492 lines
14 KiB
Rust
492 lines
14 KiB
Rust
use super::{ spawner, Map, Position, Rect, TileType };
|
|
use bracket_lib::prelude::*;
|
|
|
|
mod bsp_dungeon;
|
|
use bsp_dungeon::BspDungeonBuilder;
|
|
mod bsp_interior;
|
|
use bsp_interior::BspInteriorBuilder;
|
|
mod cellular_automata;
|
|
use cellular_automata::CellularAutomataBuilder;
|
|
mod common;
|
|
mod dla;
|
|
use dla::DLABuilder;
|
|
mod drunkard;
|
|
use drunkard::DrunkardsWalkBuilder;
|
|
mod maze;
|
|
use maze::MazeBuilder;
|
|
mod simple_map;
|
|
use simple_map::SimpleMapBuilder;
|
|
mod voronoi;
|
|
use voronoi::VoronoiBuilder;
|
|
mod prefab_builder;
|
|
use prefab_builder::PrefabBuilder;
|
|
mod room_based_spawner;
|
|
mod wfc;
|
|
use room_based_spawner::*;
|
|
mod room_based_stairs;
|
|
use room_based_stairs::*;
|
|
mod room_based_starting_position;
|
|
use room_based_starting_position::*;
|
|
mod area_starting_points;
|
|
use area_starting_points::{ AreaStartingPosition, XStart, YStart };
|
|
mod cull_unreachable;
|
|
use cull_unreachable::CullUnreachable;
|
|
mod distant_exit;
|
|
use distant_exit::DistantExit;
|
|
mod voronoi_spawning;
|
|
use common::*;
|
|
use specs::prelude::*;
|
|
use voronoi_spawning::VoronoiSpawning;
|
|
use super::config::CONFIG;
|
|
use super::data::ids::*;
|
|
use super::data::names::*;
|
|
//use wfc::WaveFunctionCollapseBuilder;
|
|
mod room_exploder;
|
|
use room_exploder::RoomExploder;
|
|
mod room_corner_rounding;
|
|
use room_corner_rounding::RoomCornerRounder;
|
|
mod rooms_corridors_dogleg;
|
|
use rooms_corridors_dogleg::DoglegCorridors;
|
|
mod rooms_corridors_bsp;
|
|
use rooms_corridors_bsp::BspCorridors;
|
|
mod room_sorter;
|
|
use room_sorter::{ RoomSort, RoomSorter };
|
|
mod room_draw;
|
|
use room_draw::RoomDrawer;
|
|
mod rooms_corridors_nearest;
|
|
use rooms_corridors_nearest::NearestCorridors;
|
|
mod rooms_corridors_bresenham;
|
|
use rooms_corridors_bresenham::BresenhamCorridors;
|
|
mod rooms_corridors_spawner;
|
|
use rooms_corridors_spawner::CorridorSpawner;
|
|
mod door_placement;
|
|
use door_placement::DoorPlacement;
|
|
mod fill_edges;
|
|
use fill_edges::FillEdges;
|
|
mod town;
|
|
use town::town_builder;
|
|
mod forest;
|
|
use forest::forest_builder;
|
|
mod foliage;
|
|
use foliage::Foliage;
|
|
mod room_themer;
|
|
use room_themer::ThemeRooms;
|
|
|
|
// Shared data to be passed around build chain
|
|
pub struct BuilderMap {
|
|
pub spawn_list: Vec<(usize, String)>,
|
|
pub map: Map,
|
|
pub starting_position: Option<Position>,
|
|
pub rooms: Option<Vec<Rect>>,
|
|
pub corridors: Option<Vec<Vec<usize>>>,
|
|
pub history: Vec<Map>,
|
|
pub width: i32,
|
|
pub height: i32,
|
|
pub initial_player_level: i32,
|
|
}
|
|
|
|
impl BuilderMap {
|
|
fn take_snapshot(&mut self) {
|
|
if CONFIG.logging.show_mapgen {
|
|
let mut snapshot = self.map.clone();
|
|
for v in snapshot.revealed_tiles.iter_mut() {
|
|
*v = true;
|
|
}
|
|
self.history.push(snapshot);
|
|
}
|
|
}
|
|
}
|
|
|
|
pub struct BuilderChain {
|
|
starter: Option<Box<dyn InitialMapBuilder>>,
|
|
builders: Vec<Box<dyn MetaMapBuilder>>,
|
|
pub build_data: BuilderMap,
|
|
}
|
|
|
|
impl BuilderChain {
|
|
pub fn new<S: ToString>(
|
|
overmap: bool,
|
|
new_id: i32,
|
|
width: i32,
|
|
height: i32,
|
|
difficulty: i32,
|
|
name: S,
|
|
short_name: S,
|
|
depth: i32,
|
|
initial_player_level: i32
|
|
) -> BuilderChain {
|
|
BuilderChain {
|
|
starter: None,
|
|
builders: Vec::new(),
|
|
build_data: BuilderMap {
|
|
spawn_list: Vec::new(),
|
|
map: Map::new(overmap, new_id, width, height, difficulty, name, short_name, depth),
|
|
starting_position: None,
|
|
rooms: None,
|
|
corridors: None,
|
|
history: Vec::new(),
|
|
width: width,
|
|
height: height,
|
|
initial_player_level: initial_player_level,
|
|
},
|
|
}
|
|
}
|
|
|
|
pub fn start_with(&mut self, starter: Box<dyn InitialMapBuilder>) {
|
|
match self.starter {
|
|
None => {
|
|
self.starter = Some(starter);
|
|
}
|
|
Some(_) => unreachable!("You can only have one starting builder."),
|
|
};
|
|
}
|
|
|
|
pub fn with(&mut self, metabuilder: Box<dyn MetaMapBuilder>) {
|
|
self.builders.push(metabuilder);
|
|
}
|
|
|
|
pub fn build_map(&mut self, rng: &mut RandomNumberGenerator) {
|
|
match &mut self.starter {
|
|
None => unreachable!("Cannot run a map builder chain without a starting build system"),
|
|
Some(starter) => {
|
|
// Build the starting map
|
|
starter.build_map(rng, &mut self.build_data);
|
|
}
|
|
}
|
|
|
|
// Build additional layers in turn
|
|
for metabuilder in self.builders.iter_mut() {
|
|
metabuilder.build_map(rng, &mut self.build_data);
|
|
}
|
|
}
|
|
|
|
pub fn spawn_entities(&mut self, ecs: &mut World) {
|
|
let mut spawned_entities = Vec::new();
|
|
for entity in self.build_data.spawn_list.iter() {
|
|
spawned_entities.push(&entity.1);
|
|
spawner::spawn_entity(ecs, &(&entity.0, &entity.1));
|
|
}
|
|
if CONFIG.logging.log_spawning {
|
|
console::log(format!("DEBUGINFO: SPAWNED ENTITIES = {:?}", spawned_entities));
|
|
}
|
|
}
|
|
}
|
|
|
|
pub trait InitialMapBuilder {
|
|
fn build_map(&mut self, rng: &mut RandomNumberGenerator, build_data: &mut BuilderMap);
|
|
}
|
|
|
|
pub trait MetaMapBuilder {
|
|
fn build_map(&mut self, rng: &mut RandomNumberGenerator, build_data: &mut BuilderMap);
|
|
}
|
|
|
|
fn random_start_position(rng: &mut RandomNumberGenerator) -> (XStart, YStart) {
|
|
let x;
|
|
let xroll = rng.roll_dice(1, 3);
|
|
match xroll {
|
|
1 => {
|
|
x = XStart::LEFT;
|
|
}
|
|
2 => {
|
|
x = XStart::CENTRE;
|
|
}
|
|
_ => {
|
|
x = XStart::RIGHT;
|
|
}
|
|
}
|
|
|
|
let y;
|
|
let yroll = rng.roll_dice(1, 3);
|
|
match yroll {
|
|
1 => {
|
|
y = YStart::BOTTOM;
|
|
}
|
|
2 => {
|
|
y = YStart::CENTRE;
|
|
}
|
|
_ => {
|
|
y = YStart::TOP;
|
|
}
|
|
}
|
|
|
|
(x, y)
|
|
}
|
|
|
|
fn random_room_builder(rng: &mut RandomNumberGenerator, builder: &mut BuilderChain, end: bool) {
|
|
let build_roll = rng.roll_dice(1, 3);
|
|
// Start with a room builder.
|
|
match build_roll {
|
|
1 => builder.start_with(SimpleMapBuilder::new(None)),
|
|
2 => builder.start_with(BspDungeonBuilder::new()),
|
|
_ => builder.start_with(BspInteriorBuilder::new()),
|
|
}
|
|
|
|
// BspInterior makes its own doorways. If we're not using that one,
|
|
// select a sorting method, a type of corridor, and modifiers.
|
|
if build_roll != 3 {
|
|
// Sort by one of the 5 available algorithms
|
|
let sort_roll = rng.roll_dice(1, 5);
|
|
match sort_roll {
|
|
1 => builder.with(RoomSorter::new(RoomSort::LEFTMOST)),
|
|
2 => builder.with(RoomSorter::new(RoomSort::RIGHTMOST)),
|
|
3 => builder.with(RoomSorter::new(RoomSort::TOPMOST)),
|
|
4 => builder.with(RoomSorter::new(RoomSort::BOTTOMMOST)),
|
|
_ => builder.with(RoomSorter::new(RoomSort::CENTRAL)),
|
|
}
|
|
|
|
builder.with(RoomDrawer::new());
|
|
|
|
let corridor_roll = rng.roll_dice(1, 2);
|
|
match corridor_roll {
|
|
1 => builder.with(DoglegCorridors::new()),
|
|
_ => builder.with(BspCorridors::new()),
|
|
}
|
|
|
|
let corridor_roll = rng.roll_dice(1, 4);
|
|
match corridor_roll {
|
|
1 => builder.with(DoglegCorridors::new()),
|
|
2 => builder.with(NearestCorridors::new()),
|
|
3 => builder.with(BresenhamCorridors::new()),
|
|
_ => builder.with(BspCorridors::new()),
|
|
}
|
|
|
|
let cspawn_roll = rng.roll_dice(1, 2);
|
|
if cspawn_roll == 1 {
|
|
builder.with(CorridorSpawner::new());
|
|
}
|
|
|
|
let modifier_roll = rng.roll_dice(1, 6);
|
|
match modifier_roll {
|
|
1 => builder.with(RoomExploder::new()),
|
|
2 => builder.with(RoomCornerRounder::new()),
|
|
_ => {}
|
|
}
|
|
}
|
|
|
|
// Pick a starting position, in a room or elsewhere.
|
|
let start_roll = rng.roll_dice(1, 2);
|
|
match start_roll {
|
|
1 => builder.with(RoomBasedStartingPosition::new()),
|
|
_ => {
|
|
let (start_x, start_y) = random_start_position(rng);
|
|
builder.with(AreaStartingPosition::new(start_x, start_y));
|
|
}
|
|
}
|
|
|
|
// Decide where to put the exit - in a room or far away, anywhere.
|
|
if !end {
|
|
let exit_roll = rng.roll_dice(1, 2);
|
|
match exit_roll {
|
|
1 => builder.with(RoomBasedStairs::new()),
|
|
_ => builder.with(DistantExit::new()),
|
|
}
|
|
}
|
|
|
|
// Decide whether to spawn entities only in rooms, or with voronoi noise.
|
|
let spawn_roll = rng.roll_dice(1, 2);
|
|
match spawn_roll {
|
|
1 => builder.with(RoomBasedSpawner::new()),
|
|
_ => builder.with(VoronoiSpawning::new()),
|
|
}
|
|
|
|
builder.with(ThemeRooms::grass(5, 5 * 5)); // 5% chance of an overgrown treant room. Must be 5*5 tiles minimum.
|
|
builder.with(ThemeRooms::barracks(5, 6 * 6)); // 5% chance of a squad barracks. Must be 6*6 tiles minimum.
|
|
}
|
|
|
|
fn random_shape_builder(
|
|
rng: &mut RandomNumberGenerator,
|
|
builder: &mut BuilderChain,
|
|
end: bool
|
|
) -> bool {
|
|
// Pick an initial builder
|
|
let builder_roll = rng.roll_dice(1, 16);
|
|
let mut want_doors = true;
|
|
match builder_roll {
|
|
1 => builder.start_with(CellularAutomataBuilder::new()),
|
|
2 => builder.start_with(DrunkardsWalkBuilder::open_area()),
|
|
3 => builder.start_with(DrunkardsWalkBuilder::open_halls()),
|
|
4 => builder.start_with(DrunkardsWalkBuilder::winding_passages()),
|
|
5 => builder.start_with(DrunkardsWalkBuilder::fat_passages()),
|
|
6 => builder.start_with(DrunkardsWalkBuilder::fearful_symmetry()),
|
|
7 => {
|
|
builder.start_with(MazeBuilder::new());
|
|
want_doors = false;
|
|
}
|
|
8 => builder.start_with(DLABuilder::walk_inwards()),
|
|
9 => builder.start_with(DLABuilder::walk_outwards()),
|
|
10 => builder.start_with(DLABuilder::central_attractor()),
|
|
11 => builder.start_with(DLABuilder::insectoid()),
|
|
12 => builder.start_with(VoronoiBuilder::pythagoras()),
|
|
13 => builder.start_with(VoronoiBuilder::manhattan()),
|
|
_ =>
|
|
builder.start_with(
|
|
PrefabBuilder::constant(prefab_builder::prefab_levels::WFC_POPULATED)
|
|
),
|
|
}
|
|
|
|
// 'Select' the centre by placing a starting position, and cull everywhere unreachable.
|
|
builder.with(AreaStartingPosition::new(XStart::CENTRE, YStart::CENTRE));
|
|
builder.with(CullUnreachable::new());
|
|
|
|
// Now set the start to a random spot in our remaining area.
|
|
let (start_x, start_y) = random_start_position(rng);
|
|
builder.with(AreaStartingPosition::new(start_x, start_y));
|
|
|
|
// Place the exit and spawn mobs
|
|
builder.with(VoronoiSpawning::new());
|
|
if !end {
|
|
builder.with(DistantExit::new());
|
|
}
|
|
|
|
return want_doors;
|
|
}
|
|
|
|
fn overmap_builder() -> BuilderChain {
|
|
let mut builder = BuilderChain::new(
|
|
true,
|
|
ID_OVERMAP,
|
|
69,
|
|
41,
|
|
0,
|
|
NAME_OVERMAP,
|
|
SHORTNAME_OVERMAP,
|
|
0,
|
|
1
|
|
);
|
|
builder.start_with(PrefabBuilder::overmap());
|
|
builder.with(Foliage::percent(TileType::Grass, 30));
|
|
return builder;
|
|
}
|
|
|
|
pub enum BuildType {
|
|
Room = 1,
|
|
Shape = 2,
|
|
Any = 3,
|
|
}
|
|
|
|
pub fn random_builder(
|
|
new_id: i32,
|
|
rng: &mut RandomNumberGenerator,
|
|
width: i32,
|
|
height: i32,
|
|
difficulty: i32,
|
|
depth: i32,
|
|
initial_player_level: i32,
|
|
end: bool,
|
|
build_type: BuildType
|
|
) -> BuilderChain {
|
|
console::log(format!("DEBUGINFO: Building random (ID:{}, DIFF:{})", new_id, difficulty));
|
|
let mut builder = BuilderChain::new(
|
|
false,
|
|
new_id,
|
|
width,
|
|
height,
|
|
difficulty,
|
|
NAME_DUNGEON_RANDOM,
|
|
SHORTNAME_DUNGEON_RANDOM,
|
|
depth,
|
|
initial_player_level
|
|
);
|
|
let mut want_doors = true;
|
|
match build_type {
|
|
BuildType::Room => random_room_builder(rng, &mut builder, end),
|
|
BuildType::Shape => {
|
|
want_doors = random_shape_builder(rng, &mut builder, end);
|
|
}
|
|
BuildType::Any => {
|
|
let roll = rng.roll_dice(1, 2);
|
|
match roll {
|
|
1 => random_room_builder(rng, &mut builder, end),
|
|
_ => {
|
|
want_doors = random_shape_builder(rng, &mut builder, end);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
WFC needs polishing up before it makes good maps. Right now it leaves too much unusable area,
|
|
by making disconnected sections and having no methods to connect them.
|
|
|
|
if rng.roll_dice(1, 1) == 1 {
|
|
builder.with(WaveFunctionCollapseBuilder::new());
|
|
|
|
// Now set the start to a random starting area
|
|
let (start_x, start_y) = random_start_position(rng);
|
|
builder.with(AreaStartingPosition::new(start_x, start_y));
|
|
|
|
// Setup an exit and spawn mobs
|
|
builder.with(VoronoiSpawning::new());
|
|
builder.with(DistantExit::new());
|
|
}
|
|
*/
|
|
|
|
if want_doors {
|
|
builder.with(DoorPlacement::new());
|
|
}
|
|
|
|
if rng.roll_dice(1, 20) == 1 {
|
|
builder.with(PrefabBuilder::sectional(prefab_builder::prefab_sections::UNDERGROUND_FORT));
|
|
}
|
|
|
|
builder.with(PrefabBuilder::vaults());
|
|
// Regardless of anything else, fill the edges back in with walls. We can't walk
|
|
// there anyway, and we don't want an open line of sight into the unmapped void.
|
|
builder.with(FillEdges::wall());
|
|
|
|
builder
|
|
}
|
|
|
|
pub fn level_builder(
|
|
id: i32,
|
|
rng: &mut RandomNumberGenerator,
|
|
width: i32,
|
|
height: i32,
|
|
initial_player_level: i32
|
|
) -> BuilderChain {
|
|
match id {
|
|
ID_OVERMAP => overmap_builder(),
|
|
ID_TOWN => town_builder(id, rng, width, height, 0, initial_player_level),
|
|
ID_TOWN2 => forest_builder(id, rng, width, height, 1, initial_player_level),
|
|
ID_TOWN3 =>
|
|
random_builder(
|
|
id,
|
|
rng,
|
|
width,
|
|
height,
|
|
2,
|
|
1,
|
|
initial_player_level,
|
|
true,
|
|
BuildType::Room
|
|
),
|
|
_ if id >= ID_INFINITE =>
|
|
random_builder(
|
|
id,
|
|
rng,
|
|
width,
|
|
height,
|
|
4 + diff(ID_INFINITE, id),
|
|
1 + diff(ID_INFINITE, id),
|
|
initial_player_level,
|
|
false,
|
|
BuildType::Room
|
|
),
|
|
_ => // This should be unreachable!() eventually. Right now it's reachable with the debug/cheat menu. It should not be in normal gameplay.
|
|
random_builder(
|
|
id,
|
|
rng,
|
|
width,
|
|
height,
|
|
1,
|
|
404,
|
|
initial_player_level,
|
|
false,
|
|
BuildType::Room
|
|
),
|
|
}
|
|
}
|
|
|
|
fn diff(branch_id: i32, lvl_id: i32) -> i32 {
|
|
return lvl_id - branch_id;
|
|
}
|