2021-12-07 10:17:13 -05:00
|
|
|
use super::common::{
|
2021-12-07 10:23:52 -05:00
|
|
|
generate_voronoi_spawn_regions, paint, remove_unreachable_areas_returning_most_distant,
|
|
|
|
Symmetry,
|
2021-12-07 10:17:13 -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;
|
|
|
|
|
|
|
|
#[derive(PartialEq, Copy, Clone)]
|
|
|
|
pub enum DLAAlgorithm {
|
|
|
|
WalkInwards,
|
|
|
|
WalkOutwards,
|
|
|
|
CentralAttractor,
|
|
|
|
}
|
|
|
|
|
|
|
|
pub struct DLABuilder {
|
|
|
|
map: Map,
|
|
|
|
starting_position: Position,
|
|
|
|
depth: i32,
|
|
|
|
history: Vec<Map>,
|
|
|
|
noise_areas: HashMap<i32, Vec<usize>>,
|
|
|
|
algorithm: DLAAlgorithm,
|
|
|
|
brush_size: i32,
|
2021-12-07 10:23:52 -05:00
|
|
|
symmetry: Symmetry,
|
2021-12-07 10:17:13 -05:00
|
|
|
floor_percent: f32,
|
|
|
|
}
|
|
|
|
|
|
|
|
impl MapBuilder for DLABuilder {
|
|
|
|
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()
|
|
|
|
}
|
|
|
|
|
2021-12-10 11:30:58 -05:00
|
|
|
fn build_map(&mut self) {
|
|
|
|
self.build();
|
|
|
|
}
|
|
|
|
|
|
|
|
fn spawn_entities(&mut self, ecs: &mut World) {
|
|
|
|
for area in self.noise_areas.iter() {
|
|
|
|
spawner::spawn_region(ecs, area.1, self.depth);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-12-07 10:17:13 -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);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl DLABuilder {
|
|
|
|
pub fn new(new_depth: i32) -> DLABuilder {
|
|
|
|
DLABuilder {
|
|
|
|
map: Map::new(new_depth),
|
|
|
|
starting_position: Position::default(),
|
|
|
|
depth: new_depth,
|
|
|
|
history: Vec::new(),
|
|
|
|
noise_areas: HashMap::new(),
|
|
|
|
algorithm: DLAAlgorithm::WalkOutwards,
|
|
|
|
brush_size: 1,
|
2021-12-07 10:23:52 -05:00
|
|
|
symmetry: Symmetry::None,
|
2021-12-07 10:17:13 -05:00
|
|
|
floor_percent: 0.25,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn walk_inwards(new_depth: i32) -> DLABuilder {
|
|
|
|
DLABuilder {
|
|
|
|
algorithm: DLAAlgorithm::WalkInwards,
|
|
|
|
..DLABuilder::new(new_depth)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn walk_outwards(new_depth: i32) -> DLABuilder {
|
|
|
|
DLABuilder {
|
|
|
|
brush_size: 2,
|
|
|
|
..DLABuilder::new(new_depth)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn central_attractor(new_depth: i32) -> DLABuilder {
|
|
|
|
DLABuilder {
|
|
|
|
algorithm: DLAAlgorithm::CentralAttractor,
|
|
|
|
brush_size: 2,
|
|
|
|
..DLABuilder::new(new_depth)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn insectoid(new_depth: i32) -> DLABuilder {
|
|
|
|
DLABuilder {
|
|
|
|
algorithm: DLAAlgorithm::CentralAttractor,
|
|
|
|
brush_size: 2,
|
2021-12-07 10:23:52 -05:00
|
|
|
symmetry: Symmetry::Horizontal,
|
2021-12-07 10:17:13 -05:00
|
|
|
..DLABuilder::new(new_depth)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#[allow(clippy::map_entry)]
|
|
|
|
fn build(&mut self) {
|
|
|
|
let mut rng = RandomNumberGenerator::new();
|
|
|
|
|
|
|
|
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.take_snapshot();
|
|
|
|
|
|
|
|
// Carve a starting seed
|
|
|
|
self.map.tiles[start_idx] = TileType::Floor;
|
|
|
|
self.map.tiles[start_idx - 1] = TileType::Floor;
|
|
|
|
self.map.tiles[start_idx + 1] = TileType::Floor;
|
|
|
|
self.map.tiles[start_idx - self.map.width as usize] = TileType::Floor;
|
|
|
|
self.map.tiles[start_idx + self.map.width as usize] = TileType::Floor;
|
|
|
|
|
|
|
|
// Random walker
|
|
|
|
let total_tiles = self.map.width * self.map.height;
|
|
|
|
let desired_floor_tiles = (self.floor_percent * total_tiles as f32) as usize;
|
|
|
|
let mut floor_tile_count = self
|
|
|
|
.map
|
|
|
|
.tiles
|
|
|
|
.iter()
|
|
|
|
.filter(|a| **a == TileType::Floor)
|
|
|
|
.count();
|
|
|
|
|
|
|
|
while floor_tile_count < desired_floor_tiles {
|
|
|
|
match self.algorithm {
|
|
|
|
DLAAlgorithm::WalkInwards => {
|
|
|
|
let mut digger_x = rng.roll_dice(1, self.map.width - 3) + 1;
|
|
|
|
let mut digger_y = rng.roll_dice(1, self.map.height - 3) + 1;
|
|
|
|
let mut prev_x = digger_x;
|
|
|
|
let mut prev_y = digger_y;
|
|
|
|
let mut digger_idx = self.map.xy_idx(digger_x, digger_y);
|
|
|
|
|
|
|
|
while self.map.tiles[digger_idx] == TileType::Wall {
|
|
|
|
prev_x = digger_x;
|
|
|
|
prev_y = digger_y;
|
|
|
|
|
|
|
|
let stagger_direction = rng.roll_dice(1, 4);
|
|
|
|
match stagger_direction {
|
|
|
|
1 => {
|
|
|
|
if digger_x > 2 {
|
|
|
|
digger_x -= 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
2 => {
|
|
|
|
if digger_x < self.map.width - 2 {
|
|
|
|
digger_x += 1
|
|
|
|
}
|
|
|
|
}
|
|
|
|
3 => {
|
|
|
|
if digger_y > 2 {
|
|
|
|
digger_y -= 1
|
|
|
|
}
|
|
|
|
}
|
|
|
|
_ => {
|
|
|
|
if digger_y < self.map.height - 2 {
|
|
|
|
digger_y += 1
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
digger_idx = self.map.xy_idx(digger_x, digger_y);
|
|
|
|
}
|
|
|
|
|
2021-12-07 10:23:52 -05:00
|
|
|
paint(
|
|
|
|
&mut self.map,
|
|
|
|
self.symmetry,
|
|
|
|
self.brush_size,
|
|
|
|
prev_x,
|
|
|
|
prev_y,
|
|
|
|
);
|
2021-12-07 10:17:13 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
DLAAlgorithm::WalkOutwards => {
|
|
|
|
let mut digger_x = self.starting_position.x;
|
|
|
|
let mut digger_y = self.starting_position.y;
|
|
|
|
let mut digger_idx = self.map.xy_idx(digger_x, digger_y);
|
|
|
|
|
|
|
|
while self.map.tiles[digger_idx] == TileType::Floor {
|
|
|
|
let stagger_direction = rng.roll_dice(1, 4);
|
|
|
|
match stagger_direction {
|
|
|
|
1 => {
|
|
|
|
if digger_x > 2 {
|
|
|
|
digger_x -= 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
2 => {
|
|
|
|
if digger_x < self.map.width - 2 {
|
|
|
|
digger_x += 1
|
|
|
|
}
|
|
|
|
}
|
|
|
|
3 => {
|
|
|
|
if digger_y > 2 {
|
|
|
|
digger_y -= 1
|
|
|
|
}
|
|
|
|
}
|
|
|
|
_ => {
|
|
|
|
if digger_y < self.map.height - 2 {
|
|
|
|
digger_y += 1
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
digger_idx = self.map.xy_idx(digger_x, digger_y);
|
|
|
|
}
|
|
|
|
|
2021-12-07 10:23:52 -05:00
|
|
|
paint(
|
|
|
|
&mut self.map,
|
|
|
|
self.symmetry,
|
|
|
|
self.brush_size,
|
|
|
|
digger_x,
|
|
|
|
digger_y,
|
|
|
|
);
|
2021-12-07 10:17:13 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
DLAAlgorithm::CentralAttractor => {
|
|
|
|
let mut digger_x = rng.roll_dice(1, self.map.width - 3) + 1;
|
|
|
|
let mut digger_y = rng.roll_dice(1, self.map.height - 3) + 1;
|
|
|
|
let mut prev_x = digger_x;
|
|
|
|
let mut prev_y = digger_y;
|
|
|
|
let mut digger_idx = self.map.xy_idx(digger_x, digger_y);
|
|
|
|
|
|
|
|
let mut path = rltk::line2d(
|
|
|
|
rltk::LineAlg::Bresenham,
|
|
|
|
rltk::Point::new(digger_x, digger_y),
|
|
|
|
rltk::Point::new(self.starting_position.x, self.starting_position.y),
|
|
|
|
);
|
|
|
|
|
|
|
|
while self.map.tiles[digger_idx] == TileType::Wall && !path.is_empty() {
|
|
|
|
prev_x = digger_x;
|
|
|
|
prev_y = digger_y;
|
|
|
|
digger_x = path[0].x;
|
|
|
|
digger_y = path[0].y;
|
|
|
|
path.remove(0);
|
|
|
|
digger_idx = self.map.xy_idx(digger_x, digger_y);
|
|
|
|
}
|
|
|
|
|
2021-12-07 10:23:52 -05:00
|
|
|
paint(
|
|
|
|
&mut self.map,
|
|
|
|
self.symmetry,
|
|
|
|
self.brush_size,
|
|
|
|
prev_x,
|
|
|
|
prev_y,
|
|
|
|
);
|
2021-12-07 10:17:13 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
self.take_snapshot();
|
|
|
|
|
|
|
|
floor_tile_count = self
|
|
|
|
.map
|
|
|
|
.tiles
|
|
|
|
.iter()
|
|
|
|
.filter(|a| **a == TileType::Floor)
|
|
|
|
.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);
|
|
|
|
}
|
|
|
|
}
|