stockfish-core 0.1.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

use crate::prelude::*;

enumeration! {
    /// A file, A through H, on a chess board. The variants for this enum are
    /// prefixed an underscore to mimic those of [`Rank`].
    pub Piece, [
        Pawn, Knight, Bishop, Rook, Queen, King,
    ]
}

impl Piece {
    /// The single-step moves available to a given piece.
    pub const STEPS: [&'static [Direction]; Self::COUNT] = [
        // pawn
        &[],

        // knight
        &[ Direction::NNW, Direction::NNE, Direction::ENE, Direction::ESE,
           Direction::SSE, Direction::SSW, Direction::WSW, Direction::WNW ],

        // bishop
        &[ Direction::NW, Direction::NE, Direction::SE, Direction::SW ],

        // rook
        &[ Direction::N,  Direction::E,  Direction::S,  Direction::W ],

        // queen
        &[ Direction::NW, Direction::N, Direction::NE, Direction::E,
           Direction::SE, Direction::S, Direction::SW, Direction::W ],

        // king
        &[ Direction::NW, Direction::N, Direction::NE, Direction::E,
           Direction::SE, Direction::S, Direction::SW, Direction::W ],
    ];

    /// Returns true if the [`Piece`] may jump over other pieces.
    #[inline]
    #[must_use]
    pub const fn is_jumping(self) -> bool {
        self == Self::Knight
    }

    /// Returns true if the [`Piece`] slides multiple squares across the board.
    #[inline]
    #[must_use]
    pub const fn is_sliding(self) -> bool {
        self == Self::Bishop || self == Self::Rook || self == Self::Queen
    }
}

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

    #[test]
    fn is_jumping() {
        refute!(Piece::Pawn  .is_jumping());
        assert!(Piece::Knight.is_jumping());
        refute!(Piece::Bishop.is_jumping());
        refute!(Piece::Rook  .is_jumping());
        refute!(Piece::Queen .is_jumping());
        refute!(Piece::King  .is_jumping());
    }

    #[test]
    fn is_sliding() {
        refute!(Piece::Pawn  .is_sliding());
        refute!(Piece::Knight.is_sliding());
        assert!(Piece::Bishop.is_sliding());
        assert!(Piece::Rook  .is_sliding());
        assert!(Piece::Queen .is_sliding());
        refute!(Piece::King  .is_sliding());
    }
}