diff --git a/src/map_builders.rs b/src/map_builders.rs index 0be014d..0859960 100644 --- a/src/map_builders.rs +++ b/src/map_builders.rs @@ -67,8 +67,15 @@ pub fn random_builder(new_depth: i32) -> Box { // // result - Box::new(PrefabBuilder::new( + Box::new(PrefabBuilder::vaults( new_depth, - Some(Box::new(SimpleMapBuilder::new(new_depth))), + Box::new(PrefabBuilder::sectional( + new_depth, + prefab_builder::prefab_sections::UNDERGROUND_FORT, + Box::new(WaveformCollapseBuilder::derived_map( + new_depth, + Box::new(CellularAutomataBuilder::new(new_depth)), + )), + )), )) } diff --git a/src/map_builders/prefab_builder.rs b/src/map_builders/prefab_builder.rs index e0221ef..58b4863 100644 --- a/src/map_builders/prefab_builder.rs +++ b/src/map_builders/prefab_builder.rs @@ -1,6 +1,8 @@ -mod prefab_levels; -mod prefab_rooms; -mod prefab_sections; +pub mod prefab_levels; +pub mod prefab_rooms; +pub mod prefab_sections; + +use std::collections::HashSet; use rltk::RandomNumberGenerator; use specs::prelude::*; @@ -8,7 +10,7 @@ use specs::prelude::*; use super::{remove_unreachable_areas_returning_most_distant, MapBuilder}; use crate::{spawner, Map, Position, TileType, SHOW_MAPGEN_VISUALIZER}; -#[derive(PartialEq, Clone)] +#[derive(PartialEq, Copy, Clone)] #[allow(dead_code)] pub enum PrefabMode { RexLevel { @@ -23,6 +25,7 @@ pub enum PrefabMode { RoomVaults, } +#[allow(dead_code)] pub struct PrefabBuilder { map: Map, starting_position: Position, @@ -79,9 +82,65 @@ impl PrefabBuilder { } } + #[allow(dead_code)] + pub fn rex_level(new_depth: i32, template: &'static str) -> PrefabBuilder { + PrefabBuilder { + map: Map::new(new_depth), + starting_position: Position { x: 0, y: 0 }, + depth: new_depth, + history: Vec::new(), + mode: PrefabMode::RexLevel { template }, + previous_builder: None, + spawn_list: Vec::new(), + } + } + + #[allow(dead_code)] + pub fn constant(new_depth: i32, level: prefab_levels::PrefabLevel) -> PrefabBuilder { + PrefabBuilder { + map: Map::new(new_depth), + starting_position: Position { x: 0, y: 0 }, + depth: new_depth, + history: Vec::new(), + mode: PrefabMode::Constant { level }, + previous_builder: None, + spawn_list: Vec::new(), + } + } + + #[allow(dead_code)] + pub fn sectional( + new_depth: i32, + section: prefab_sections::PrefabSection, + previous_builder: Box, + ) -> PrefabBuilder { + PrefabBuilder { + map: Map::new(new_depth), + starting_position: Position { x: 0, y: 0 }, + depth: new_depth, + history: Vec::new(), + mode: PrefabMode::Sectional { section }, + previous_builder: Some(previous_builder), + spawn_list: Vec::new(), + } + } + + #[allow(dead_code)] + pub fn vaults(new_depth: i32, previous_builder: Box) -> PrefabBuilder { + PrefabBuilder { + map: Map::new(new_depth), + starting_position: Position { x: 0, y: 0 }, + depth: new_depth, + history: Vec::new(), + mode: PrefabMode::RoomVaults, + previous_builder: Some(previous_builder), + spawn_list: Vec::new(), + } + } + fn build(&mut self) { match self.mode { - PrefabMode::RexLevel { template } => self.load_rex_map(template), + PrefabMode::RexLevel { template } => self.load_rex_map(&template), PrefabMode::Constant { level } => self.load_ascii_map(&level), PrefabMode::Sectional { section } => self.apply_sectional(§ion), PrefabMode::RoomVaults => self.apply_room_vaults(), @@ -89,12 +148,13 @@ impl PrefabBuilder { self.take_snapshot(); // Find a starting point; start at the middle and walk left until we find an open tile + let mut start_idx; if self.starting_position.x == 0 { self.starting_position = Position { x: self.map.width / 2, y: self.map.height / 2, }; - let mut start_idx = self + start_idx = self .map .xy_idx(self.starting_position.x, self.starting_position.y); while self.map.tiles[start_idx] != TileType::Floor { @@ -104,6 +164,18 @@ impl PrefabBuilder { .xy_idx(self.starting_position.x, self.starting_position.y); } self.take_snapshot(); + } + let mut has_exit = false; + for t in self.map.tiles.iter() { + if *t == TileType::DownStairs { + has_exit = true; + } + } + + if !has_exit { + start_idx = self + .map + .xy_idx(self.starting_position.x, self.starting_position.y); // Find all tiles we can reach from the starting point let exit_tile = @@ -179,20 +251,17 @@ impl PrefabBuilder { .chars() .filter(|a| *a != '\r' && *a != '\n') .collect(); - for c in string_vec.iter_mut() { if *c as u8 == 160_u8 { *c = ' '; } } - string_vec } #[allow(dead_code)] fn load_ascii_map(&mut self, level: &prefab_levels::PrefabLevel) { - // Start by converting to a vector, with newlines removed - let string_vec = Self::read_ascii_to_vec(level.template); + let string_vec = PrefabBuilder::read_ascii_to_vec(level.template); let mut i = 0; for ty in 0..level.height { @@ -201,7 +270,6 @@ impl PrefabBuilder { let idx = self.map.xy_idx(tx as i32, ty as i32); self.char_to_map(string_vec[i], idx); } - i += 1; } } @@ -215,13 +283,12 @@ impl PrefabBuilder { let prev_builder = self.previous_builder.as_mut().unwrap(); prev_builder.build_map(); self.starting_position = prev_builder.get_starting_position(); - self.map = prev_builder.get_map(); + self.map = prev_builder.get_map().clone(); self.history = prev_builder.get_snapshot_history(); for e in prev_builder.get_spawn_list().iter() { let idx = e.0; let x = idx as i32 % self.map.width; let y = idx as i32 / self.map.width; - if filter(x, y, e) { self.spawn_list.push((idx, e.1.to_string())) } @@ -229,10 +296,11 @@ impl PrefabBuilder { self.take_snapshot(); } - pub fn apply_sectional(&mut self, section: &prefab_sections::PrefabSection) { + #[allow(dead_code)] + fn apply_sectional(&mut self, section: &prefab_sections::PrefabSection) { use prefab_sections::*; - let string_vec = Self::read_ascii_to_vec(section.template); + let string_vec = PrefabBuilder::read_ascii_to_vec(section.template); // Place the new section let chunk_x = match section.placement.0 { @@ -248,7 +316,7 @@ impl PrefabBuilder { }; // Build the map - self.apply_previous_iteration(|x, y, e| { + self.apply_previous_iteration(|x, y, _e| { x < chunk_x || x > (chunk_x + section.width as i32) || y < chunk_y @@ -258,7 +326,11 @@ impl PrefabBuilder { let mut i = 0; for ty in 0..section.height { for tx in 0..section.width { - if tx < self.map.width as usize && ty < self.map.height as usize { + if tx > 0 + && tx < self.map.width as usize - 1 + && ty < self.map.height as usize - 1 + && ty > 0 + { let idx = self.map.xy_idx(tx as i32 + chunk_x, ty as i32 + chunk_y); self.char_to_map(string_vec[i], idx); } @@ -275,11 +347,17 @@ impl PrefabBuilder { // Apply the previous builder, and keep all entities it spawns (for now) self.apply_previous_iteration(|_x, _y, _e| true); + // Do we want a vault at all? + let vault_roll = rng.roll_dice(1, 6) + self.depth; + if vault_roll < 4 { + return; + } + // Note that this is a place-holder and will be moved out of this function let master_vault_list = vec![TOTALLY_NOT_A_TRAP, CHECKERBOARD, SILLY_SMILE]; - // Filter the possible vault list down to ones that are application to the current depth - let possible_vaults: Vec<&PrefabRoom> = master_vault_list + // Filter the vault list down to ones that are applicable to the current depth + let mut possible_vaults: Vec<&PrefabRoom> = master_vault_list .iter() .filter(|v| self.depth >= v.first_depth && self.depth <= v.last_depth) .collect(); @@ -289,40 +367,48 @@ impl PrefabBuilder { return; } - let vault_index = if possible_vaults.len() == 1 { - 0 - } else { - (rng.roll_dice(1, possible_vaults.len() as i32) - 1) as usize - }; - let vault = possible_vaults[vault_index]; + let n_vaults = i32::min(rng.roll_dice(1, 3), possible_vaults.len() as i32); + let mut used_tiles: HashSet = HashSet::new(); - // We'll make a list of places in which the vault could fit - let mut vault_positions: Vec = Vec::new(); + for _i in 0..n_vaults { + let vault_index = if possible_vaults.len() == 1 { + 0 + } else { + (rng.roll_dice(1, possible_vaults.len() as i32) - 1) as usize + }; + let vault = possible_vaults[vault_index]; - let mut idx = 0_usize; - loop { - let x = (idx % self.map.width as usize) as i32; - let y = (idx / self.map.width as usize) as i32; + // We'll make a list of places in which the vault could fit + let mut vault_positions: Vec = Vec::new(); - // Check that we won't overflow the map - if x > 1 - && (x + vault.width as i32) < self.map.width - 2 - && y > 1 - && (y + vault.height as i32) < self.map.height - 2 - { - let mut possible = true; - for ty in 0..vault.height as i32 { - for tx in 0..vault.width as i32 { - let idx = self.map.xy_idx(tx + x, ty + y); - if self.map.tiles[idx] != TileType::Floor { - possible = false; + let mut idx = 0usize; + loop { + let x = (idx % self.map.width as usize) as i32; + let y = (idx / self.map.width as usize) as i32; + + // Check that we won't overflow the map + if x > 1 + && (x + vault.width as i32) < self.map.width - 2 + && y > 1 + && (y + vault.height as i32) < self.map.height - 2 + { + let mut possible = true; + for ty in 0..vault.height as i32 { + for tx in 0..vault.width as i32 { + let idx = self.map.xy_idx(tx + x, ty + y); + if self.map.tiles[idx] != TileType::Floor { + possible = false; + } + if used_tiles.contains(&idx) { + possible = false; + } } } - } - if possible { - vault_positions.push(Position { x, y }); - break; + if possible { + vault_positions.push(Position { x, y }); + break; + } } idx += 1; @@ -330,41 +416,44 @@ impl PrefabBuilder { break; } } - } - if !vault_positions.is_empty() { - let pos_idx = if vault_positions.len() == 1 { - 0 - } else { - (rng.roll_dice(1, vault_positions.len() as i32) - 1) as usize - }; - let pos = &vault_positions[pos_idx]; + if !vault_positions.is_empty() { + let pos_idx = if vault_positions.len() == 1 { + 0 + } else { + (rng.roll_dice(1, vault_positions.len() as i32) - 1) as usize + }; + let pos = &vault_positions[pos_idx]; - let chunk_x = pos.x; - let chunk_y = pos.y; + let chunk_x = pos.x; + let chunk_y = pos.y; - let width = self.map.width; - let height = self.map.height; - self.spawn_list.retain(|e| { - let idx = e.0 as i32; - let x = idx % width; - let y = idx / height; - x < chunk_x - || x > chunk_x + vault.width as i32 - || y < chunk_y - || y > chunk_y + vault.height as i32 - }); + let width = self.map.width; // The borrow checker really doesn't like it + let height = self.map.height; // when we access `self` inside the `retain` + self.spawn_list.retain(|e| { + let idx = e.0 as i32; + let x = idx % width; + let y = idx / height; + x < chunk_x + || x > chunk_x + vault.width as i32 + || y < chunk_y + || y > chunk_y + vault.height as i32 + }); - let string_vec = PrefabBuilder::read_ascii_to_vec(vault.template); - let mut i = 0; - for ty in 0..vault.height { - for tx in 0..vault.width { - let idx = self.map.xy_idx(tx as i32 + chunk_x, ty as i32 + chunk_y); - self.char_to_map(string_vec[i], idx); - i += 1; + let string_vec = PrefabBuilder::read_ascii_to_vec(vault.template); + let mut i = 0; + for ty in 0..vault.height { + for tx in 0..vault.width { + let idx = self.map.xy_idx(tx as i32 + chunk_x, ty as i32 + chunk_y); + self.char_to_map(string_vec[i], idx); + used_tiles.insert(idx); + i += 1; + } } + self.take_snapshot(); + + possible_vaults.remove(vault_index); } - self.take_snapshot(); } } }