150 lines
3.7 KiB
Rust
150 lines
3.7 KiB
Rust
mod world;
|
|
mod state;
|
|
mod events;
|
|
mod time;
|
|
mod generators;
|
|
mod creature;
|
|
mod site;
|
|
mod ui;
|
|
mod entity;
|
|
mod game;
|
|
mod item;
|
|
|
|
use ui::App;
|
|
use noise::{Perlin, ScalePoint, Add, NoiseFn, ScaleBias};
|
|
use noise::utils::{NoiseMapBuilder, PlaneMapBuilder};
|
|
use image::{RgbImage, Rgb};
|
|
use rand::prelude::*;
|
|
use world::World;
|
|
|
|
use std::{io};
|
|
use tui::{
|
|
backend::CrosstermBackend,
|
|
Terminal
|
|
};
|
|
use crossterm::{
|
|
event::{DisableMouseCapture, EnableMouseCapture},
|
|
execute,
|
|
terminal::{disable_raw_mode, enable_raw_mode, EnterAlternateScreen, LeaveAlternateScreen},
|
|
};
|
|
|
|
|
|
const N_TOWNS: usize = 10;
|
|
const WORLD_SIZE: usize = 256;
|
|
|
|
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 build_world() -> World {
|
|
let mut rng = rand::thread_rng();
|
|
|
|
let map_center = WORLD_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],
|
|
WORLD_SIZE as f64 * 0.4,
|
|
100.0
|
|
),
|
|
);
|
|
|
|
let plane = PlaneMapBuilder::<_, 2>::new(&height)
|
|
.set_size(WORLD_SIZE, WORLD_SIZE)
|
|
.set_x_bounds(0.0, WORLD_SIZE as f64)
|
|
.set_y_bounds(0.0, WORLD_SIZE as f64)
|
|
.build();
|
|
|
|
let mut img = RgbImage::new(WORLD_SIZE as u32, WORLD_SIZE as u32);
|
|
|
|
let mut world = world::World::new(WORLD_SIZE);
|
|
|
|
for x in 0..WORLD_SIZE {
|
|
for y in 0..WORLD_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()));
|
|
}
|
|
}
|
|
|
|
world
|
|
}
|
|
|
|
fn main() -> Result<(), io::Error> {
|
|
// build game state
|
|
let mut world_state = state::GameState::new(build_world());
|
|
world_state.time = world_state.time.add_years(100);
|
|
let mut rng = rand::thread_rng();
|
|
for _ in 0..N_TOWNS {
|
|
world_state.time = world_state.time.add_days(rng.gen_range(0..360*3));
|
|
world_state.found_town();
|
|
}
|
|
world_state.build_tavern();
|
|
// insert state into game
|
|
let game = game::Game::new(world_state);
|
|
|
|
|
|
// setup terminal
|
|
enable_raw_mode()?;
|
|
let mut stdout = io::stdout();
|
|
execute!(stdout, EnterAlternateScreen, EnableMouseCapture)?;
|
|
let backend = CrosstermBackend::new(stdout);
|
|
let mut terminal = Terminal::new(backend)?;
|
|
|
|
let mut app = App::new(game);
|
|
loop {
|
|
terminal.draw(|f| app.draw(f))?;
|
|
if !app.step() {
|
|
break;
|
|
}
|
|
// terminal.draw(|f| app.draw(f))?;
|
|
}
|
|
|
|
// restore terminal
|
|
disable_raw_mode()?;
|
|
execute!(
|
|
terminal.backend_mut(),
|
|
LeaveAlternateScreen,
|
|
DisableMouseCapture
|
|
)?;
|
|
terminal.show_cursor()?;
|
|
|
|
Ok(())
|
|
|
|
} |