poirebot 0.1.6

A chess bot engine written in Rust
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 crate::bitboard::{BitBoard, EMPTY};
use crate::game::pieces::{get_anti_diagonal, get_main_diagonal, Color, FILES, RANKS};
use crate::game::Board;

/// Generates a bitboard with the moves that can be performed by the sliding pieces in the given bitboard, horizontally and vertically.
///
/// Note that multiple pieces can be passed in the bitboard; to get the moves for individual pieces,
/// iterate over the pieces and call this function with the singular bitboard for each piece.
pub fn get_sliding_straight_moves(board: &Board, color: Color, origins: &BitBoard) -> BitBoard {
    let mut result = EMPTY;

    let all_pieces = board.white.pieces | board.black.pieces;
    let side = board.get_side(color);
    let own_pieces = side.pieces;

    // From a high-level, the operation here is to subtract the piece from the occupancy
    // See: https://www.chessprogramming.org/Subtracting_a_Rook_from_a_Blocking_Piece
    // The formula is o^(o-2r), and only applies to "positive rays" (moves with positive rank and/or file difference)
    // NB: The formula only works on bitboards with 1 square, so we must do 1 piece at a time
    for origin in *origins {
        let file_mask = &FILES[origin.file_x as usize];
        let rank_mask = &RANKS[origin.rank_y as usize];

        // Start with North (positive vertical)
        // First we find the potential blockers on the same file (vertical)
        let blockers = all_pieces & file_mask;

        // The (o-2r) portion gets the squares between the piece and the closest blocker, excluding the blocker itself
        let square_board = BitBoard::from(origin);
        let difference = blockers - (square_board * 2);

        // The XOR (occupancy ^ difference) portion gives us the tiles between the closest blocker and the piece
        // that aren't occupied. It includes the closest blocker because we intentionally left it out during the
        // (o-2r) portion. We also re-use the file mask because we're not interested in the other pieces.
        // Lastly, we don't want to count the blocker if it's our own piece (it's a capture otherwise).
        result |= (all_pieces ^ difference) & file_mask & !own_pieces;

        // For South (negative vertical), we'll do the same formula but after swapping the board direction.
        // Note: this is a swap, not a rotation, because the file is preserved.
        {
            let blockers = blockers.swap();
            let all_pieces = all_pieces.swap();
            let own_pieces = own_pieces.swap();
            let square_board = square_board.swap();

            let difference = blockers - (square_board * 2);
            result |= ((all_pieces ^ difference) & file_mask & !own_pieces).swap();
        }

        // For East (positive horizontal), it's the same as the North formula, but with the rank mask instead
        let blockers = all_pieces & rank_mask;
        let difference = blockers - (square_board * 2);
        result |= (all_pieces ^ difference) & rank_mask & !own_pieces;

        // For West (negative horizontal), it's the same as the East formula, but we mirror the board horizontally
        // Note: this is a mirror, not a rotation, because the rank is preserved
        let blockers = blockers.mirror_horizontally();
        let all_pieces = all_pieces.mirror_horizontally();
        let own_pieces = own_pieces.mirror_horizontally();
        let square_board = square_board.mirror_horizontally();

        let difference = blockers - (square_board * 2);
        result |= ((all_pieces ^ difference) & rank_mask & !own_pieces).mirror_horizontally();
    }

    result
}

/// Generates a bitboard with the diagonal moves that can be performed by the sliding pieces in the given bitboard.
///
/// Note that multiple pieces can be passed in the bitboard; to get the moves for individual pieces,
/// iterate over the pieces and call this function with the singular bitboard for each piece.
pub fn get_sliding_diagonal_moves(board: &Board, color: Color, origins: &BitBoard) -> BitBoard {
    let mut result = EMPTY;
    let all_pieces = board.white.pieces | board.black.pieces;
    let side = board.get_side(color);
    let own_pieces = side.pieces;

    // From a high-level, the operation here is to subtract the piece from the occupancy
    // The formula is o^(o-2r), and only applies to "positive rays" (moves with positive rank and/or file difference)
    // See the `get_sliding_straight_moves` function above for details about the formula
    // The difference with diagonals is simply the masks, which are based on the main diagonal and the anti-diagonal
    // NB: The formula only works on bitboards with 1 square, so we must do 1 piece at a time
    for origin in *origins {
        let main_mask = get_main_diagonal(&origin);
        let anti_mask = get_anti_diagonal(&origin);

        // Start with the positive-main diagonal (North-East)
        let blockers = all_pieces & main_mask;
        let square_board = BitBoard::from(origin);
        let difference = blockers - (square_board * 2);
        result |= (all_pieces ^ difference) & main_mask & !own_pieces;

        // Then positive-anti diagonal (North-West)
        {
            let blockers = all_pieces & anti_mask;
            let difference = blockers - (square_board * 2);
            result |= (all_pieces ^ difference) & anti_mask & !own_pieces;

            // Then negative-anti diagonal (South-East)
            let blockers = blockers.swap();
            let all_pieces = all_pieces.swap();
            let own_pieces = own_pieces.swap();
            let square_board = square_board.swap();

            let difference = blockers - (square_board * 2);
            result |= ((all_pieces ^ difference) & anti_mask.swap() & !own_pieces).swap();
        }

        // Then negative-main diagonal (South-West)
        let blockers = blockers.swap();
        let all_pieces = all_pieces.swap();
        let own_pieces = own_pieces.swap();
        let square_board = square_board.swap();

        let difference = blockers - (square_board * 2);
        result |= ((all_pieces ^ difference) & main_mask.swap() & !own_pieces).swap();
    }
    result
}