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
116
117
118
119
120

use super::side::Side;
use chess_notation_parser::CastlingType;

/// Initialization info
///
/// Some chess games might omit castling rights
#[derive(PartialEq)]
pub enum StartingRights {
    All,
    None,
}

/// Struct which keeps track of which castling is possible
#[derive(Hash, Copy, Clone)]
pub struct CastlingRights {
    /// All info can fit within 8 bits
    bitmask: u8,
}

/// Castling masks
const CASTLING_WHITE_LONG: u8 = 1 << 0;
const CASTLING_WHITE_SHORT: u8 = 1 << 1;
const CASTLING_BLACK_LONG: u8 = 1 << 2;
const CASTLING_BLACK_SHORT: u8 = 1 << 3;

impl CastlingRights {
    /// Create new CastlingRights with given rights
    pub fn new(rights: StartingRights) -> CastlingRights {
        let mut ret = Self { bitmask: 0 };

        if rights == StartingRights::None {
            return ret;
        }

        ret.insert((Side::White, CastlingType::Long));
        ret.insert((Side::White, CastlingType::Short));
        ret.insert((Side::Black, CastlingType::Long));
        ret.insert((Side::Black, CastlingType::Short));
        ret
    }

    /// Get all castling rights packed in a vector
    pub fn get(&self) -> Vec<(Side, CastlingType)> {
        let mut ret = Vec::<(Side, CastlingType)>::with_capacity(4);

        if self.bitmask & CASTLING_WHITE_LONG != 0 {
            ret.push((Side::White, CastlingType::Long));
        }
        if self.bitmask & CASTLING_WHITE_SHORT != 0 {
            ret.push((Side::White, CastlingType::Short));
        }
        if self.bitmask & CASTLING_BLACK_LONG != 0 {
            ret.push((Side::Black, CastlingType::Long));
        }
        if self.bitmask & CASTLING_BLACK_SHORT != 0 {
            ret.push((Side::Black, CastlingType::Short));
        }

        ret
    }

    /// Insert castling right
    ///
    /// If the set did not have this value present, true is returned.
    ///
    /// If the set did have this value present, false is returned.
    pub fn insert(&mut self, (side, castling): (Side, CastlingType)) -> bool {
        let mask = Self::get_mask((side, castling));

        if mask & self.bitmask != 0 {
            return true;
        }

        self.bitmask |= mask;
        false
    }

    /// Remove castling right
    pub fn remove(&mut self, (side, castling): &(Side, CastlingType)) -> bool {
        let mask = Self::get_mask((*side, *castling));

        if mask & self.bitmask == 0 {
            return false;
        }

        self.bitmask &= !mask;
        true
    }

    /// Returns true if no castling rights available
    pub fn is_empty(&self) -> bool {
        self.bitmask == 0
    }

    /// Convert tuple into a bitmask
    fn get_mask(side_castling: (Side, CastlingType)) -> u8 {
        match side_castling {
            (Side::White, CastlingType::Long) => CASTLING_WHITE_LONG,
            (Side::White, CastlingType::Short) => CASTLING_WHITE_SHORT,
            (Side::Black, CastlingType::Long) => CASTLING_BLACK_LONG,
            (Side::Black, CastlingType::Short) => CASTLING_BLACK_SHORT,
        }
    }
}

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

    #[test]
    fn extra_insert_does_nothing() {
        let mut map = CastlingRights::new(StartingRights::None);

        let castling = (Side::White, CastlingType::Long);
        assert_eq!(map.insert(castling), false);
        assert_eq!(map.insert(castling), true);
        assert_eq!(map.remove(&castling), true);
        assert_eq!(map.remove(&castling), false);
    }
}