123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301 |
- use rltk::{RandomNumberGenerator, RGB, Rltk, Algorithm2D, Point, BaseMap};
- use super::{Rect};
- use std::cmp::{max, min};
- use specs::prelude::*;
- use serde::{Serialize, Deserialize};
- use std::collections::HashSet;
- pub const MAPWIDTH : usize = 80;
- pub const MAPHEIGHT : usize = 38;
- pub const MAPCOUNT : usize = MAPHEIGHT * MAPWIDTH;
- #[derive(PartialEq, Copy, Clone, Serialize, Deserialize)]
- pub enum TileType {
- Wall,
- Floor,
- DownStairs,
- }
- #[derive(Default, Serialize, Deserialize, Clone)]
- pub struct Map {
- pub tiles: Vec<TileType>,
- pub rooms: Vec<Rect>,
- pub width: i32,
- pub height: i32,
- pub revealed_tiles : Vec<bool>,
- pub visible_tiles: Vec<bool>,
- pub blocked : Vec<bool>,
- pub depth: i32,
- pub bloodstains : HashSet<usize>,
- #[serde(skip_serializing)]
- #[serde(skip_deserializing)]
- pub tile_content : Vec<Vec<Entity>>
- }
- impl Map {
- pub fn clear_content_index(&mut self) {
- for content in self.tile_content.iter_mut() {
- content.clear();
- }
- }
- pub fn populate_blocked(&mut self) {
- for (i,tile) in self.tiles.iter_mut().enumerate() {
- self.blocked[i] = *tile == TileType::Wall;
- }
- }
- 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);
- !self.blocked[idx]
- }
- pub fn xy_idx(&self, x: i32, y: i32) -> usize {
- (y as usize * self.width as usize) + x as usize
- }
- fn apply_room_to_map(&mut self, room: &Rect) {
- for y in room.y1 +1 ..= room.y2 {
- for x in room.x1 + 1 ..= room.x2 {
- let idx = self.xy_idx(x,y);
- self.tiles[idx] = TileType::Floor;
- }
- }
- }
- fn apply_horizontal_tunnel(&mut self, x1:i32, x2:i32, y:i32) {
- for x in min(x1,x2) ..= max(x1,x2) {
- let idx = self.xy_idx(x, y);
- if idx > 0 && idx < self.width as usize * self.height as usize {
- self.tiles[idx as usize] = TileType::Floor;
- }
- }
- }
- fn apply_vertical_tunnel(&mut self, y1:i32, y2:i32, x:i32) {
- for y in min(y1,y2) ..= max(y1,y2) {
- let idx = self.xy_idx(x, y);
- if idx > 0 && idx < self.width as usize * self.height as usize {
- self.tiles[idx as usize] = TileType::Floor;
- }
- }
- }
- pub fn new_map_rooms_and_corridors(new_depth: i32) -> Map {
- let mut map = Map{
- tiles : vec![TileType::Wall; MAPCOUNT],
- rooms : Vec::new(),
- width : MAPWIDTH as i32,
- height: MAPHEIGHT as i32,
- revealed_tiles : vec![false; MAPCOUNT],
- visible_tiles : vec![false; MAPCOUNT],
- blocked : vec![false; MAPCOUNT],
- depth: new_depth,
- bloodstains: HashSet::new(),
- tile_content : vec![Vec::new(); MAPCOUNT]
- };
-
- const MAX_ROOMS : i32 = 30;
- const MIN_SIZE : i32 = 6;
- const MAX_SIZE : i32 = 10;
-
- let mut rng = RandomNumberGenerator::new();
-
- for _ in 0..MAX_ROOMS {
- let w = rng.range(MIN_SIZE, MAX_SIZE);
- let h = rng.range(MIN_SIZE, MAX_SIZE);
- let x = rng.roll_dice(1, map.width - w - 1) - 1;
- let y = rng.roll_dice(1, map.height - h - 1) - 1;
- let new_room = Rect::new(x, y, w, h);
- let mut ok = true;
- for other_room in map.rooms.iter() {
- if new_room.intersect(other_room) { ok = false }
- }
- if ok {
- map.apply_room_to_map(&new_room);
-
- if !map.rooms.is_empty() {
- let (new_x, new_y) = new_room.center();
- let (prev_x, prev_y) = map.rooms[map.rooms.len()-1].center();
- if rng.range(0,2) == 1 {
- map.apply_horizontal_tunnel(prev_x, new_x, prev_y);
- map.apply_vertical_tunnel(prev_y, new_y, new_x);
- } else {
- map.apply_vertical_tunnel(prev_y, new_y, prev_x);
- map.apply_horizontal_tunnel(prev_x, new_x, new_y);
- }
- }
- map.rooms.push(new_room);
- }
- }
- let stairs_position = map.rooms[map.rooms.len()-1].center();
- let stairs_idx = map.xy_idx(stairs_position.0, stairs_position.1);
- map.tiles[stairs_idx] = TileType::DownStairs;
-
- map
- }
- }
- impl Algorithm2D for Map {
- fn dimensions(&self) -> Point {
- Point::new(self.width, self.height)
- }
- }
- impl BaseMap for Map {
- fn is_opaque(&self, idx:usize) -> bool {
- self.tiles[idx as usize] == TileType::Wall
- }
- fn get_available_exits(&self, idx:usize) -> rltk::SmallVec<[(usize, f32); 10]> {
- let mut exits = rltk::SmallVec::new();
- let x = idx as i32 % self.width;
- let y = idx as i32 / self.width;
- let w = self.width as usize;
-
- // Cardinal directions
- if self.is_exit_valid(x-1, y) { exits.push((idx-1, 1.0)) };
- if self.is_exit_valid(x+1, y) { exits.push((idx+1, 1.0)) };
- if self.is_exit_valid(x, y-1) { exits.push((idx-w, 1.0)) };
- if self.is_exit_valid(x, y+1) { exits.push((idx+w, 1.0)) };
- // Diagonals
- if self.is_exit_valid(x-1, y-1) { exits.push(((idx-w)-1, 1.45)); }
- if self.is_exit_valid(x+1, y-1) { exits.push(((idx-w)+1, 1.45)); }
- if self.is_exit_valid(x-1, y+1) { exits.push(((idx+w)-1, 1.45)); }
- if self.is_exit_valid(x+1, y+1) { exits.push(((idx+w)+1, 1.45)); }
-
- 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);
- rltk::DistanceAlg::Pythagoras.distance2d(p1, p2)
- }
- }
- // /// Makes a map with solid boundaries and 400 randomly placed walls. No guarantees that it won't
- // /// look awful.
- // pub fn new_map_test() -> Vec<TileType> {
- // let mut map = vec![TileType::Floor; MAPCOUNT];
- // // Make the boundaries walls
- // for x in 0..80 {
- // map[xy_idx(x, 0)] = TileType::Wall;
- // map[xy_idx(x, 49)] = TileType::Wall;
- // }
- // for y in 0..50 {
- // map[xy_idx(0, y)] = TileType::Wall;
- // map[xy_idx(79, y)] = TileType::Wall;
- // }
- // // Now we'll randomly splat a bunch of walls. It won't be pretty, but it's a decent illustration.
- // // First, obtain the thread-local RNG:
- // let mut rng = rltk::RandomNumberGenerator::new();
- // for _i in 0..400 {
- // let x = rng.roll_dice(1, 79);
- // let y = rng.roll_dice(1, 49);
- // let idx = xy_idx(x, y);
- // if idx != xy_idx(40, 25) {
- // map[idx] = TileType::Wall;
- // }
- // }
- // return map
- // }
- fn is_revealed_and_wall(map: &Map, x: i32, y: i32) -> bool {
- let idx = map.xy_idx(x, y);
- map.tiles[idx] == TileType::Wall && map.revealed_tiles[idx]
- }
- fn wall_glyph(map : &Map, x: i32, y:i32) -> rltk::FontCharType {
- if x < 1 || x > map.width-2 || y < 1 || y > map.height-2 as i32 { return 35; }
- let mut mask : u8 = 0;
- if is_revealed_and_wall(map, x, y - 1) { mask +=1; }
- if is_revealed_and_wall(map, x, y + 1) { mask +=2; }
- if is_revealed_and_wall(map, x - 1, y) { mask +=4; }
- if is_revealed_and_wall(map, x + 1, y) { mask +=8; }
- match mask {
- 0 => { 9 } // Pillar because we can't see neighbors
- 1 => { 186 } // Wall only to the north
- 2 => { 186 } // Wall only to the south
- 3 => { 186 } // Wall to the north and south
- 4 => { 205 } // Wall only to the west
- 5 => { 188 } // Wall to the north and west
- 6 => { 187 } // Wall to the south and west
- 7 => { 185 } // Wall to the north, south and west
- 8 => { 205 } // Wall only to the east
- 9 => { 200 } // Wall to the north and east
- 10 => { 201 } // Wall to the south and east
- 11 => { 204 } // Wall to the north, south and east
- 12 => { 205 } // Wall to the east and west
- 13 => { 202 } // Wall to the east, west, and south
- 14 => { 203 } // Wall to the east, west, and north
- 15 => { 206 } // ╬ Wall on all sides
- _ => { 35 } // We missed one?
- }
- }
- pub fn draw_map(ecs: &World, ctx : &mut Rltk) {
- let map = ecs.fetch::<Map>();
- let mut y = 0;
- let mut x = 0;
- for (idx,tile) in map.tiles.iter().enumerate() {
- // Render a tile depending upon the tile type
- if map.revealed_tiles[idx] {
- let glyph;
- let mut fg;
- let mut bg = RGB::from_f32(0., 0., 0.);
- match tile {
- TileType::Floor => {
- glyph = rltk::to_cp437('.');
- fg = RGB::from_f32(1.0, 0.5, 0.7);
- }
- TileType::Wall => {
- glyph = wall_glyph(&*map, x, y);
- fg = RGB::from_f32(1.0, 0.6, 0.);
- }
- TileType::DownStairs => {
- glyph = rltk::to_cp437('>');
- fg = RGB::from_f32(0.0,1.0,1.0);
- }
- }
- // Render bloodstains
- if map.bloodstains.contains(&idx) {
- bg = RGB::from_f32(0.75, 0., 0.);
- }
- // Fog of war
- if !map.visible_tiles[idx] {
- fg = fg.to_greyscale();
- bg = RGB::from_f32(0., 0., 0.); // Don't show blood out of visual range
- }
- ctx.set(x, y, fg, bg, glyph);
- }
- // Move the coordinates
- x += 1;
- if x > 79 {
- x = 0;
- y += 1;
- }
- }
- }
|