chess-turn-engine 0.1.1

Chess turn engine library with all chess rules implemented. Can be used to implement a chess game.
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

use std::fmt;
use std::hash::{Hasher, Hash};

/// Player
#[derive(Eq, PartialEq, Debug, Copy, Clone)]
pub enum Side {
    /// Black player
    Black,

    /// White player
    White,
}

impl Side {
    /// Get opponent
    pub fn opponent(&self) -> Self {
        match self {
            Self::Black => Self::White,
            Self::White => Self::Black,
        }
    }

    /// Change side/player
    pub fn switch_side(&mut self) {
        *self = self.opponent();
    }
}

impl Hash for Side {
    fn hash<H: Hasher>(&self, state: &mut H) {
        match self {
            Self::White => state.write_u8(0),
            Self::Black => state.write_u8(1)
        }
    }
}

impl TryFrom<&str> for Side {
    type Error = &'static str;

    fn try_from(side: &str) -> Result<Self, Self::Error> {
        Ok(match side {
            "w" | "W" => Self::White,
            "b" | "B" => Self::Black,
            _ => return Err("Unknown character"),
        })
    }
}

impl TryFrom<char> for Side {
    type Error = &'static str;

    fn try_from(side: char) -> Result<Self, Self::Error> {
        Ok(match side {
            'w' | 'W' => Self::White,
            'b' | 'B' => Self::Black,
            _ => return Err("Unknown character"),
        })
    }
}

impl fmt::Display for Side {
    #[rustfmt::skip]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", match self {
                Self::White => "White",
                Self::Black => "Black",
        })
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn printing_side() {
        assert_eq!(Side::Black.to_string(), "Black");
        assert_eq!(Side::White.to_string(), "White");
    }

    #[test]
    fn opponent() {
        assert_eq!(Side::Black.opponent(), Side::White);
        assert_eq!(Side::White.opponent(), Side::Black);
    }

    #[test]
    fn switch_side() {
        const WHITE: Side = Side::White;
        let mut white = WHITE;
        white.switch_side();
        assert_ne!(white, WHITE);
        white.switch_side();
        assert_eq!(white, WHITE);
    }

    #[test]
    fn try_from_sucess() {
        assert_eq!(Side::Black, Side::try_from('b').unwrap());
        assert_eq!(Side::Black, Side::try_from('B').unwrap());
        assert_eq!(Side::Black, Side::try_from("b").unwrap());
        assert_eq!(Side::Black, Side::try_from("B").unwrap());

        assert_eq!(Side::White, Side::try_from('w').unwrap());
        assert_eq!(Side::White, Side::try_from('W').unwrap());
        assert_eq!(Side::White, Side::try_from("w").unwrap());
        assert_eq!(Side::White, Side::try_from("W").unwrap());
    }

    #[test]
    fn try_from_failure() {
        assert_eq!(Err("Unknown character"), Side::try_from('x'));
    }
}