114 lines
3.0 KiB
Rust
114 lines
3.0 KiB
Rust
mod world;
|
|
mod state;
|
|
|
|
use noise::{Perlin, ScalePoint, Add, NoiseFn, Multiply, ScaleBias};
|
|
use noise::utils::{NoiseMapBuilder, PlaneMapBuilder};
|
|
use image::{RgbImage, Rgb};
|
|
use rand::prelude::*;
|
|
|
|
struct BorderNoise {
|
|
pub center: [f64; 2],
|
|
pub radius: f64,
|
|
pub falloff: f64,
|
|
}
|
|
|
|
impl BorderNoise {
|
|
pub fn new(center: [f64; 2], radius: f64, falloff: f64) -> BorderNoise {
|
|
BorderNoise {
|
|
center: center,
|
|
radius: radius,
|
|
falloff: falloff
|
|
}
|
|
}
|
|
}
|
|
|
|
impl NoiseFn<f64, 2> for BorderNoise {
|
|
fn get(&self, _point: [f64; 2]) -> f64 {
|
|
let dist = (
|
|
(self.center[0] - _point[0]).powi(2) +
|
|
(self.center[1] - _point[1]).powi(2)
|
|
).sqrt();
|
|
if dist > self.radius {
|
|
1.0 - ((dist - self.radius) * self.falloff)
|
|
} else {
|
|
1.0
|
|
}
|
|
}
|
|
}
|
|
|
|
fn main() {
|
|
|
|
let N_TOWNS = 10;
|
|
|
|
let mut rng = rand::thread_rng();
|
|
|
|
let map_size = 256;
|
|
let map_center = map_size / 2;
|
|
let height = Add::new(
|
|
ScaleBias::new(
|
|
Add::new(
|
|
ScalePoint::new(Perlin::new(rng.gen::<u32>()))
|
|
.set_x_scale(0.04)
|
|
.set_y_scale(0.04),
|
|
ScalePoint::new(Perlin::new(rng.gen::<u32>()))
|
|
.set_x_scale(0.011)
|
|
.set_y_scale(0.011),
|
|
),
|
|
).set_scale(2000.0).set_bias(1000.0),
|
|
BorderNoise::new(
|
|
[map_center as f64, map_center as f64],
|
|
map_size as f64 * 0.4,
|
|
100.0
|
|
),
|
|
);
|
|
|
|
let plane = PlaneMapBuilder::<_, 2>::new(&height)
|
|
.set_size(map_size, map_size)
|
|
.set_x_bounds(0.0, map_size as f64)
|
|
.set_y_bounds(0.0, map_size as f64)
|
|
.build();
|
|
|
|
let min = plane.iter().fold(f64::MAX, |min, &val| val.min(min));
|
|
let max = plane.iter().fold(f64::MIN, |max, &val| val.max(max));
|
|
|
|
println!("Min: {}", min);
|
|
println!("Max: {}", max);
|
|
|
|
|
|
let mut img = RgbImage::new(map_size as u32, map_size as u32);
|
|
|
|
let mut world = world::World::new(map_size);
|
|
|
|
for x in 0..map_size {
|
|
for y in 0..map_size {
|
|
let h = plane.get_value(x, y);
|
|
let t = world::Terrain::from_height(h);
|
|
world.map[x][y] = world::WorldCell::new(t);
|
|
img.put_pixel(x as u32, y as u32, Rgb(t.to_color()));
|
|
}
|
|
}
|
|
|
|
let mut placed = 0;
|
|
while placed < N_TOWNS {
|
|
let x = rng.gen_range(0..map_size);
|
|
let y = rng.gen_range(0..map_size);
|
|
if
|
|
world.map[x][y].terrain == world::Terrain::Flats ||
|
|
world.map[x][y].terrain == world::Terrain::Hills
|
|
{
|
|
world.add_structure(x, y, world::Structure::Town(world::Town::new()));
|
|
placed += 1;
|
|
img.put_pixel(x as u32, y as u32, Rgb([255, 0, 0]));
|
|
}
|
|
}
|
|
|
|
let scaled = image::imageops::resize(
|
|
&img,
|
|
map_size as u32 * 4, map_size as u32 * 4,
|
|
image::imageops::FilterType::Nearest);
|
|
|
|
scaled.save("world.png").unwrap();
|
|
|
|
|
|
|
|
} |