rs48_lib 1.3.1

components of rs48
Documentation 
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

#[derive(Clone, Copy)]
pub struct Tile {
	value: Option<usize>,
}

impl Tile {
	pub fn new_with_value(value: usize) -> Self {
		Self { value: Some(value) }
	}
	pub fn new_empty() -> Self {
		Self { value: None }
	}

	pub fn value(&self) -> Option<usize> {
		self.value
	}

	pub fn is_empty(&self) -> bool {
		self.value.is_none()
	}
}

#[derive(Clone)]
pub struct Grid {
	size: usize,
	tiles: Vec<Vec<Tile>>,
}

impl Grid {
	///
	/// constructor
	///
	pub fn new(size: usize) -> Self {
		let tiles = (0..size)
			.map(|_| (0..size).map(|_| Tile::new_empty()).collect())
			.collect();
		Self { size, tiles }
	}

	///
	/// set the value of the tile at the selected position
	///
	pub fn set(&mut self, (x, y): (usize, usize), value: Option<usize>) {
		self.tiles[y][x] = if let Some(value) = value {
			Tile::new_with_value(value)
		} else {
			Tile::new_empty()
		};
	}

	///
	/// get a tile if the position is in the grid
	///
	pub fn get(&self, (x, y): (usize, usize)) -> Option<&Tile> {
		match self.tiles.get(y).map(|row| row.get(x)) {
			Some(Some(tile)) => Some(tile),
			_ => None,
		}
	}

	///
	/// get the value of a tile if the position is in the grid and the tile has a value
	///
	pub fn get_val(&self, (x, y): (usize, usize)) -> Option<usize> {
		match self.get((x, y)).map(|tile| tile.value()) {
			Some(Some(value)) => Some(value),
			_ => None,
		}
	}

	///
	/// get the size of the grid
	///
	pub fn size(&self) -> usize {
		self.size
	}

	///
	/// get the array of tiles
	///
	pub fn tiles(&self) -> &Vec<Vec<Tile>> {
		&self.tiles
	}

	///
	/// move a tile over another one, replace the previously occupied place by an empty tile and overrides the destination
	///
	pub fn move_tile(&mut self, (src_x, src_y): (usize, usize), (dst_x, dst_y): (usize, usize)) {
		let src = self.tiles[src_y][src_x];
		self.tiles[dst_y][dst_x] = src;
		self.tiles[src_y][src_x] = Tile::new_empty();
	}

	///
	/// get the biggest value of the board
	///
	pub fn biggest_value(&self) -> usize {
		self.tiles()
			.iter()
			.filter_map(|row| {
				row.iter()
					.filter_map(|tile| tile.value())
					.reduce(|a, b| a.max(b))
			})
			.reduce(|a, b| a.max(b))
			.unwrap_or(0)
	}
}