From 8a596bf93c34fb50995fd02ebf2529cfc8e730fb Mon Sep 17 00:00:00 2001 From: Timothy Warren Date: Wed, 15 Dec 2021 10:57:30 -0500 Subject: [PATCH] Refactor voronoi builder to use Rust builder pattern --- src/map_builders/voronoi.rs | 157 +++++++++--------------------------- 1 file changed, 38 insertions(+), 119 deletions(-) diff --git a/src/map_builders/voronoi.rs b/src/map_builders/voronoi.rs index aa1f9f5..f9d2950 100644 --- a/src/map_builders/voronoi.rs +++ b/src/map_builders/voronoi.rs @@ -2,11 +2,8 @@ use std::collections::HashMap; use rltk::RandomNumberGenerator; -use super::common::{ - generate_voronoi_spawn_regions, remove_unreachable_areas_returning_most_distant, -}; -use super::MapBuilder; use crate::components::Position; +use crate::map_builders::{BuilderMap, InitialMapBuilder}; use crate::{spawner, Map, TileType, SHOW_MAPGEN_VISUALIZER}; #[derive(PartialEq, Copy, Clone)] @@ -18,84 +15,46 @@ pub enum DistanceAlgorithm { } pub struct VoronoiCellBuilder { - map: Map, - starting_position: Position, - depth: i32, - history: Vec, - noise_areas: HashMap>, n_seeds: usize, distance_algorithm: DistanceAlgorithm, - spawn_list: Vec<(usize, String)>, } -impl MapBuilder for VoronoiCellBuilder { - fn get_map(&self) -> Map { - self.map.clone() - } - - fn get_starting_position(&self) -> Position { - self.starting_position - } - - fn get_snapshot_history(&self) -> Vec { - self.history.clone() - } - - fn build_map(&mut self) { - self.build(); - } - - 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 +impl InitialMapBuilder for VoronoiCellBuilder { + fn build_map(&mut self, rng: &mut RandomNumberGenerator, build_data: &mut BuilderMap) { + self.build(rng, build_data); } } impl VoronoiCellBuilder { - pub fn new(new_depth: i32) -> VoronoiCellBuilder { + pub fn new() -> VoronoiCellBuilder { VoronoiCellBuilder { - map: Map::new(new_depth), - starting_position: Position::default(), - depth: new_depth, - history: Vec::new(), - noise_areas: HashMap::new(), n_seeds: 64, distance_algorithm: DistanceAlgorithm::Pythagoras, - spawn_list: Vec::new(), } } - pub fn pythagoras(new_depth: i32) -> VoronoiCellBuilder { - VoronoiCellBuilder::new(new_depth) + #[allow(dead_code)] + pub fn pythagoras() -> Box { + Box::new(VoronoiCellBuilder::new()) } - pub fn manhattan(new_depth: i32) -> VoronoiCellBuilder { - VoronoiCellBuilder { + #[allow(dead_code)] + pub fn manhattan() -> Box { + Box::new(VoronoiCellBuilder { distance_algorithm: DistanceAlgorithm::Manhattan, - ..VoronoiCellBuilder::new(new_depth) - } + ..VoronoiCellBuilder::new() + }) } #[allow(clippy::map_entry)] - fn build(&mut self) { - let mut rng = RandomNumberGenerator::new(); - + fn build(&mut self, rng: &mut RandomNumberGenerator, build_data: &mut BuilderMap) { // Make a Voronoi diagram. We'll do this the hard way to learn about the technique! let mut voronoi_seeds: Vec<(usize, rltk::Point)> = Vec::new(); while voronoi_seeds.len() < self.n_seeds { - let vx = rng.roll_dice(1, self.map.width - 1); - let vy = rng.roll_dice(1, self.map.height - 1); - let vidx = self.map.xy_idx(vx, vy); + let vx = rng.roll_dice(1, build_data.map.width - 1); + let vy = rng.roll_dice(1, build_data.map.height - 1); + let vidx = build_data.map.xy_idx(vx, vy); let candidate = (vidx, rltk::Point::new(vx, vy)); if !voronoi_seeds.contains(&candidate) { voronoi_seeds.push(candidate); @@ -104,27 +63,25 @@ impl VoronoiCellBuilder { let mut voronoi_distance = vec![(0, 0.0f32); self.n_seeds]; let mut voronoi_membership: Vec = - vec![0; self.map.width as usize * self.map.height as usize]; + vec![0; build_data.map.width as usize * build_data.map.height as usize]; + for (i, vid) in voronoi_membership.iter_mut().enumerate() { - let x = i as i32 % self.map.width; - let y = i as i32 / self.map.width; + let x = i as i32 % build_data.map.width; + let y = i as i32 / build_data.map.width; for (seed, pos) in voronoi_seeds.iter().enumerate() { - let distance; - match self.distance_algorithm { - DistanceAlgorithm::Pythagoras => { - distance = rltk::DistanceAlg::PythagorasSquared - .distance2d(rltk::Point::new(x, y), pos.1); - } + let distance = match self.distance_algorithm { + DistanceAlgorithm::Pythagoras => rltk::DistanceAlg::PythagorasSquared + .distance2d(rltk::Point::new(x, y), pos.1), + DistanceAlgorithm::Manhattan => { - distance = - rltk::DistanceAlg::Manhattan.distance2d(rltk::Point::new(x, y), pos.1); + rltk::DistanceAlg::Manhattan.distance2d(rltk::Point::new(x, y), pos.1) } + DistanceAlgorithm::Chebyshev => { - distance = - rltk::DistanceAlg::Chebyshev.distance2d(rltk::Point::new(x, y), pos.1); + rltk::DistanceAlg::Chebyshev.distance2d(rltk::Point::new(x, y), pos.1) } - } + }; voronoi_distance[seed] = (seed, distance); } @@ -133,68 +90,30 @@ impl VoronoiCellBuilder { *vid = voronoi_distance[0].0 as i32; } - for y in 1..self.map.height - 1 { - for x in 1..self.map.width - 1 { + for y in 1..build_data.map.height - 1 { + for x in 1..build_data.map.width - 1 { let mut neighbors = 0; - let my_idx = self.map.xy_idx(x, y); + let my_idx = build_data.map.xy_idx(x, y); let my_seed = voronoi_membership[my_idx]; - if voronoi_membership[self.map.xy_idx(x - 1, y)] != my_seed { + if voronoi_membership[build_data.map.xy_idx(x - 1, y)] != my_seed { neighbors += 1; } - if voronoi_membership[self.map.xy_idx(x + 1, y)] != my_seed { + if voronoi_membership[build_data.map.xy_idx(x + 1, y)] != my_seed { neighbors += 1; } - if voronoi_membership[self.map.xy_idx(x, y - 1)] != my_seed { + if voronoi_membership[build_data.map.xy_idx(x, y - 1)] != my_seed { neighbors += 1; } - if voronoi_membership[self.map.xy_idx(x, y + 1)] != my_seed { + if voronoi_membership[build_data.map.xy_idx(x, y + 1)] != my_seed { neighbors += 1; } if neighbors < 2 { - self.map.tiles[my_idx] = TileType::Floor; + build_data.map.tiles[my_idx] = TileType::Floor; } } - self.take_snapshot(); - } - - // Find a starting point; start at the middle and walk left until we find an open tile - self.starting_position = Position { - x: self.map.width / 2, - y: self.map.height / 2, - }; - let mut start_idx = self - .map - .xy_idx(self.starting_position.x, self.starting_position.y); - while self.map.tiles[start_idx] != TileType::Floor { - self.starting_position.x -= 1; - start_idx = self - .map - .xy_idx(self.starting_position.x, self.starting_position.y); - } - self.take_snapshot(); - - // 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, - ); + build_data.take_snapshot(); } } }