1use crate::{Dice, Play, Position, Step};
2use std::fmt;
3
4#[derive(Clone, Debug, Eq, PartialEq)]
5pub struct Turn {
10 initial: Position,
11 preview: Position,
12 dice: Dice,
13 plays: Vec<Play>,
14 steps: Vec<Step>,
15}
16
17impl Turn {
18 pub fn new(position: Position, dice: Dice) -> Result<Self, TurnError> {
19 let plays = position.legal_plays(dice);
20 if plays.is_empty() {
21 return Err(TurnError::GameOver);
22 }
23 Ok(Self {
24 initial: position,
25 preview: position,
26 dice,
27 plays,
28 steps: Vec::new(),
29 })
30 }
31
32 pub const fn initial_position(&self) -> Position {
33 self.initial
34 }
35
36 pub const fn preview_position(&self) -> Position {
37 self.preview
38 }
39
40 pub const fn dice(&self) -> Dice {
41 self.dice
42 }
43
44 pub fn steps(&self) -> &[Step] {
45 &self.steps
46 }
47
48 pub fn remaining_dice(&self) -> Vec<u8> {
49 let mut remaining = self.dice.moves();
50 for step in &self.steps {
51 if let Some(index) = remaining.iter().position(|die| *die == step.die()) {
52 remaining.remove(index);
53 }
54 }
55 remaining
56 }
57
58 pub fn legal_steps(&self) -> Vec<Step> {
59 let mut next = self
60 .plays
61 .iter()
62 .filter(|play| play.steps().starts_with(&self.steps))
63 .filter_map(|play| play.steps().get(self.steps.len()).copied())
64 .collect::<Vec<_>>();
65 next.sort();
66 next.dedup();
67 next
68 }
69
70 pub fn select(&mut self, step: Step) -> Result<(), TurnError> {
71 if self.is_complete() || !self.legal_steps().contains(&step) {
72 return Err(TurnError::IllegalStep);
73 }
74 self.preview.apply_step_unchecked(step);
75 self.steps.push(step);
76 Ok(())
77 }
78
79 pub fn undo(&mut self) -> bool {
80 if self.steps.pop().is_none() {
81 return false;
82 }
83 self.preview = self.initial;
84 for &step in &self.steps {
85 self.preview.apply_step_unchecked(step);
86 }
87 true
88 }
89
90 pub fn is_pass(&self) -> bool {
91 self.steps.is_empty() && self.plays.iter().any(Play::is_empty)
92 }
93
94 pub fn is_complete(&self) -> bool {
95 self.plays.iter().any(|play| play.steps() == self.steps)
96 }
97
98 pub fn completed_play(&self) -> Option<&Play> {
99 self.plays.iter().find(|play| play.steps() == self.steps)
100 }
101
102 pub fn finish(self) -> Result<Play, TurnError> {
103 self.plays
104 .into_iter()
105 .find(|play| play.steps() == self.steps)
106 .ok_or(TurnError::Incomplete)
107 }
108}
109
110#[derive(Clone, Copy, Debug, Eq, PartialEq)]
111pub enum TurnError {
112 GameOver,
113 IllegalStep,
114 Incomplete,
115}
116
117impl fmt::Display for TurnError {
118 fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
119 match self {
120 Self::GameOver => formatter.write_str("the game is already over"),
121 Self::IllegalStep => {
122 formatter.write_str("that checker step is not a legal continuation")
123 }
124 Self::Incomplete => formatter.write_str("the checker turn is not complete"),
125 }
126 }
127}
128
129impl std::error::Error for TurnError {}