lew/rust-rl
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

sorry - swapping from rustfmt to prettier-rust

Browse source
This commit is contained in:
Llywelwyn 2023-08-23 01:22:09 +01:00
parent 281396f9ce
commit c2c7e0bd52
93 changed files with 2797 additions and 2021 deletions
Download patch file Download diff file Expand all files Collapse all files

34
src/map_builders/area_starting_points.rs
View file

@ -1,4 +1,4 @@
use super::{BuilderMap, MetaMapBuilder, Position};
use super::{ BuilderMap, MetaMapBuilder, Position };
use rltk::RandomNumberGenerator;
#[allow(dead_code)]
@ -37,14 +37,26 @@ impl AreaStartingPosition {
let seed_y;
match self.x {
XStart::LEFT => seed_x = 1,
XStart::CENTRE => seed_x = build_data.map.width / 2,
XStart::RIGHT => seed_x = build_data.map.width - 2,
XStart::LEFT => {
seed_x = 1;
}
XStart::CENTRE => {
seed_x = build_data.map.width / 2;
}
XStart::RIGHT => {
seed_x = build_data.map.width - 2;
}
}
match self.y {
YStart::TOP => seed_y = 1,
YStart::CENTRE => seed_y = build_data.map.height / 2,
YStart::BOTTOM => seed_y = build_data.map.height - 2,
YStart::TOP => {
seed_y = 1;
}
YStart::CENTRE => {
seed_y = build_data.map.height / 2;
}
YStart::BOTTOM => {
seed_y = build_data.map.height - 2;
}
}
let mut available_floors: Vec<(usize, f32)> = Vec::new();
@ -53,8 +65,8 @@ impl AreaStartingPosition {
available_floors.push((
idx,
rltk::DistanceAlg::PythagorasSquared.distance2d(
rltk::Point::new(idx as i32 % build_data.map.width, idx as i32 / build_data.map.width),
rltk::Point::new(seed_x, seed_y),
rltk::Point::new((idx as i32) % build_data.map.width, (idx as i32) / build_data.map.width),
rltk::Point::new(seed_x, seed_y)
),
));
}
@ -65,8 +77,8 @@ impl AreaStartingPosition {
available_floors.sort_by(|a, b| a.1.partial_cmp(&b.1).unwrap());
let start_x = available_floors[0].0 as i32 % build_data.map.width;
let start_y = available_floors[0].0 as i32 / build_data.map.width;
let start_x = (available_floors[0].0 as i32) % build_data.map.width;
let start_y = (available_floors[0].0 as i32) / build_data.map.width;
build_data.starting_position = Some(Position { x: start_x, y: start_y });
}

2
src/map_builders/bsp_dungeon.rs
View file

@ -1,4 +1,4 @@
use super::{BuilderMap, InitialMapBuilder, Rect, TileType};
use super::{ BuilderMap, InitialMapBuilder, Rect, TileType };
use rltk::RandomNumberGenerator;
pub struct BspDungeonBuilder {

4
src/map_builders/bsp_interior.rs
View file

@ -1,4 +1,4 @@
use super::{draw_corridor, BuilderMap, InitialMapBuilder, Rect, TileType};
use super::{ draw_corridor, BuilderMap, InitialMapBuilder, Rect, TileType };
use rltk::RandomNumberGenerator;
const MIN_ROOM_SIZE: i32 = 8;
@ -36,7 +36,7 @@ impl BspInteriorBuilder {
for y in room.y1..room.y2 {
for x in room.x1..room.x2 {
let idx = build_data.map.xy_idx(x, y);
if idx > 0 && idx < ((build_data.map.width * build_data.map.height) - 1) as usize {
if idx > 0 && idx < ((build_data.map.width * build_data.map.height - 1) as usize) {
build_data.map.tiles[idx] = TileType::Floor;
}
}

18
src/map_builders/cellular_automata.rs
View file

@ -1,4 +1,4 @@
use super::{BuilderMap, InitialMapBuilder, MetaMapBuilder, TileType};
use super::{ BuilderMap, InitialMapBuilder, MetaMapBuilder, TileType };
use rltk::RandomNumberGenerator;
pub struct CellularAutomataBuilder {}
@ -31,9 +31,9 @@ impl CellularAutomataBuilder {
let roll = rng.roll_dice(1, 100);
let idx = build_data.map.xy_idx(x, y);
if roll > 55 {
build_data.map.tiles[idx] = TileType::Floor
build_data.map.tiles[idx] = TileType::Floor;
} else {
build_data.map.tiles[idx] = TileType::Wall
build_data.map.tiles[idx] = TileType::Wall;
}
}
}
@ -58,22 +58,22 @@ impl CellularAutomataBuilder {
if build_data.map.tiles[idx + 1] == TileType::Wall {
neighbors += 1;
}
if build_data.map.tiles[idx - build_data.map.width as usize] == TileType::Wall {
if build_data.map.tiles[idx - (build_data.map.width as usize)] == TileType::Wall {
neighbors += 1;
}
if build_data.map.tiles[idx + build_data.map.width as usize] == TileType::Wall {
if build_data.map.tiles[idx + (build_data.map.width as usize)] == TileType::Wall {
neighbors += 1;
}
if build_data.map.tiles[idx - (build_data.map.width as usize - 1)] == TileType::Wall {
if build_data.map.tiles[idx - ((build_data.map.width as usize) - 1)] == TileType::Wall {
neighbors += 1;
}
if build_data.map.tiles[idx - (build_data.map.width as usize + 1)] == TileType::Wall {
if build_data.map.tiles[idx - ((build_data.map.width as usize) + 1)] == TileType::Wall {
neighbors += 1;
}
if build_data.map.tiles[idx + (build_data.map.width as usize - 1)] == TileType::Wall {
if build_data.map.tiles[idx + ((build_data.map.width as usize) - 1)] == TileType::Wall {
neighbors += 1;
}
if build_data.map.tiles[idx + (build_data.map.width as usize + 1)] == TileType::Wall {
if build_data.map.tiles[idx + ((build_data.map.width as usize) + 1)] == TileType::Wall {
neighbors += 1;
}

4
src/map_builders/common.rs
View file

@ -1,5 +1,5 @@
use super::{Map, Rect, TileType};
use std::cmp::{max, min};
use super::{ Map, Rect, TileType };
use std::cmp::{ max, min };
#[allow(dead_code)]
pub fn apply_room_to_map(map: &mut Map, room: &Rect) {

4
src/map_builders/cull_unreachable.rs
View file

@ -1,4 +1,4 @@
use super::{BuilderMap, MetaMapBuilder, TileType};
use super::{ BuilderMap, MetaMapBuilder, TileType };
use rltk::RandomNumberGenerator;
pub struct CullUnreachable {}
@ -25,7 +25,7 @@ impl CullUnreachable {
build_data.map.height as usize,
&map_starts,
&build_data.map,
1000.0,
1000.0
);
for (i, tile) in build_data.map.tiles.iter_mut().enumerate() {
if *tile == TileType::Floor {

4
src/map_builders/distant_exit.rs
View file

@ -1,4 +1,4 @@
use super::{BuilderMap, MetaMapBuilder, TileType};
use super::{ BuilderMap, MetaMapBuilder, TileType };
use rltk::RandomNumberGenerator;
pub struct DistantExit {}
@ -25,7 +25,7 @@ impl DistantExit {
build_data.map.height as usize,
&map_starts,
&build_data.map,
1000.0,
1000.0
);
let mut exit_tile = (0, 0.0f32);
for (i, tile) in build_data.map.tiles.iter_mut().enumerate() {

20
src/map_builders/dla.rs
View file

@ -1,4 +1,4 @@
use super::{paint, BuilderMap, InitialMapBuilder, MetaMapBuilder, Position, Symmetry, TileType};
use super::{ paint, BuilderMap, InitialMapBuilder, MetaMapBuilder, Position, Symmetry, TileType };
use rltk::RandomNumberGenerator;
#[derive(PartialEq, Copy, Clone)]
@ -100,13 +100,16 @@ impl DLABuilder {
build_data.map.tiles[start_idx] = TileType::Floor;
build_data.map.tiles[start_idx - 1] = TileType::Floor;
build_data.map.tiles[start_idx + 1] = TileType::Floor;
build_data.map.tiles[start_idx - build_data.map.width as usize] = TileType::Floor;
build_data.map.tiles[start_idx + build_data.map.width as usize] = TileType::Floor;
build_data.map.tiles[start_idx - (build_data.map.width as usize)] = TileType::Floor;
build_data.map.tiles[start_idx + (build_data.map.width as usize)] = TileType::Floor;
// Random walker
let total_tiles = build_data.map.width * build_data.map.height;
let desired_floor_tiles = (self.floor_percent * total_tiles as f32) as usize;
let mut floor_tile_count = build_data.map.tiles.iter().filter(|a| **a == TileType::Floor).count();
let desired_floor_tiles = (self.floor_percent * (total_tiles as f32)) as usize;
let mut floor_tile_count = build_data.map.tiles
.iter()
.filter(|a| **a == TileType::Floor)
.count();
while floor_tile_count < desired_floor_tiles {
match self.algorithm {
DLAAlgorithm::WalkInwards => {
@ -189,7 +192,7 @@ impl DLABuilder {
let mut path = rltk::line2d(
rltk::LineAlg::Bresenham,
rltk::Point::new(digger_x, digger_y),
rltk::Point::new(starting_position.x, starting_position.y),
rltk::Point::new(starting_position.x, starting_position.y)
);
while build_data.map.tiles[digger_idx] == TileType::Wall && !path.is_empty() {
@ -206,7 +209,10 @@ impl DLABuilder {
build_data.take_snapshot();
floor_tile_count = build_data.map.tiles.iter().filter(|a| **a == TileType::Floor).count();
floor_tile_count = build_data.map.tiles
.iter()
.filter(|a| **a == TileType::Floor)
.count();
}
}
}

38
src/map_builders/door_placement.rs
View file

@ -1,4 +1,4 @@
use super::{BuilderMap, MetaMapBuilder, TileType};
use super::{ BuilderMap, MetaMapBuilder, TileType };
use rltk::RandomNumberGenerator;
pub struct DoorPlacement {}
@ -45,27 +45,35 @@ impl DoorPlacement {
}
}
let x = idx % build_data.map.width as usize;
let y = idx / build_data.map.width as usize;
let x = idx % (build_data.map.width as usize);
let y = idx / (build_data.map.width as usize);
// Check for east-west door possibility
if build_data.map.tiles[idx] == TileType::Floor
&& (x > 1 && build_data.map.tiles[idx - 1] == TileType::Floor)
&& (x < build_data.map.width as usize - 2 && build_data.map.tiles[idx + 1] == TileType::Floor)
&& (y > 1 && build_data.map.tiles[idx - build_data.map.width as usize] == TileType::Wall)
&& (y < build_data.map.height as usize - 2
&& build_data.map.tiles[idx + build_data.map.width as usize] == TileType::Wall)
if
build_data.map.tiles[idx] == TileType::Floor &&
x > 1 &&
build_data.map.tiles[idx - 1] == TileType::Floor &&
x < (build_data.map.width as usize) - 2 &&
build_data.map.tiles[idx + 1] == TileType::Floor &&
y > 1 &&
build_data.map.tiles[idx - (build_data.map.width as usize)] == TileType::Wall &&
y < (build_data.map.height as usize) - 2 &&
build_data.map.tiles[idx + (build_data.map.width as usize)] == TileType::Wall
{
return true;
}
// Check for north-south door possibility
if build_data.map.tiles[idx] == TileType::Floor
&& (x > 1 && build_data.map.tiles[idx - 1] == TileType::Wall)
&& (x < build_data.map.width as usize - 2 && build_data.map.tiles[idx + 1] == TileType::Wall)
&& (y > 1 && build_data.map.tiles[idx - build_data.map.width as usize] == TileType::Floor)
&& (y < build_data.map.height as usize - 2
&& build_data.map.tiles[idx + build_data.map.width as usize] == TileType::Floor)
if
build_data.map.tiles[idx] == TileType::Floor &&
x > 1 &&
build_data.map.tiles[idx - 1] == TileType::Wall &&
x < (build_data.map.width as usize) - 2 &&
build_data.map.tiles[idx + 1] == TileType::Wall &&
y > 1 &&
build_data.map.tiles[idx - (build_data.map.width as usize)] == TileType::Floor &&
y < (build_data.map.height as usize) - 2 &&
build_data.map.tiles[idx + (build_data.map.width as usize)] == TileType::Floor
{
return true;
}

14
src/map_builders/drunkard.rs
View file

@ -1,4 +1,4 @@
use super::{paint, BuilderMap, InitialMapBuilder, MetaMapBuilder, Position, Symmetry, TileType};
use super::{ paint, BuilderMap, InitialMapBuilder, MetaMapBuilder, Position, Symmetry, TileType };
use rltk::RandomNumberGenerator;
#[derive(PartialEq, Copy, Clone)]
@ -112,8 +112,11 @@ impl DrunkardsWalkBuilder {
build_data.map.tiles[start_idx] = TileType::Floor;
let total_tiles = build_data.map.width * build_data.map.height;
let desired_floor_tiles = (self.settings.floor_percent * total_tiles as f32) as usize;
let mut floor_tile_count = build_data.map.tiles.iter().filter(|a| **a == TileType::Floor).count();
let desired_floor_tiles = (self.settings.floor_percent * (total_tiles as f32)) as usize;
let mut floor_tile_count = build_data.map.tiles
.iter()
.filter(|a| **a == TileType::Floor)
.count();
let mut digger_count = 0;
while floor_tile_count < desired_floor_tiles {
let mut did_something = false;
@ -180,7 +183,10 @@ impl DrunkardsWalkBuilder {
*t = TileType::Floor;
}
}
floor_tile_count = build_data.map.tiles.iter().filter(|a| **a == TileType::Floor).count();
floor_tile_count = build_data.map.tiles
.iter()
.filter(|a| **a == TileType::Floor)
.count();
}
}
}

2
src/map_builders/fill_edges.rs
View file

@ -1,4 +1,4 @@
use super::{BuilderMap, MetaMapBuilder, TileType};
use super::{ BuilderMap, MetaMapBuilder, TileType };
use rltk::RandomNumberGenerator;
pub struct FillEdges {

26
src/map_builders/forest.rs
View file

@ -1,6 +1,14 @@
use super::{
AreaStartingPosition, BuilderChain, BuilderMap, CellularAutomataBuilder, CullUnreachable, MetaMapBuilder, TileType,
VoronoiSpawning, XStart, YStart,
AreaStartingPosition,
BuilderChain,
BuilderMap,
CellularAutomataBuilder,
CullUnreachable,
MetaMapBuilder,
TileType,
VoronoiSpawning,
XStart,
YStart,
};
use rltk::prelude::*;
@ -10,7 +18,7 @@ pub fn forest_builder(
width: i32,
height: i32,
difficulty: i32,
initial_player_level: i32,
initial_player_level: i32
) -> BuilderChain {
let mut chain = BuilderChain::new(new_id, width, height, difficulty, "the woods", initial_player_level);
chain.start_with(CellularAutomataBuilder::new());
@ -44,8 +52,8 @@ impl RoadExit {
available_floors.push((
idx,
DistanceAlg::PythagorasSquared.distance2d(
Point::new(idx as i32 % build_data.map.width, idx as i32 / build_data.map.width),
Point::new(seed_x, seed_y),
Point::new((idx as i32) % build_data.map.width, (idx as i32) / build_data.map.width),
Point::new(seed_x, seed_y)
),
));
}
@ -54,8 +62,8 @@ impl RoadExit {
panic!("No valid floors to start on.");
}
available_floors.sort_by(|a, b| a.1.partial_cmp(&b.1).unwrap());
let end_x = available_floors[0].0 as i32 % build_data.map.width;
let end_y = available_floors[0].0 as i32 / build_data.map.width;
let end_x = (available_floors[0].0 as i32) % build_data.map.width;
let end_y = (available_floors[0].0 as i32) / build_data.map.width;
return (end_x, end_y);
}
@ -78,8 +86,8 @@ impl RoadExit {
let path = a_star_search(start_idx, end_idx, &mut build_data.map);
for idx in path.steps.iter() {
let x = *idx as i32 % build_data.map.width;
let y = *idx as i32 / build_data.map.width;
let x = (*idx as i32) % build_data.map.width;
let y = (*idx as i32) / build_data.map.width;
self.paint_road(build_data, x, y);
self.paint_road(build_data, x - 1, y);
self.paint_road(build_data, x + 1, y);

14
src/map_builders/maze.rs
View file

@ -1,4 +1,4 @@
use super::{BuilderMap, InitialMapBuilder, Map, TileType};
use super::{ BuilderMap, InitialMapBuilder, Map, TileType };
use rltk::RandomNumberGenerator;
pub struct MazeBuilder {}
@ -19,7 +19,7 @@ impl MazeBuilder {
#[allow(clippy::map_entry)]
fn build(&mut self, rng: &mut RandomNumberGenerator, build_data: &mut BuilderMap) {
// Maze gen
let mut maze = Grid::new((build_data.map.width / 2) - 2, (build_data.map.height / 2) - 2, rng);
let mut maze = Grid::new(build_data.map.width / 2 - 2, build_data.map.height / 2 - 2, rng);
maze.generate_maze(build_data);
}
}
@ -90,7 +90,7 @@ impl<'a> Grid<'a> {
if row < 0 || column < 0 || column > self.width - 1 || row > self.height - 1 {
-1
} else {
column + (row * self.width)
column + row * self.width
}
}
@ -178,16 +178,16 @@ impl<'a> Grid<'a> {
map.tiles[idx] = TileType::Floor;
if !cell.walls[TOP] {
map.tiles[idx - map.width as usize] = TileType::Floor
map.tiles[idx - (map.width as usize)] = TileType::Floor;
}
if !cell.walls[RIGHT] {
map.tiles[idx + 1] = TileType::Floor
map.tiles[idx + 1] = TileType::Floor;
}
if !cell.walls[BOTTOM] {
map.tiles[idx + map.width as usize] = TileType::Floor
map.tiles[idx + (map.width as usize)] = TileType::Floor;
}
if !cell.walls[LEFT] {
map.tiles[idx - 1] = TileType::Floor
map.tiles[idx - 1] = TileType::Floor;
}
}
}

44
src/map_builders/mod.rs
View file

@ -1,4 +1,4 @@
use super::{spawner, Map, Position, Rect, TileType, SHOW_MAPGEN};
use super::{ spawner, Map, Position, Rect, TileType, SHOW_MAPGEN };
mod bsp_dungeon;
use bsp_dungeon::BspDungeonBuilder;
mod bsp_interior;
@ -26,7 +26,7 @@ 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};
use area_starting_points::{ AreaStartingPosition, XStart, YStart };
mod cull_unreachable;
use cull_unreachable::CullUnreachable;
mod distant_exit;
@ -45,7 +45,7 @@ use rooms_corridors_dogleg::DoglegCorridors;
mod rooms_corridors_bsp;
use rooms_corridors_bsp::BspCorridors;
mod room_sorter;
use room_sorter::{RoomSort, RoomSorter};
use room_sorter::{ RoomSort, RoomSorter };
mod room_draw;
use room_draw::RoomDrawer;
mod rooms_corridors_nearest;
@ -101,7 +101,7 @@ impl BuilderChain {
height: i32,
difficulty: i32,
name: S,
initial_player_level: i32,
initial_player_level: i32
) -> BuilderChain {
BuilderChain {
starter: None,
@ -122,7 +122,9 @@ impl BuilderChain {
pub fn start_with(&mut self, starter: Box<dyn InitialMapBuilder>) {
match self.starter {
None => self.starter = Some(starter),
None => {
self.starter = Some(starter);
}
Some(_) => panic!("You can only have one starting builder."),
};
}
@ -168,17 +170,29 @@ fn random_start_position(rng: &mut rltk::RandomNumberGenerator) -> (XStart, YSta
let x;
let xroll = rng.roll_dice(1, 3);
match xroll {
1 => x = XStart::LEFT,
2 => x = XStart::CENTRE,
_ => x = XStart::RIGHT,
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,
1 => {
y = YStart::BOTTOM;
}
2 => {
y = YStart::CENTRE;
}
_ => {
y = YStart::TOP;
}
}
(x, y)
@ -305,7 +319,7 @@ pub fn random_builder(
width: i32,
height: i32,
difficulty: i32,
initial_player_level: i32,
initial_player_level: i32
) -> BuilderChain {
rltk::console::log(format!("DEBUGINFO: Building random (ID:{}, DIFF:{})", new_id, difficulty));
let mut builder = BuilderChain::new(new_id, width, height, difficulty, "the dungeon", initial_player_level);
@ -313,7 +327,9 @@ pub fn random_builder(
let mut want_doors = true;
match type_roll {
1 => random_room_builder(rng, &mut builder),
_ => want_doors = random_shape_builder(rng, &mut builder),
_ => {
want_doors = random_shape_builder(rng, &mut builder);
}
}
/*
@ -354,7 +370,7 @@ pub fn level_builder(
rng: &mut rltk::RandomNumberGenerator,
width: i32,
height: i32,
initial_player_level: i32,
initial_player_level: i32
) -> BuilderChain {
// TODO: With difficulty and ID/depth decoupled, this can be used for branches later.
let difficulty = new_id;

4
src/map_builders/room_based_spawner.rs
View file

@ -1,4 +1,4 @@
use super::{spawner, BuilderMap, MetaMapBuilder};
use super::{ spawner, BuilderMap, MetaMapBuilder };
use rltk::RandomNumberGenerator;
pub struct RoomBasedSpawner {}
@ -23,7 +23,7 @@ impl RoomBasedSpawner {
rng,
room,
&mut build_data.spawn_list,
build_data.initial_player_level,
build_data.initial_player_level
);
}
} else {

2
src/map_builders/room_based_stairs.rs
View file

@ -1,4 +1,4 @@
use super::{BuilderMap, MetaMapBuilder, TileType};
use super::{ BuilderMap, MetaMapBuilder, TileType };
use rltk::RandomNumberGenerator;
pub struct RoomBasedStairs {}

2
src/map_builders/room_based_starting_position.rs
View file

@ -1,4 +1,4 @@
use super::{BuilderMap, MetaMapBuilder, Position};
use super::{ BuilderMap, MetaMapBuilder, Position };
use rltk::RandomNumberGenerator;
pub struct RoomBasedStartingPosition {}

6
src/map_builders/room_corner_rounding.rs
View file

@ -1,4 +1,4 @@
use super::{BuilderMap, MetaMapBuilder, Rect, TileType};
use super::{ BuilderMap, MetaMapBuilder, Rect, TileType };
use rltk::RandomNumberGenerator;
pub struct RoomCornerRounder {}
@ -23,13 +23,13 @@ impl RoomCornerRounder {
if x > 0 && build_data.map.tiles[idx - 1] == TileType::Wall {
neighbour_walls += 1;
}
if y > 0 && build_data.map.tiles[idx - w as usize] == TileType::Wall {
if y > 0 && build_data.map.tiles[idx - (w as usize)] == TileType::Wall {
neighbour_walls += 1;
}
if x < w - 2 && build_data.map.tiles[idx + 1] == TileType::Wall {
neighbour_walls += 1;
}
if y < h - 2 && build_data.map.tiles[idx + w as usize] == TileType::Wall {
if y < h - 2 && build_data.map.tiles[idx + (w as usize)] == TileType::Wall {
neighbour_walls += 1;
}
if neighbour_walls == 2 {

9
src/map_builders/room_draw.rs
View file

@ -1,4 +1,4 @@
use super::{BuilderMap, MetaMapBuilder, Rect, TileType};
use super::{ BuilderMap, MetaMapBuilder, Rect, TileType };
use rltk::RandomNumberGenerator;
pub struct RoomDrawer {}
@ -19,7 +19,7 @@ impl RoomDrawer {
for y in room.y1 + 1..=room.y2 {
for x in room.x1 + 1..=room.x2 {
let idx = build_data.map.xy_idx(x, y);
if idx > 0 && idx < ((build_data.map.width * build_data.map.height) - 1) as usize {
if idx > 0 && idx < ((build_data.map.width * build_data.map.height - 1) as usize) {
build_data.map.tiles[idx] = TileType::Floor;
}
}
@ -27,15 +27,14 @@ impl RoomDrawer {
}
fn circle(&mut self, build_data: &mut BuilderMap, room: &Rect) {
let radius = i32::min(room.x2 - room.x1, room.y2 - room.y1) as f32 / 2.0;
let radius = (i32::min(room.x2 - room.x1, room.y2 - room.y1) as f32) / 2.0;
let center = room.centre();
let center_pt = rltk::Point::new(center.0, center.1);
for y in room.y1..=room.y2 {
for x in room.x1..=room.x2 {
let idx = build_data.map.xy_idx(x, y);
let distance = rltk::DistanceAlg::Pythagoras.distance2d(center_pt, rltk::Point::new(x, y));
if idx > 0 && idx < ((build_data.map.width * build_data.map.height) - 1) as usize && distance <= radius
{
if idx > 0 && idx < ((build_data.map.width * build_data.map.height - 1) as usize) && distance <= radius {
build_data.map.tiles[idx] = TileType::Floor;
}
}

2
src/map_builders/room_exploder.rs
View file

@ -1,4 +1,4 @@
use super::{paint, BuilderMap, MetaMapBuilder, Rect, Symmetry, TileType};
use super::{ paint, BuilderMap, MetaMapBuilder, Rect, Symmetry, TileType };
use rltk::RandomNumberGenerator;
pub struct RoomExploder {}

43
src/map_builders/room_sorter.rs
View file

@ -1,4 +1,4 @@
use super::{BuilderMap, MetaMapBuilder, Rect};
use super::{ BuilderMap, MetaMapBuilder, Rect };
use rltk::RandomNumberGenerator;
#[allow(dead_code)]
@ -29,19 +29,38 @@ impl RoomSorter {
fn sorter(&mut self, _rng: &mut RandomNumberGenerator, build_data: &mut BuilderMap) {
match self.sort_by {
RoomSort::LEFTMOST => build_data.rooms.as_mut().unwrap().sort_by(|a, b| a.x1.cmp(&b.x1)),
RoomSort::RIGHTMOST => build_data.rooms.as_mut().unwrap().sort_by(|a, b| b.x2.cmp(&a.x2)),
RoomSort::TOPMOST => build_data.rooms.as_mut().unwrap().sort_by(|a, b| a.y1.cmp(&b.y1)),
RoomSort::BOTTOMMOST => build_data.rooms.as_mut().unwrap().sort_by(|a, b| b.y2.cmp(&a.y2)),
RoomSort::LEFTMOST =>
build_data.rooms
.as_mut()
.unwrap()
.sort_by(|a, b| a.x1.cmp(&b.x1)),
RoomSort::RIGHTMOST =>
build_data.rooms
.as_mut()
.unwrap()
.sort_by(|a, b| b.x2.cmp(&a.x2)),
RoomSort::TOPMOST =>
build_data.rooms
.as_mut()
.unwrap()
.sort_by(|a, b| a.y1.cmp(&b.y1)),
RoomSort::BOTTOMMOST =>
build_data.rooms
.as_mut()
.unwrap()
.sort_by(|a, b| b.y2.cmp(&a.y2)),
RoomSort::CENTRAL => {
let map_centre = rltk::Point::new(build_data.map.width / 2, build_data.map.height / 2);
build_data.rooms.as_mut().unwrap().sort_by(|a: &Rect, b: &Rect| {
let a_centre_pt = rltk::Point::new(a.centre().0, a.centre().1);
let b_centre_pt = rltk::Point::new(b.centre().0, b.centre().1);
let distance_a = rltk::DistanceAlg::Pythagoras.distance2d(a_centre_pt, map_centre);
let distance_b = rltk::DistanceAlg::Pythagoras.distance2d(b_centre_pt, map_centre);
return distance_a.partial_cmp(&distance_b).unwrap();
})
build_data.rooms
.as_mut()
.unwrap()
.sort_by(|a: &Rect, b: &Rect| {
let a_centre_pt = rltk::Point::new(a.centre().0, a.centre().1);
let b_centre_pt = rltk::Point::new(b.centre().0, b.centre().1);
let distance_a = rltk::DistanceAlg::Pythagoras.distance2d(a_centre_pt, map_centre);
let distance_b = rltk::DistanceAlg::Pythagoras.distance2d(b_centre_pt, map_centre);
return distance_a.partial_cmp(&distance_b).unwrap();
})
}
}
}

4
src/map_builders/rooms_corridors_bresenham.rs
View file

@ -1,4 +1,4 @@
use super::{BuilderMap, MetaMapBuilder, Rect, TileType};
use super::{ BuilderMap, MetaMapBuilder, Rect, TileType };
use rltk::RandomNumberGenerator;
use std::collections::HashSet;
@ -46,7 +46,7 @@ impl BresenhamCorridors {
let line = rltk::line2d(
rltk::LineAlg::Bresenham,
room_centre_pt,
rltk::Point::new(dest_centre.0, dest_centre.1),
rltk::Point::new(dest_centre.0, dest_centre.1)
);
let mut corridor = Vec::new();
for cell in line.iter() {

2
src/map_builders/rooms_corridors_bsp.rs
View file

@ -1,4 +1,4 @@
use super::{draw_corridor, BuilderMap, MetaMapBuilder, Rect};
use super::{ draw_corridor, BuilderMap, MetaMapBuilder, Rect };
use rltk::RandomNumberGenerator;
pub struct BspCorridors {}

4
src/map_builders/rooms_corridors_dogleg.rs
View file

@ -1,4 +1,4 @@
use super::{apply_horizontal_tunnel, apply_vertical_tunnel, BuilderMap, MetaMapBuilder, Rect};
use super::{ apply_horizontal_tunnel, apply_vertical_tunnel, BuilderMap, MetaMapBuilder, Rect };
use rltk::RandomNumberGenerator;
pub struct DoglegCorridors {}
@ -28,7 +28,7 @@ impl DoglegCorridors {
for (i, room) in rooms.iter().enumerate() {
if i > 0 {
let (new_x, new_y) = room.centre();
let (prev_x, prev_y) = rooms[i as usize - 1].centre();
let (prev_x, prev_y) = rooms[(i as usize) - 1].centre();
if rng.range(0, 2) == 1 {
let mut c1 = apply_horizontal_tunnel(&mut build_data.map, prev_x, new_x, prev_y);
let mut c2 = apply_vertical_tunnel(&mut build_data.map, prev_y, new_y, new_x);

11
src/map_builders/rooms_corridors_nearest.rs
View file

@ -1,4 +1,4 @@
use super::{draw_corridor, BuilderMap, MetaMapBuilder, Rect};
use super::{ draw_corridor, BuilderMap, MetaMapBuilder, Rect };
use rltk::RandomNumberGenerator;
use std::collections::HashSet;
@ -43,8 +43,13 @@ impl NearestCorridors {
if !room_distance.is_empty() {
room_distance.sort_by(|a, b| a.1.partial_cmp(&b.1).unwrap());
let dest_centre = rooms[room_distance[0].0].centre();
let corridor =
draw_corridor(&mut build_data.map, room_centre.0, room_centre.1, dest_centre.0, dest_centre.1);
let corridor = draw_corridor(
&mut build_data.map,
room_centre.0,
room_centre.1,
dest_centre.0,
dest_centre.1
);
connected.insert(i);
build_data.take_snapshot();
corridors.push(corridor);

4
src/map_builders/rooms_corridors_spawner.rs
View file

@ -1,4 +1,4 @@
use super::{spawner, BuilderMap, MetaMapBuilder};
use super::{ spawner, BuilderMap, MetaMapBuilder };
use rltk::RandomNumberGenerator;
pub struct CorridorSpawner {}
@ -23,7 +23,7 @@ impl CorridorSpawner {
rng,
&corridor,
&mut build_data.spawn_list,
build_data.initial_player_level,
build_data.initial_player_level
);
}
} else {

8
src/map_builders/simple_map.rs
View file

@ -1,4 +1,4 @@
use super::{BuilderMap, InitialMapBuilder, Rect};
use super::{ BuilderMap, InitialMapBuilder, Rect };
use rltk::RandomNumberGenerator;
pub struct SimpleMapBuilder {
@ -22,9 +22,9 @@ impl SimpleMapBuilder {
let (max_rooms, min_size, max_size);
if let Some(room_params) = room_params {
(max_rooms, min_size, max_size) = (room_params.0, room_params.1, room_params.2)
(max_rooms, min_size, max_size) = (room_params.0, room_params.1, room_params.2);
} else {
(max_rooms, min_size, max_size) = (DEFAULT_MAX_ROOMS, DEFAULT_MIN_SIZE, DEFAULT_MAX_SIZE)
(max_rooms, min_size, max_size) = (DEFAULT_MAX_ROOMS, DEFAULT_MIN_SIZE, DEFAULT_MAX_SIZE);
}
Box::new(SimpleMapBuilder { room_params: (max_rooms, min_size, max_size) })
@ -42,7 +42,7 @@ impl SimpleMapBuilder {
let mut ok = true;
for other_room in rooms.iter() {
if new_room.intersect(other_room) {
ok = false
ok = false;
}
}
if ok {

96
src/map_builders/town.rs
View file

@ -1,4 +1,4 @@
use super::{BuilderChain, BuilderMap, InitialMapBuilder, Position, TileType};
use super::{ BuilderChain, BuilderMap, InitialMapBuilder, Position, TileType };
use std::collections::HashSet;
pub fn town_builder(
@ -7,7 +7,7 @@ pub fn town_builder(
width: i32,
height: i32,
difficulty: i32,
initial_player_level: i32,
initial_player_level: i32
) -> BuilderChain {
rltk::console::log(format!("DEBUGINFO: Building town (ID:{}, DIFF:{})", new_id, difficulty));
let mut chain = BuilderChain::new(new_id, width, height, difficulty, "the town", initial_player_level);
@ -78,7 +78,7 @@ impl TownBuilder {
building_size[2].2 = BuildingTag::Mine;
building_size[3].2 = BuildingTag::PlayerHouse;
for b in building_size.iter_mut().skip(4) {
b.2 = BuildingTag::NPCHouse
b.2 = BuildingTag::NPCHouse;
}
let last_idx = building_size.len() - 1;
building_size[last_idx].2 = BuildingTag::Abandoned;
@ -91,7 +91,7 @@ impl TownBuilder {
rng: &mut rltk::RandomNumberGenerator,
build_data: &mut BuilderMap,
buildings: &[(i32, i32, i32, i32)],
building_index: &[(usize, i32, BuildingTag)],
building_index: &[(usize, i32, BuildingTag)]
) {
for (i, building) in buildings.iter().enumerate() {
let build_tag = &building_index[i].2;
@ -123,7 +123,7 @@ impl TownBuilder {
&mut self,
build_data: &mut BuilderMap,
rng: &mut rltk::RandomNumberGenerator,
available_building_tiles: &mut HashSet<usize>,
available_building_tiles: &mut HashSet<usize>
) {
for idx in available_building_tiles.iter() {
if rng.roll_dice(1, 40) == 1 {
@ -161,15 +161,16 @@ impl TownBuilder {
build_data: &mut BuilderMap,
rng: &mut rltk::RandomNumberGenerator,
to_place: &mut Vec<&str>,
avoid_tile: usize,
avoid_tile: usize
) {
for y in building.1..building.1 + building.3 {
for x in building.0..building.0 + building.2 {
let idx = build_data.map.xy_idx(x, y);
if build_data.map.tiles[idx] == TileType::WoodFloor
&& idx != avoid_tile
&& rng.roll_dice(1, 3) == 1
&& !to_place.is_empty()
if
build_data.map.tiles[idx] == TileType::WoodFloor &&
idx != avoid_tile &&
rng.roll_dice(1, 3) == 1 &&
!to_place.is_empty()
{
let entity_tag = to_place[0];
to_place.remove(0);
@ -183,12 +184,14 @@ impl TownBuilder {
&mut self,
building: &(i32, i32, i32, i32),
build_data: &mut BuilderMap,
rng: &mut rltk::RandomNumberGenerator,
rng: &mut rltk::RandomNumberGenerator
) {
// Place player
build_data.starting_position =
Some(Position { x: building.0 + (building.2 / 2), y: building.1 + (building.3 / 2) });
let player_idx = build_data.map.xy_idx(building.0 + (building.2 / 2), building.1 + (building.3 / 2));
build_data.starting_position = Some(Position {
x: building.0 + building.2 / 2,
y: building.1 + building.3 / 2,
});
let player_idx = build_data.map.xy_idx(building.0 + building.2 / 2, building.1 + building.3 / 2);
// Place other items
let mut to_place: Vec<&str> = vec![
@ -200,7 +203,7 @@ impl TownBuilder {
"prop_table",
"prop_table",
"prop_chair",
"prop_chair",
"prop_chair"
];
self.random_building_spawn(building, build_data, rng, &mut to_place, player_idx);
}
@ -209,7 +212,7 @@ impl TownBuilder {
&mut self,
building: &(i32, i32, i32, i32),
build_data: &mut BuilderMap,
rng: &mut rltk::RandomNumberGenerator,
rng: &mut rltk::RandomNumberGenerator
) {
let mut to_place: Vec<&str> = vec![
"npc_priest",
@ -220,7 +223,7 @@ impl TownBuilder {
"prop_table",
"prop_table",
"prop_candle",
"prop_candle",
"prop_candle"
];
self.random_building_spawn(building, build_data, rng, &mut to_place, 0)
}
@ -229,10 +232,10 @@ impl TownBuilder {
&mut self,
building: &(i32, i32, i32, i32),
build_data: &mut BuilderMap,
rng: &mut rltk::RandomNumberGenerator,
rng: &mut rltk::RandomNumberGenerator
) {
// Place exit
let exit_idx = build_data.map.xy_idx(building.0 + (building.2 / 2), building.1 + (building.3 / 2));
let exit_idx = build_data.map.xy_idx(building.0 + building.2 / 2, building.1 + building.3 / 2);
build_data.map.tiles[exit_idx] = TileType::DownStair;
let mut to_place: Vec<&str> = vec!["npc_miner", "npc_miner", "npc_guard", "prop_chair"];
self.random_building_spawn(building, build_data, rng, &mut to_place, exit_idx)
@ -242,7 +245,7 @@ impl TownBuilder {
&mut self,
building: &(i32, i32, i32, i32),
build_data: &mut BuilderMap,
rng: &mut rltk::RandomNumberGenerator,
rng: &mut rltk::RandomNumberGenerator
) {
let mut to_place: Vec<&str> = vec!["prop_bed", "prop_table", "dog_little", "prop_chair", "prop_chair"];
self.random_building_spawn(building, build_data, rng, &mut to_place, 0);
@ -252,7 +255,7 @@ impl TownBuilder {
&mut self,
building: &(i32, i32, i32, i32),
build_data: &mut BuilderMap,
rng: &mut rltk::RandomNumberGenerator,
rng: &mut rltk::RandomNumberGenerator
) {
let mut to_place: Vec<&str> = vec!["npc_townsperson", "prop_bed", "prop_table", "prop_chair"];
self.random_building_spawn(building, build_data, rng, &mut to_place, 0);
@ -262,7 +265,7 @@ impl TownBuilder {
&mut self,
building: &(i32, i32, i32, i32),
build_data: &mut BuilderMap,
rng: &mut rltk::RandomNumberGenerator,
rng: &mut rltk::RandomNumberGenerator
) {
let mut to_place: Vec<&str> = vec!["rat", "rat", "rat", "prop_table", "prop_chair"];
self.random_building_spawn(building, build_data, rng, &mut to_place, 0);
@ -285,7 +288,7 @@ impl TownBuilder {
let sand_width = shallow_width + 4;
for y in 0..build_data.height {
let n_water = (f32::sin(n) * variance as f32) as i32 + minimum_width + rng.roll_dice(1, 2);
let n_water = ((f32::sin(n) * (variance as f32)) as i32) + minimum_width + rng.roll_dice(1, 2);
water_width.push(n_water);
n += 0.1;
for x in 0..n_water {
@ -323,10 +326,10 @@ impl TownBuilder {
let start_roll = rng.roll_dice(1, 4);
let largest_water_width;
if water_width[y as usize] > water_width[y as usize + 1] {
if water_width[y as usize] > water_width[(y as usize) + 1] {
largest_water_width = water_width[y as usize];
} else {
largest_water_width = water_width[y as usize + 1];
largest_water_width = water_width[(y as usize) + 1];
}
// Make pier length
@ -360,7 +363,7 @@ impl TownBuilder {
fn town_walls(
&mut self,
rng: &mut rltk::RandomNumberGenerator,
build_data: &mut BuilderMap,
build_data: &mut BuilderMap
) -> (HashSet<usize>, i32) {
let mut available_building_tiles: HashSet<usize> = HashSet::new();
@ -370,7 +373,7 @@ impl TownBuilder {
const HALF_PATH_THICKNESS: i32 = 3;
let wall_gap_y =
(build_data.height / 2) + rng.roll_dice(1, PATH_OFFSET_FROM_CENTRE * 2) - 1 - PATH_OFFSET_FROM_CENTRE;
build_data.height / 2 + rng.roll_dice(1, PATH_OFFSET_FROM_CENTRE * 2) - 1 - PATH_OFFSET_FROM_CENTRE;
for y in BORDER..build_data.height - BORDER {
if !(y > wall_gap_y - HALF_PATH_THICKNESS && y < wall_gap_y + HALF_PATH_THICKNESS) {
@ -384,14 +387,19 @@ impl TownBuilder {
let gravel_idx = build_data.map.xy_idx(x, y);
let roll = rng.roll_dice(1, 6);
match roll {
1 => build_data.map.tiles[gravel_idx] = TileType::Foliage,
2 => build_data.map.tiles[gravel_idx] = TileType::HeavyFoliage,
1 => {
build_data.map.tiles[gravel_idx] = TileType::Foliage;
}
2 => {
build_data.map.tiles[gravel_idx] = TileType::HeavyFoliage;
}
_ => {}
}
if y > BORDER + 1
&& y < build_data.height - BORDER - 1
&& x > OFFSET_FROM_LEFT + 2
&& x < build_data.width - BORDER - 1
if
y > BORDER + 1 &&
y < build_data.height - BORDER - 1 &&
x > OFFSET_FROM_LEFT + 2 &&
x < build_data.width - BORDER - 1
{
available_building_tiles.insert(gravel_idx);
}
@ -420,7 +428,7 @@ impl TownBuilder {
&mut self,
rng: &mut rltk::RandomNumberGenerator,
build_data: &mut BuilderMap,
available_building_tiles: &mut HashSet<usize>,
available_building_tiles: &mut HashSet<usize>
) -> Vec<(i32, i32, i32, i32)> {
let mut buildings: Vec<(i32, i32, i32, i32)> = Vec::new();
let mut n_buildings = 0;
@ -458,9 +466,9 @@ impl TownBuilder {
build_data.map.tiles[idx] = TileType::WoodFloor;
available_building_tiles.remove(&idx);
available_building_tiles.remove(&(idx + 1));
available_building_tiles.remove(&(idx + build_data.width as usize));
available_building_tiles.remove(&(idx + (build_data.width as usize)));
available_building_tiles.remove(&(idx - 1));
available_building_tiles.remove(&(idx - build_data.width as usize));
available_building_tiles.remove(&(idx - (build_data.width as usize)));
}
}
build_data.take_snapshot();
@ -480,10 +488,10 @@ impl TownBuilder {
if build_data.map.tiles[idx + 1] != TileType::WoodFloor {
neighbours += 1;
}
if build_data.map.tiles[idx - build_data.width as usize] != TileType::WoodFloor {
if build_data.map.tiles[idx - (build_data.width as usize)] != TileType::WoodFloor {
neighbours += 1;
}
if build_data.map.tiles[idx + build_data.width as usize] != TileType::WoodFloor {
if build_data.map.tiles[idx + (build_data.width as usize)] != TileType::WoodFloor {
neighbours += 1;
}
if neighbours > 0 {
@ -503,12 +511,12 @@ impl TownBuilder {
rng: &mut rltk::RandomNumberGenerator,
build_data: &mut BuilderMap,
buildings: &mut Vec<(i32, i32, i32, i32)>,
wall_gap_y: i32,
wall_gap_y: i32
) -> Vec<usize> {
let mut doors = Vec::new();
for building in buildings.iter() {
let door_x = building.0 + 1 + rng.roll_dice(1, building.2 - 3);
let cy = building.1 + (building.3 / 2);
let cy = building.1 + building.3 / 2;
let idx = if cy > wall_gap_y {
// Door on north wall
build_data.map.xy_idx(door_x, building.1)
@ -529,7 +537,7 @@ impl TownBuilder {
tiles: &[usize],
tiletype: TileType,
new_road_tiletype: TileType,
include_new_tiles: bool,
include_new_tiles: bool
) {
let mut roads = self.find_tiletype(build_data, tiletype);
@ -537,15 +545,15 @@ impl TownBuilder {
for tile_idx in tiles.iter() {
let mut nearest_tiletype: Vec<(usize, f32)> = Vec::new();
let tile_pt = rltk::Point::new(
*tile_idx as i32 % build_data.map.width as i32,
*tile_idx as i32 / build_data.map.width as i32,
(*tile_idx as i32) % (build_data.map.width as i32),
(*tile_idx as i32) / (build_data.map.width as i32)
);
for r in roads.iter() {
nearest_tiletype.push((
*r,
rltk::DistanceAlg::Manhattan.distance2d(
tile_pt,
rltk::Point::new(*r as i32 % build_data.map.width, *r as i32 / build_data.map.width),
rltk::Point::new((*r as i32) % build_data.map.width, (*r as i32) / build_data.map.width)
),
));
}

6
src/map_builders/voronoi.rs
View file

@ -1,4 +1,4 @@
use super::{BuilderMap, InitialMapBuilder, TileType};
use super::{ BuilderMap, InitialMapBuilder, TileType };
use rltk::RandomNumberGenerator;
#[derive(PartialEq, Copy, Clone)]
@ -55,8 +55,8 @@ impl VoronoiBuilder {
let mut voronoi_distance = vec![(0, 0.0f32); self.n_seeds];
let mut voronoi_membership: Vec<i32> = 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 % build_data.map.width;
let y = i as i32 / build_data.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;

4
src/map_builders/voronoi_spawning.rs
View file

@ -1,4 +1,4 @@
use super::{spawner, BuilderMap, MetaMapBuilder, TileType};
use super::{ spawner, BuilderMap, MetaMapBuilder, TileType };
use rltk::RandomNumberGenerator;
use std::collections::HashMap;
@ -47,7 +47,7 @@ impl VoronoiSpawning {
rng,
area.1,
&mut build_data.spawn_list,
build_data.initial_player_level,
build_data.initial_player_level
);
}
}