2022-01-21 15:55:13 -05:00
|
|
|
//! An object to hold the state of the current level's map
|
2022-02-02 10:08:11 -05:00
|
|
|
pub mod camera;
|
2022-01-05 16:44:44 -05:00
|
|
|
mod dungeon;
|
2022-01-04 15:02:50 -05:00
|
|
|
mod themes;
|
2021-12-24 10:20:29 -05:00
|
|
|
mod tiletype;
|
|
|
|
|
2021-12-10 20:16:48 -05:00
|
|
|
use std::collections::HashSet;
|
|
|
|
|
2022-01-21 15:55:13 -05:00
|
|
|
use ::rltk::{Algorithm2D, BaseMap, Point, SmallVec, RGB};
|
2021-12-24 10:20:29 -05:00
|
|
|
use ::serde::{Deserialize, Serialize};
|
2022-01-05 16:44:44 -05:00
|
|
|
pub use dungeon::*;
|
2022-01-04 15:02:50 -05:00
|
|
|
pub use themes::*;
|
2021-12-24 10:20:29 -05:00
|
|
|
pub use tiletype::{tile_opaque, tile_walkable, TileType};
|
2021-10-22 10:05:06 -04:00
|
|
|
|
2021-12-24 10:20:29 -05:00
|
|
|
use crate::map::tiletype::tile_cost;
|
2022-01-14 12:19:46 -05:00
|
|
|
use crate::{colors, spatial};
|
2021-10-22 10:05:06 -04:00
|
|
|
|
2021-11-08 13:58:40 -05:00
|
|
|
#[derive(Default, Serialize, Deserialize, Clone)]
|
2021-10-25 14:23:19 -04:00
|
|
|
pub struct Map {
|
|
|
|
pub tiles: Vec<TileType>,
|
|
|
|
pub width: i32,
|
|
|
|
pub height: i32,
|
2021-10-25 15:26:39 -04:00
|
|
|
pub revealed_tiles: Vec<bool>,
|
2021-10-26 14:23:08 -04:00
|
|
|
pub visible_tiles: Vec<bool>,
|
2021-11-09 15:50:42 -05:00
|
|
|
pub depth: i32,
|
2021-11-16 10:28:05 -05:00
|
|
|
pub bloodstains: HashSet<usize>,
|
2021-12-17 14:07:14 -05:00
|
|
|
pub view_blocked: HashSet<usize>,
|
2022-01-04 12:12:08 -05:00
|
|
|
pub name: String,
|
2022-01-10 10:21:19 -05:00
|
|
|
pub outdoors: bool,
|
|
|
|
pub light: Vec<RGB>,
|
2021-10-22 10:05:06 -04:00
|
|
|
}
|
|
|
|
|
2021-10-25 14:23:19 -04:00
|
|
|
impl Map {
|
2022-01-21 15:55:13 -05:00
|
|
|
/// Converts an `(x, y)` coordinate to the flat index within the
|
|
|
|
/// `Map`'s internal array.
|
2021-10-25 14:23:19 -04:00
|
|
|
pub fn xy_idx(&self, x: i32, y: i32) -> usize {
|
|
|
|
(y as usize * self.width as usize) + x as usize
|
2021-10-22 10:05:06 -04:00
|
|
|
}
|
|
|
|
|
2021-11-15 13:55:31 -05:00
|
|
|
fn is_exit_valid(&self, x: i32, y: i32) -> bool {
|
|
|
|
if x < 1 || x > self.width - 1 || y < 1 || y > self.height - 1 {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
let idx = self.xy_idx(x, y);
|
|
|
|
|
2022-01-12 10:45:13 -05:00
|
|
|
!spatial::is_blocked(idx)
|
2021-11-15 13:55:31 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
pub fn populate_blocked(&mut self) {
|
2022-01-12 10:45:13 -05:00
|
|
|
spatial::populate_blocked_from_map(self);
|
2021-11-15 13:55:31 -05:00
|
|
|
}
|
|
|
|
|
2022-01-28 11:48:25 -05:00
|
|
|
pub fn populate_blocked_multi(&mut self, width: i32, height: i32) {
|
|
|
|
self.populate_blocked();
|
|
|
|
for y in 1..self.height - 1 {
|
|
|
|
for x in 1..self.width - 1 {
|
|
|
|
let idx = self.xy_idx(x, y);
|
|
|
|
if !spatial::is_blocked(idx) {
|
|
|
|
for cy in 0..height {
|
|
|
|
for cx in 0..width {
|
|
|
|
let tx = x + cx;
|
|
|
|
let ty = y + cy;
|
|
|
|
if tx < self.width - 1 && ty < self.height - 1 {
|
|
|
|
let tidx = self.xy_idx(tx, ty);
|
|
|
|
if spatial::is_blocked(tidx) {
|
|
|
|
spatial::set_blocked(idx, true);
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
spatial::set_blocked(idx, true);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-11-15 13:55:31 -05:00
|
|
|
pub fn clear_content_index(&mut self) {
|
2022-01-12 10:45:13 -05:00
|
|
|
spatial::clear();
|
2021-11-15 13:55:31 -05:00
|
|
|
}
|
|
|
|
|
2021-12-01 10:47:41 -05:00
|
|
|
/// Generates an empty map, consisting entirely of solid walls
|
2022-01-04 12:12:08 -05:00
|
|
|
pub fn new<S: ToString>(new_depth: i32, width: i32, height: i32, name: S) -> Map {
|
2021-12-17 16:35:30 -05:00
|
|
|
let map_tile_count = (width * height) as usize;
|
2022-01-12 10:45:13 -05:00
|
|
|
crate::spatial::set_size(map_tile_count);
|
2021-12-17 16:35:30 -05:00
|
|
|
|
2021-12-01 10:47:41 -05:00
|
|
|
Map {
|
2021-12-17 16:35:30 -05:00
|
|
|
tiles: vec![TileType::Wall; map_tile_count],
|
|
|
|
width,
|
|
|
|
height,
|
|
|
|
revealed_tiles: vec![false; map_tile_count],
|
|
|
|
visible_tiles: vec![false; map_tile_count],
|
2021-11-09 15:50:42 -05:00
|
|
|
depth: new_depth,
|
2021-11-16 10:28:05 -05:00
|
|
|
bloodstains: HashSet::new(),
|
2021-12-17 14:07:14 -05:00
|
|
|
view_blocked: HashSet::new(),
|
2022-01-04 12:12:08 -05:00
|
|
|
name: name.to_string(),
|
2022-01-10 10:21:19 -05:00
|
|
|
outdoors: true,
|
2022-01-14 12:19:46 -05:00
|
|
|
light: vec![colors::BLACK; map_tile_count],
|
2021-10-22 14:50:04 -04:00
|
|
|
}
|
|
|
|
}
|
2021-10-25 15:26:39 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
impl BaseMap for Map {
|
|
|
|
fn is_opaque(&self, idx: usize) -> bool {
|
2021-12-24 10:20:29 -05:00
|
|
|
if idx > 0 && idx < self.tiles.len() {
|
|
|
|
tile_opaque(self.tiles[idx]) || self.view_blocked.contains(&idx)
|
|
|
|
} else {
|
|
|
|
true
|
|
|
|
}
|
2021-10-25 15:26:39 -04:00
|
|
|
}
|
2021-10-29 10:30:17 -04:00
|
|
|
|
|
|
|
fn get_available_exits(&self, idx: usize) -> SmallVec<[(usize, f32); 10]> {
|
2022-01-21 15:55:13 -05:00
|
|
|
let mut exits = SmallVec::new();
|
2021-10-29 10:30:17 -04:00
|
|
|
let x = idx as i32 % self.width;
|
|
|
|
let y = idx as i32 / self.width;
|
|
|
|
let w = self.width as usize;
|
2021-12-24 10:20:29 -05:00
|
|
|
let tt = self.tiles[idx];
|
2021-10-29 10:30:17 -04:00
|
|
|
|
2021-10-29 11:11:17 -04:00
|
|
|
// Cardinal directions
|
2021-10-29 10:30:17 -04:00
|
|
|
if self.is_exit_valid(x - 1, y) {
|
2021-12-24 10:20:29 -05:00
|
|
|
exits.push((idx - 1, tile_cost(tt)))
|
2021-10-29 10:30:17 -04:00
|
|
|
};
|
|
|
|
if self.is_exit_valid(x + 1, y) {
|
2021-12-24 10:20:29 -05:00
|
|
|
exits.push((idx + 1, tile_cost(tt)))
|
2021-10-29 10:30:17 -04:00
|
|
|
};
|
|
|
|
if self.is_exit_valid(x, y - 1) {
|
2021-12-24 10:20:29 -05:00
|
|
|
exits.push((idx - w, tile_cost(tt)))
|
2021-10-29 10:30:17 -04:00
|
|
|
};
|
|
|
|
if self.is_exit_valid(x, y + 1) {
|
2021-12-24 10:20:29 -05:00
|
|
|
exits.push((idx + w, tile_cost(tt)))
|
2021-10-29 10:30:17 -04:00
|
|
|
};
|
|
|
|
|
2021-10-29 11:11:17 -04:00
|
|
|
// Diagonals
|
|
|
|
if self.is_exit_valid(x - 1, y - 1) {
|
2021-12-24 10:20:29 -05:00
|
|
|
exits.push(((idx - w) - 1, tile_cost(tt) * 1.45));
|
2021-10-29 11:11:17 -04:00
|
|
|
}
|
|
|
|
if self.is_exit_valid(x + 1, y - 1) {
|
2021-12-24 10:20:29 -05:00
|
|
|
exits.push(((idx - w) + 1, tile_cost(tt) * 1.45));
|
2021-10-29 11:11:17 -04:00
|
|
|
}
|
|
|
|
if self.is_exit_valid(x - 1, y + 1) {
|
2021-12-24 10:20:29 -05:00
|
|
|
exits.push(((idx + w) - 1, tile_cost(tt) * 1.45));
|
2021-10-29 11:11:17 -04:00
|
|
|
}
|
|
|
|
if self.is_exit_valid(x + 1, y + 1) {
|
2021-12-24 10:20:29 -05:00
|
|
|
exits.push(((idx + w) + 1, tile_cost(tt) * 1.45));
|
2021-10-29 11:11:17 -04:00
|
|
|
}
|
|
|
|
|
2021-10-29 10:30:17 -04:00
|
|
|
exits
|
|
|
|
}
|
|
|
|
|
|
|
|
fn get_pathing_distance(&self, idx1: usize, idx2: usize) -> f32 {
|
|
|
|
let w = self.width as usize;
|
|
|
|
let p1 = Point::new(idx1 % w, idx1 / w);
|
|
|
|
let p2 = Point::new(idx2 % w, idx2 / w);
|
|
|
|
|
2022-01-21 15:55:13 -05:00
|
|
|
::rltk::DistanceAlg::Pythagoras.distance2d(p1, p2)
|
2021-10-29 10:30:17 -04:00
|
|
|
}
|
2021-10-25 15:26:39 -04:00
|
|
|
}
|
|
|
|
|
2021-11-15 13:55:31 -05:00
|
|
|
impl Algorithm2D for Map {
|
|
|
|
fn dimensions(&self) -> Point {
|
|
|
|
Point::new(self.width, self.height)
|
|
|
|
}
|
|
|
|
}
|