1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
|
//! The `map` module contains structures of the dungeon game map
//! including the current `Floor`, and map `Tile`.
use crate::{const_pos, pos::Pos};
/// `MAP_SIZE` is the size of the size of the dungeon grid.
pub const MAP_SIZE: u16 = 100;
/// `MAP_SIZE` as a usize
pub const MAP_SIZE_USIZE: usize = MAP_SIZE as usize;
/// The number of tiles in the dungeon grid
pub const TILE_COUNT: usize = MAP_SIZE_USIZE * MAP_SIZE_USIZE;
/// The `Tile` enum represents what is (or is not) at
/// any given spot in the dungeon grid.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum Tile {
/// `Wall` represents an impassible wall
Wall,
/// `Air` represents empty walkable space
Air,
}
/// The `Floor` type represents the current playing
/// grid of the dungeon. It contains the tiles of the
/// grid, and the starting position of the player.
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
pub struct Floor {
/// The dungeon grid
tiles: Box<[Tile; TILE_COUNT]>,
/// The position the player starts at
player_start: Pos,
/// The seed used when generating the dungeon grid
seed: u64,
}
impl Floor {
/// Generates a dungeon `Floor` using wave function collapse.
///
/// # Examples
///
/// ```no_run
/// use dungeon::Floor;
///
/// let floor = Floor::generate();
/// ```
#[must_use]
pub fn generate() -> Self {
let seed = rand::random();
Self::generate_seeded(seed)
}
/// Genreates a dungeon `Floor` using wave function collapse provided with a seed.
///
/// The provided seed is used for randomness in the wave function
/// collapse algorithm.
///
/// # Examples
///
/// ```no_run
/// use dungeon::Floor;
///
/// /// here is our very seedy seed
/// let seed = 2893249402u64;
/// let floor = Floor::generate_seeded(seed);
/// ```
#[must_use]
pub fn generate_seeded(_seed: u64) -> Self {
unimplemented!()
}
/// Returns the start position of the player
#[must_use]
pub const fn player_start(&self) -> Pos {
self.player_start
}
/// Returns the seed used to generate the map
#[must_use]
pub const fn seed(&self) -> u64 {
self.seed
}
/// Returns a `Tile` on the dungeon grid at `Pos`.
#[must_use]
pub const fn get(&self, pos: Pos) -> Tile {
let idx = pos.idx();
self.tiles[idx]
}
/// Returns a multable reference to a `Tile` on the dungeon grid at `Pos`.
#[must_use]
pub const fn get_mut(&mut self, pos: Pos) -> &mut Tile {
let idx = pos.idx();
&mut self.tiles[idx]
}
/// Returns a reference to all tiles in the `Floor`.
/// The size of this lise will always be `TILE_COUNT` long.
#[must_use]
pub const fn tiles(&self) -> &[Tile] {
&*self.tiles
}
/// Returns a mutable reference to all tiles in the `Floor`.
/// The size of this lise will always be `TILE_COUNT` long.
#[must_use]
pub const fn tiles_mut(&mut self) -> &mut [Tile] {
&mut *self.tiles
}
}
impl Default for Floor {
/// Returns a floor with a single set of walls on the map border
fn default() -> Self {
let player_start = const_pos!(1, 1);
let mut tiles = Box::new([Tile::Air; TILE_COUNT]);
let seed = 0u64;
for pos in Pos::values() {
if pos.is_border() {
tiles[pos.idx()] = Tile::Wall;
}
}
Self {
tiles,
player_start,
seed,
}
}
}
|
