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
|
pub enum BlockType {
Nothing,
Wall,
Floor,
}
pub struct World {
size: usize,
world: Vec<Vec<BlockType>>
}
pub trait GameWorld<'a> {
fn new(size: usize) -> Self;
fn generate(&mut self);
fn get_world(&'a self) -> &'a Vec<Vec<BlockType>>;
fn get_item(&'a self, x: usize, y: usize) -> &'a BlockType;
}
impl World {
fn make_vertical_corridor(&mut self, start: (usize, usize), length: usize) {
let x = start.0;
let endy = start.1 + length;
for y in start.1..endy {
self.wall_up(x - 1, y);
self.set_tile(x, y, BlockType::Floor);
self.wall_up(x + 1, y);
}
}
fn make_horizontal_corridor(&mut self, start: (usize, usize), length: usize) {
let y = start.1;
let endx = start.0 + length;
for x in start.0..endx {
self.wall_up(x, y - 1);
self.set_tile(x, y, BlockType::Floor);
self.wall_up(x, y - 1);
}
}
fn set_tile(&mut self, x: usize, y: usize, block: BlockType) {
self.world[y][x] = block;
}
/// Puts a wall on the coordinates if it isn't a floor.
fn wall_up(&mut self, x: usize, y: usize) {
self.set_tile(x, y, match self.world[y][x] {
BlockType::Floor => BlockType::Floor,
_ => BlockType::Wall
})
}
/// Creates a room at the given coordinates of the given size.
fn make_room(&mut self, start: (usize, usize), width: usize, height: usize) {
let endx = start.0 + width;
let endy = start.1 + height;
// Draw the walls
for x in start.0..endx {
self.wall_up(x, start.1);
self.wall_up(x, endy);
}
for y in start.1..endy {
self.wall_up(start.0, y);
self.wall_up(endx, y);
}
// Fill the room
for x in (start.0 + 1)..(endx) {
for y in (start.1 + 1)..(endy) {
self.set_tile(x, y, BlockType::Floor);
}
}
}
}
impl<'a> GameWorld<'a> for World {
fn new(size: usize) -> World {
World {
size: size,
world: Vec::with_capacity(size)
}
}
fn generate(&mut self) {
for _ in 0..self.size {
let mut subvec = Vec::with_capacity(self.size);
for _ in 0..self.size {
subvec.push(BlockType::Nothing);
}
self.world.push(subvec);
}
self.make_room((1, 13), 5, 7);
self.make_vertical_corridor((3, 5), 10);
}
fn get_world(&'a self) -> &'a Vec<Vec<BlockType>> {
&self.world
}
fn get_item(&'a self, x: usize, y: usize) -> &'a BlockType {
&self.world[x][y]
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_generates_world() {
let mut world = World::new(128);
world.generate();
assert_eq!(world.get_world().len(), 128);
assert_eq!(world.get_world()[0].len(), 128);
match world.get_world()[0][0] {
BlockType::Nothing => assert!(true),
_ => assert!(false)
}
}
}
|
