stockfish-core 0.2.0

Core types for implementing a fast chess engine
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
121
122
123
124
125

use crate::prelude::*;

enumeration! {
    /// Represents a complete type of castling, including the color to castle
    /// and the side to which castling will occur.
    pub CastlingVariety, [
        WhiteKingside, WhiteQueenside,
        BlackKingside, BlackQueenside,
    ]
}

impl CastlingVariety {
    const COLORS: [Color; Self::COUNT] = [
        Color::White, Color::White,
        Color::Black, Color::Black,
    ];

    const KING_DESTINATIONS: [Square; Self::COUNT] = [
        Square::G1, Square::C1,
        Square::G8, Square::C8,
    ];

    const ROOK_DESTINATIONS: [Square; Self::COUNT] = [
        Square::F1, Square::D1,
        Square::F8, Square::D8,
    ];

    const KINDS: [[Self; CastlingSide::COUNT]; Color::COUNT] = [
        [ Self::WhiteKingside, Self::WhiteQueenside ],
        [ Self::BlackKingside, Self::BlackQueenside ],
    ];

    const SIDES: [CastlingSide; Self::COUNT] = [
        CastlingSide::King, CastlingSide::Queen,
        CastlingSide::King, CastlingSide::Queen,
    ];

    const RIGHTS: [CastlingRights; Self::COUNT] = [
        CastlingRights::WHITE_OO, CastlingRights::WHITE_OOO,
        CastlingRights::BLACK_OO, CastlingRights::BLACK_OOO,
    ];

    /// Returns the variety of castling for the given `color` and `side`.
    #[inline]
    pub const fn new(color: Color, side: CastlingSide) -> Self {
        Self::KINDS[color][side]
    }

    /// Returns the color of the player involved in this castling variety
    #[inline]
    pub const fn color(self) -> Color {
        Self::COLORS[self]
    }

    /// Returns the side of the board this castling variety will occur towards.
    #[inline]
    pub const fn side(self) -> CastlingSide {
        Self::SIDES[self]
    }

    /// Returns the square the king finishes on.
    #[inline]
    pub const fn king_destination(self) -> Square {
        Self::KING_DESTINATIONS[self]
    }

    /// Returns the square the rook finishes on.
    #[inline]
    pub const fn rook_destination(self) -> Square {
        Self::ROOK_DESTINATIONS[self]
    }

    /// Returns the individual rights required for this castling variety to be
    /// eligible.
    #[inline]
    pub const fn rights(self) -> CastlingRights {
        Self::RIGHTS[self]
    }
}

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

    #[test]
    fn color() {
        assert!(CastlingVariety::WhiteKingside .color().is_white());
        assert!(CastlingVariety::WhiteQueenside.color().is_white());
        assert!(CastlingVariety::BlackKingside .color().is_black());
        assert!(CastlingVariety::BlackQueenside.color().is_black());
    }

    #[test]
    fn side() {
        assert_eq!(CastlingSide::King,  CastlingVariety::WhiteKingside .side());
        assert_eq!(CastlingSide::Queen, CastlingVariety::WhiteQueenside.side());
        assert_eq!(CastlingSide::King,  CastlingVariety::BlackKingside .side());
        assert_eq!(CastlingSide::Queen, CastlingVariety::BlackQueenside.side());
    }


    #[test]
    fn king_destination() {
        assert_eq!(Square::G1, CastlingVariety::WhiteKingside .king_destination());
        assert_eq!(Square::C1, CastlingVariety::WhiteQueenside.king_destination());
        assert_eq!(Square::G8, CastlingVariety::BlackKingside .king_destination());
        assert_eq!(Square::C8, CastlingVariety::BlackQueenside.king_destination());
    }

    #[test]
    fn rook_destination() {
        assert_eq!(Square::F1, CastlingVariety::WhiteKingside .rook_destination());
        assert_eq!(Square::D1, CastlingVariety::WhiteQueenside.rook_destination());
        assert_eq!(Square::F8, CastlingVariety::BlackKingside .rook_destination());
        assert_eq!(Square::D8, CastlingVariety::BlackQueenside.rook_destination());
    }

    #[test]
    fn rights() {
        assert_eq!(CastlingRights::WHITE_OO,  CastlingVariety::WhiteKingside .rights());
        assert_eq!(CastlingRights::WHITE_OOO, CastlingVariety::WhiteQueenside.rights());
        assert_eq!(CastlingRights::BLACK_OO,  CastlingVariety::BlackKingside .rights());
        assert_eq!(CastlingRights::BLACK_OOO, CastlingVariety::BlackQueenside.rights());
    }
}