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
|
use std::convert::From;
#[derive(Clone)]
pub enum TileType {
Empty,
Wall,
Floor,
StairsUp,
StairsDown,
Character(&'static str),
Player,
}
#[derive(Clone)]
pub struct Tile {
tile_type: TileType,
visible: bool,
}
impl Tile {
pub fn new(tile_type: TileType, visible: bool) -> Self {
Tile {
tile_type,
visible,
}
}
pub fn get_type(&self) -> &TileType {
&self.tile_type
}
}
impl From<TileType> for Tile {
fn from(tile_type: TileType) -> Self {
Tile {
tile_type,
visible: true, // <--- TODO: this set the default beaviour
// - true: all tiles of world and entities will be drawn
// - false: only draw tiles visible for the player
}
}
}
pub struct TileGrid {
grid: Vec<Vec<Tile>>,
}
impl TileGrid {
pub fn new(xsize: usize, ysize: usize) -> TileGrid {
let mut grid = TileGrid {
grid: Vec::with_capacity(ysize),
};
for _ in 0..ysize {
let mut subvec = Vec::with_capacity(xsize);
for _ in 0..xsize {
subvec.push(Tile::new(TileType::Empty, true));
}
grid.grid.push(subvec);
}
grid
}
pub fn set_tile(&mut self, x: usize, y: usize, tile: Tile) {
self.grid[y][x] = tile;
}
/// Sets a tile if nothing lies underneath it.
pub fn set_empty_tile(&mut self, x: usize, y: usize, tile: Tile) {
self.set_tile(
x,
y,
match self.grid[y][x].tile_type {
TileType::Empty => tile,
_ => self.grid[y][x].clone(),
},
)
}
pub fn raw_data(&self) -> &Vec<Vec<Tile>> {
&self.grid
}
pub fn block_at(&self, x: usize, y: usize) -> &Tile {
&self.grid[y + 1][x]
}
}
pub fn tile_to_str(tile: &Tile) -> &str {
if tile.visible {
match tile.tile_type {
TileType::Floor => ".",
TileType::Wall => "#",
TileType::Empty => " ",
TileType::StairsDown => ">",
TileType::StairsUp => "<",
TileType::Player => "@",
TileType::Character(t) => t,
}
} else {
" "
}
}
pub trait Tileable {
fn tile(&self, grid: &mut TileGrid) -> Result<(), String>;
}
|
