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
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147

use std::{thread, time::Duration};

use crate::{
	controller::Controller,
	game::{self, Game, GameError},
};

use super::{clear_term, grid_displayer::GridDisplayer};

pub struct Rules {
	display: bool,
	display_skips: usize,
	clear_term: bool,
	color_seed: u16,
	turn_duration: Duration,
}

impl Rules {
	/// wether to display the game at all or not
	pub fn display(mut self, display: bool) -> Self {
		self.display = display;
		self
	}

	/// turns to skip the display of
	pub fn display_skips(mut self, display_skips: usize) -> Self {
		self.display_skips = display_skips;
		self
	}

	/// wether to clear the terminal or not between displays
	pub fn clear_term(mut self, clear_term: bool) -> Self {
		self.clear_term = clear_term;
		self
	}

	/// seed for the procedural coloration of tiles
	pub fn color_seed(mut self, color_seed: u16) -> Self {
		self.color_seed = color_seed;
		self
	}

	/// duration of pauses between turns
	pub fn turn_duration(mut self, turn_duration: Duration) -> Self {
		self.turn_duration = turn_duration;
		self
	}
}

impl Default for Rules {
	fn default() -> Self {
		Self {
			display: true,
			display_skips: 0,
			clear_term: true,
			color_seed: 35,
			turn_duration: Duration::ZERO,
		}
	}
}

pub struct GameManager {
	game: Game,
	controller: Box<dyn Controller>,
	grid_displayer: GridDisplayer,
	display_to_skip: usize,
	display: bool,
	display_skips: usize,
	clear_term: bool,
	turn_duration: Duration,
}

impl GameManager {
	pub fn new(
		game_rules: game::Rules,
		manager_rules: self::Rules,
		controller: Box<dyn Controller>,
	) -> Self {
		let game = Game::new(game_rules);
		let Rules {
			clear_term,
			color_seed,
			display,
			display_skips,
			turn_duration,
		} = manager_rules;
		let grid_displayer = GridDisplayer::new(color_seed);
		Self {
			game,
			controller,
			display_to_skip: 0,
			display,
			display_skips,
			clear_term,
			turn_duration,
			grid_displayer,
		}
	}

	pub fn turn(&mut self) -> Result<(), GameError> {
		self.display_conditionnally();
		self.game_turn()?;
		thread::sleep(self.turn_duration);
		Ok(())
	}

	fn display_conditionnally(&mut self) {
		if self.display {
			if self.display_to_skip == 0 {
				if self.clear_term {
					clear_term();
				}
				self.print_display();
				self.display_to_skip = self.display_skips;
			} else {
				self.display_to_skip -= 1;
			}
		}
	}

	fn game_turn(&mut self) -> Result<(), GameError> {
		let movement = self.controller.next_move(&self.game)?;
		self.game.turn(movement)?;
		Ok(())
	}

	pub fn print_display(&self) {
		let headline_display = self.get_headline_display();
		println!("{headline_display}");
		let grid = self.game.get_board();
		let grid_display = self.grid_displayer.display(grid);
		println!("{grid_display}");
	}

	fn get_headline_display(&self) -> String {
		let score = self.game.get_score();
		let turn = self.game.get_turn_index();
		let biggest_tile = self.game.get_board().biggest_value();
		format!("score: {score:>12} | biggest tile: {biggest_tile:>12} | turn: {turn:>12}")
	}

	pub fn play_all(&mut self) -> Result<(), GameError> {
		loop {
			self.turn()?;
		}
	}
}