roguelike-game/src/map.rs

233 lines
6.5 KiB
Rust
Raw Normal View History

2021-10-29 11:11:17 -04:00
use super::{Rect, MAP_SIZE};
2021-10-29 10:30:17 -04:00
use rltk::{Algorithm2D, BaseMap, Point, RandomNumberGenerator, Rltk, SmallVec, RGB};
2021-10-25 14:23:19 -04:00
use specs::prelude::*;
2021-10-25 15:26:39 -04:00
use std::cmp::{max, min};
2021-10-22 10:05:06 -04:00
#[derive(PartialEq, Copy, Clone)]
pub enum TileType {
Wall,
Floor,
}
2021-10-25 14:23:19 -04:00
pub struct Map {
pub tiles: Vec<TileType>,
pub rooms: Vec<Rect>,
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-10-29 11:11:17 -04:00
pub blocked: Vec<bool>,
2021-10-29 15:15:22 -04:00
pub tile_content: Vec<Vec<Entity>>,
2021-10-22 10:05:06 -04:00
}
2021-10-25 14:23:19 -04:00
impl Map {
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-10-25 14:23:19 -04:00
fn apply_room_to_map(&mut self, room: &Rect) {
2021-10-25 15:26:39 -04:00
for y in room.y1 + 1..=room.y2 {
for x in room.x1 + 1..=room.x2 {
2021-10-25 14:23:19 -04:00
let idx = self.xy_idx(x, y);
self.tiles[idx] = TileType::Floor;
}
2021-10-22 10:05:06 -04:00
}
}
2021-10-25 14:23:19 -04:00
fn apply_horizontal_tunnel(&mut self, x1: i32, x2: i32, y: i32) {
2021-10-25 15:26:39 -04:00
for x in min(x1, x2)..=max(x1, x2) {
2021-10-25 14:23:19 -04:00
let idx = self.xy_idx(x, y);
2021-10-22 14:50:04 -04:00
2021-10-25 14:23:19 -04:00
if idx > 0 && idx < self.width as usize * self.height as usize {
self.tiles[idx as usize] = TileType::Floor;
2021-10-22 14:50:04 -04:00
}
}
2021-10-25 14:23:19 -04:00
}
2021-10-22 14:50:04 -04:00
2021-10-25 14:23:19 -04:00
fn apply_vertical_tunnel(&mut self, y1: i32, y2: i32, x: i32) {
2021-10-25 15:26:39 -04:00
for y in min(y1, y2)..=max(y1, y2) {
2021-10-25 14:23:19 -04:00
let idx = self.xy_idx(x, y);
2021-10-22 14:50:04 -04:00
2021-10-25 14:23:19 -04:00
if idx > 0 && idx < self.width as usize * self.height as usize {
self.tiles[idx as usize] = TileType::Floor;
2021-10-22 14:50:04 -04:00
}
}
}
2021-10-25 14:23:19 -04:00
/// Makes a new map using the algorithm from http://rogueliketutorials.com/tutorials/tcod/part-3/
/// This gives a handful of random rooms and corridors joining them together
pub fn new_map_rooms_and_corridors() -> Map {
let mut map = Map {
2021-10-29 11:11:17 -04:00
tiles: vec![TileType::Wall; MAP_SIZE],
2021-10-25 14:23:19 -04:00
rooms: Vec::new(),
width: 80,
2021-10-25 15:26:39 -04:00
height: 50,
2021-10-29 11:11:17 -04:00
revealed_tiles: vec![false; MAP_SIZE],
visible_tiles: vec![false; MAP_SIZE],
blocked: vec![false; MAP_SIZE],
2021-10-29 15:15:22 -04:00
tile_content: vec![Vec::new(); MAP_SIZE],
2021-10-25 14:23:19 -04:00
};
2021-10-25 15:26:39 -04:00
const MAX_ROOMS: i32 = 30;
const MIN_SIZE: i32 = 6;
const MAX_SIZE: i32 = 10;
2021-10-25 14:23:19 -04:00
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, 80 - w - 1) - 1;
let y = rng.roll_dice(1, 50 - 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;
}
}
2021-10-22 14:50:04 -04:00
2021-10-25 14:23:19 -04:00
if ok {
map.apply_room_to_map(&new_room);
2021-10-22 14:50:04 -04:00
2021-10-25 15:26:39 -04:00
if !map.rooms.is_empty() {
2021-10-25 14:23:19 -04:00
let (new_x, new_y) = new_room.center();
2021-10-25 15:26:39 -04:00
let (prev_x, prev_y) = map.rooms[map.rooms.len() - 1].center();
2021-10-22 14:50:04 -04:00
2021-10-25 14:23:19 -04:00
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);
}
}
2021-10-22 14:50:04 -04:00
2021-10-25 14:23:19 -04:00
map.rooms.push(new_room);
}
2021-10-22 14:50:04 -04:00
}
2021-10-25 14:23:19 -04:00
map
2021-10-22 14:50:04 -04:00
}
2021-10-29 10:30:17 -04: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);
2021-10-29 11:11:17 -04:00
!self.blocked[idx]
}
pub fn populate_blocked(&mut self) {
for (i, tile) in self.tiles.iter_mut().enumerate() {
self.blocked[i] = *tile == TileType::Wall;
}
2021-10-29 10:30:17 -04:00
}
2021-10-29 15:15:22 -04:00
pub fn clear_content_index(&mut self) {
for content in self.tile_content.iter_mut() {
content.clear();
}
}
2021-10-22 14:50:04 -04:00
}
2021-10-25 15:26:39 -04:00
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
}
2021-10-29 10:30:17 -04:00
fn get_available_exits(&self, idx: usize) -> 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;
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) {
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))
};
2021-10-29 11:11:17 -04:00
// 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));
}
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);
rltk::DistanceAlg::Pythagoras.distance2d(p1, p2)
}
2021-10-25 15:26:39 -04:00
}
2021-10-25 14:23:19 -04:00
pub fn draw_map(ecs: &World, ctx: &mut Rltk) {
let map = ecs.fetch::<Map>();
2021-10-22 10:05:06 -04:00
let mut y = 0;
let mut x = 0;
2021-10-25 15:26:39 -04:00
for (idx, tile) in map.tiles.iter().enumerate() {
// Render a tile depending on the tile type
if map.revealed_tiles[idx] {
2021-10-26 14:23:08 -04:00
let glyph;
let mut fg;
2021-10-25 15:26:39 -04:00
match tile {
TileType::Floor => {
2021-10-26 14:23:08 -04:00
glyph = rltk::to_cp437('.');
fg = RGB::from_f32(0., 0.5, 0.5);
2021-10-25 15:26:39 -04:00
}
TileType::Wall => {
2021-10-26 14:23:08 -04:00
glyph = rltk::to_cp437('#');
fg = RGB::from_f32(0., 1.0, 0.);
2021-10-25 15:26:39 -04:00
}
2021-10-22 10:05:06 -04:00
}
2021-10-26 14:23:08 -04:00
if !map.visible_tiles[idx] {
fg = fg.to_greyscale();
}
ctx.set(x, y, fg, RGB::from_f32(0., 0., 0.), glyph);
2021-10-22 10:05:06 -04:00
}
// Move to the next set of coordinates
x += 1;
if x > 79 {
x = 0;
y += 1;
}
}
2021-10-25 15:26:39 -04:00
}