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
#![allow(dead_code, unused_imports, unused_variables, unused_must_use)]
extern crate rand;
mod color;
mod peg;
pub use color::Color;
use rand::Rng;
use std::fmt;
use std::io;
use io::Write;
pub use peg::Peg;
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_game_step() {
let mut state = GameState::new(4);
let guess = vec![Peg::new(Color::Red), Peg::new(Color::Red), Peg::new(Color::Red), Peg::new(Color::Red)];
let validity = state.step(guess);
println!("{:?}", validity);
}
}
#[derive(Debug)]
pub enum Correctness {
Partial,
Total,
}
impl fmt::Display for Correctness {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{:?}", self)
}
}
pub struct GameState {
answer: Vec<Peg>,
current_turn: u32,
}
impl GameState {
pub fn new(num_pegs: usize) -> GameState {
let answer: Vec<Peg> = (0..num_pegs)
.map(|x: usize| Peg::new_random())
.collect();
GameState::new_with_answer(answer)
}
pub fn new_with_answer(answer: Vec<Peg>) -> GameState {
GameState {
answer,
current_turn: 0,
}
}
pub fn step(&mut self, guess: Vec<Peg>) -> Vec<Correctness> {
self.current_turn += 1;
self.make_guess_response(guess)
}
fn make_guess_response(&mut self, mut guess: Vec<Peg>) -> Vec<Correctness> {
use Correctness::*;
let mut answer = self.answer.clone();
let mut result: Vec<Correctness> = Vec::new();
for i in 0..guess.len() {
if guess[i].color() == answer[i].color() && !answer[i].found() {
result.push(Total);
answer[i].find();
guess[i].find();
}
}
guess.retain(|p| !p.found());
answer.retain(|p| !p.found());
for g in guess.iter() {
answer.iter()
.position(|p| p.color() == g.color())
.map(|index| {
if !answer[index].found() {
result.push(Partial);
answer[index].find();
}
});
}
result
}
}