Skip to main content

ai_backgammon/
turn.rs

1use crate::{Dice, Play, Position, Step};
2use std::fmt;
3
4#[derive(Clone, Debug, Eq, PartialEq)]
5/// A checker turn entered one legal step at a time.
6///
7/// The continuation set is filtered from complete legal plays, so partial
8/// input cannot bypass the maximum-dice or higher-die rules.
9pub 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 {}