fast-tak 0.4.2

Implementation of the abstract strategy board game Tak
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

use takparse::{Color, WinReason};

#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord)]
pub enum GameResult {
    Winner {
        color: Color,
        reason: Reason,
    },
    Draw {
        reason: Reason,
    },
    #[default]
    Ongoing,
}

#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord)]
pub enum Reason {
    Road,
    ReservesDepleted,
    BoardFill,
    ReversiblePlies,
}

impl From<Reason> for WinReason {
    fn from(reason: Reason) -> Self {
        match reason {
            Reason::Road => Self::Road,
            Reason::BoardFill | Reason::ReservesDepleted => Self::Flat,
            Reason::ReversiblePlies => Self::Other,
        }
    }
}

pub struct Ongoing;

impl TryFrom<GameResult> for takparse::GameResult {
    type Error = Ongoing;

    fn try_from(result: GameResult) -> Result<Self, Self::Error> {
        Ok(match result {
            GameResult::Ongoing => return Err(Ongoing),
            GameResult::Draw { .. } => Self::Draw,
            GameResult::Winner {
                color: Color::White,
                reason,
            } => Self::White(reason.into()),
            GameResult::Winner {
                color: Color::Black,
                reason,
            } => Self::Black(reason.into()),
        })
    }
}