roguelike-game/src/map_builders/drunkard.rs

281 lines
8.2 KiB
Rust
Raw Normal View History

2021-12-06 14:23:35 -05:00
use super::common::{
2021-12-07 10:36:41 -05:00
generate_voronoi_spawn_regions, paint, remove_unreachable_areas_returning_most_distant,
Symmetry,
2021-12-06 14:23:35 -05:00
};
2021-12-03 19:33:56 -05:00
use super::MapBuilder;
use crate::{components::Position, spawner, Map, TileType, SHOW_MAPGEN_VISUALIZER};
use rltk::RandomNumberGenerator;
use specs::prelude::*;
use std::collections::HashMap;
2021-12-06 14:23:35 -05:00
#[derive(PartialEq, Copy, Clone)]
pub enum DrunkSpawnMode {
StaringPoint,
Random,
}
pub struct DrunkardSettings {
pub spawn_mode: DrunkSpawnMode,
pub drunken_lifetime: i32,
pub floor_percent: f32,
2021-12-07 10:36:41 -05:00
pub brush_size: i32,
pub symmetry: Symmetry,
2021-12-06 14:23:35 -05:00
}
2021-12-03 19:33:56 -05:00
pub struct DrunkardsWalkBuilder {
map: Map,
starting_position: Position,
depth: i32,
history: Vec<Map>,
noise_areas: HashMap<i32, Vec<usize>>,
2021-12-06 14:23:35 -05:00
settings: DrunkardSettings,
spawn_list: Vec<(usize, String)>,
2021-12-03 19:33:56 -05:00
}
impl MapBuilder for DrunkardsWalkBuilder {
fn get_map(&self) -> Map {
self.map.clone()
}
fn get_starting_position(&self) -> Position {
self.starting_position
}
fn get_snapshot_history(&self) -> Vec<Map> {
self.history.clone()
}
fn build_map(&mut self) {
self.build();
}
2021-12-03 19:33:56 -05:00
fn take_snapshot(&mut self) {
if SHOW_MAPGEN_VISUALIZER {
let mut snapshot = self.map.clone();
for v in snapshot.revealed_tiles.iter_mut() {
*v = true;
}
self.history.push(snapshot);
}
}
fn get_spawn_list(&self) -> &Vec<(usize, String)> {
&self.spawn_list
}
2021-12-03 19:33:56 -05:00
}
impl DrunkardsWalkBuilder {
2021-12-06 14:23:35 -05:00
pub fn new(new_depth: i32, settings: DrunkardSettings) -> DrunkardsWalkBuilder {
2021-12-03 19:33:56 -05:00
DrunkardsWalkBuilder {
map: Map::new(new_depth),
starting_position: Position::default(),
depth: new_depth,
history: Vec::new(),
noise_areas: HashMap::new(),
2021-12-06 14:23:35 -05:00
settings,
spawn_list: Vec::new(),
2021-12-03 19:33:56 -05:00
}
}
2021-12-06 14:23:35 -05:00
pub fn open_area(new_depth: i32) -> DrunkardsWalkBuilder {
DrunkardsWalkBuilder::new(
new_depth,
DrunkardSettings {
spawn_mode: DrunkSpawnMode::StaringPoint,
drunken_lifetime: 400,
floor_percent: 0.5,
2021-12-07 10:36:41 -05:00
brush_size: 1,
symmetry: Symmetry::None,
2021-12-06 14:23:35 -05:00
},
)
}
pub fn open_halls(new_depth: i32) -> DrunkardsWalkBuilder {
DrunkardsWalkBuilder::new(
new_depth,
DrunkardSettings {
spawn_mode: DrunkSpawnMode::Random,
drunken_lifetime: 400,
floor_percent: 0.5,
2021-12-07 10:36:41 -05:00
brush_size: 1,
symmetry: Symmetry::None,
2021-12-06 14:23:35 -05:00
},
)
}
pub fn winding_passages(new_depth: i32) -> DrunkardsWalkBuilder {
DrunkardsWalkBuilder::new(
new_depth,
DrunkardSettings {
spawn_mode: DrunkSpawnMode::Random,
drunken_lifetime: 100,
floor_percent: 0.4,
2021-12-07 10:36:41 -05:00
brush_size: 1,
symmetry: Symmetry::None,
},
)
}
pub fn fat_passages(new_depth: i32) -> DrunkardsWalkBuilder {
DrunkardsWalkBuilder::new(
new_depth,
DrunkardSettings {
spawn_mode: DrunkSpawnMode::Random,
drunken_lifetime: 100,
floor_percent: 0.4,
brush_size: 2,
symmetry: Symmetry::None,
},
)
}
pub fn fearful_symmetry(new_depth: i32) -> DrunkardsWalkBuilder {
DrunkardsWalkBuilder::new(
new_depth,
DrunkardSettings {
spawn_mode: DrunkSpawnMode::Random,
drunken_lifetime: 100,
floor_percent: 0.4,
brush_size: 1,
symmetry: Symmetry::Both,
2021-12-06 14:23:35 -05:00
},
)
}
2021-12-03 19:33:56 -05:00
#[allow(clippy::map_entry)]
fn build(&mut self) {
2021-12-06 14:23:35 -05:00
let mut rng = RandomNumberGenerator::new();
2021-12-03 19:33:56 -05:00
// Set a central starting point
self.starting_position = Position {
x: self.map.width / 2,
y: self.map.height / 2,
};
let start_idx = self
.map
.xy_idx(self.starting_position.x, self.starting_position.y);
self.map.tiles[start_idx] = TileType::Floor;
2021-12-06 14:23:35 -05:00
let total_tiles = self.map.width * self.map.height;
let desired_floor_tiles = (self.settings.floor_percent * total_tiles as f32) as usize;
let mut floor_tile_count = self
.map
.tiles
.iter()
.filter(|a| **a == TileType::Floor)
.count();
let mut digger_count = 0;
let mut active_digger_count = 0;
while floor_tile_count < desired_floor_tiles {
let mut did_something = false;
let mut drunk_x;
let mut drunk_y;
match self.settings.spawn_mode {
DrunkSpawnMode::StaringPoint => {
drunk_x = self.starting_position.x;
drunk_y = self.starting_position.y;
}
DrunkSpawnMode::Random => {
if digger_count == 0 {
drunk_x = self.starting_position.x;
drunk_y = self.starting_position.y;
} else {
drunk_x = rng.roll_dice(1, self.map.width - 3) + 1;
drunk_y = rng.roll_dice(1, self.map.height - 3) + 1;
}
}
}
let mut drunk_life = self.settings.drunken_lifetime;
while drunk_life > 0 {
let drunk_idx = self.map.xy_idx(drunk_x, drunk_y);
if self.map.tiles[drunk_idx] == TileType::Wall {
did_something = true;
}
2021-12-07 10:36:41 -05:00
paint(
&mut self.map,
self.settings.symmetry,
self.settings.brush_size,
drunk_x,
drunk_y,
);
2021-12-06 14:23:35 -05:00
self.map.tiles[drunk_idx] = TileType::DownStairs;
let stagger_direction = rng.roll_dice(1, 4);
match stagger_direction {
1 => {
if drunk_x > 2 {
drunk_x -= 1;
}
}
2 => {
if drunk_x < self.map.width - 2 {
drunk_x += 1
}
}
3 => {
if drunk_y > 2 {
drunk_y -= 1
}
}
_ => {
if drunk_y < self.map.height - 2 {
drunk_y += 1
}
}
}
drunk_life -= 1;
}
if did_something {
self.take_snapshot();
active_digger_count += 1;
}
digger_count += 1;
for t in self.map.tiles.iter_mut() {
if *t == TileType::DownStairs {
*t = TileType::Floor;
}
}
floor_tile_count = self
.map
.tiles
.iter()
.filter(|a| **a == TileType::Floor)
.count();
}
rltk::console::log(format!(
"{} dwarves gave up their sobriety, of whom {} actually found a wall.",
digger_count, active_digger_count
));
// Find all tiles we can reach from the starting point
let exit_tile = remove_unreachable_areas_returning_most_distant(&mut self.map, start_idx);
self.take_snapshot();
// Place the stairs
self.map.tiles[exit_tile] = TileType::DownStairs;
self.take_snapshot();
// Now we build a noise map for use in spawning entities later
self.noise_areas = generate_voronoi_spawn_regions(&self.map, &mut rng);
// Spawn the entities
for area in self.noise_areas.iter() {
spawner::spawn_region(
&self.map,
&mut rng,
area.1,
self.depth,
&mut self.spawn_list,
);
}
2021-12-03 19:33:56 -05:00
}
}