pounce 2.0.2

A mediocre (but trying its best) uci 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
126
127
128

use crate::chess::bitboard::Bitboard;
use crate::chess::movegen::types::{FromAndMoves, MoveList, Mover, PawnType};
use crate::chess::movegen::utils::{
    between, get_bishop_moves, get_pawn_attacks, get_pawn_moves, get_rook_moves, line,
};
use crate::chess::{Color, Position, Role, Square};

impl Mover for PawnType {
    #[inline]
    fn into_piece() -> Role {
        Role::Pawn
    }

    #[inline]
    fn pseudo_legal_moves<const BLACK: bool>(from: Square, pos: &Position) -> Bitboard {
        let mut bb = Bitboard::EMPTY;
        let side = match BLACK {
            true => Color::Black,
            false => Color::White,
        };
        // add single moves
        if from
            .up(side)
            .is_some_and(|s| pos.occupancy & s == Bitboard::EMPTY)
        {
            bb |= get_pawn_moves(from, side);
            bb &= !pos.occupancy;
        }

        bb |= get_pawn_attacks(from, side) & pos.by_color[side.opponent()];
        bb
    }

    #[inline]
    fn legal_moves<const CHECK: bool, const BLACK: bool>(pos: &Position, movelist: &mut MoveList) {
        let side = match BLACK {
            true => Color::Black,
            false => Color::White,
        };
        let ksq = Square::from(pos.king_of(side));
        let pieces = pos.by_color_role(side, Self::into_piece());
        let pinned = pos.pinned[side];
        let checkers = pos.checkers[side];

        let promotion_bb = Bitboard::from(side.opponent().home_rank());

        let check_mask = if CHECK {
            between(Square::from(checkers), ksq) ^ checkers
        } else {
            Bitboard::FULL
        };

        for sq in pieces & !pinned {
            let moves = Self::pseudo_legal_moves::<BLACK>(sq, pos) & check_mask;
            if moves != Bitboard::EMPTY {
                unsafe {
                    movelist.push_unchecked(FromAndMoves::new(
                        sq,
                        moves,
                        promotion_bb & Bitboard::from(sq) != Bitboard::EMPTY,
                        false,
                    ));
                }
            }
        }

        if !CHECK {
            for sq in pieces & pinned {
                let moves = Self::pseudo_legal_moves::<BLACK>(sq, pos) & line(ksq, sq);
                if moves != Bitboard::EMPTY {
                    unsafe {
                        movelist.push_unchecked(FromAndMoves::new(
                            sq,
                            moves,
                            promotion_bb & Bitboard::from(sq) != Bitboard::EMPTY,
                            false,
                        ));
                    }
                }
            }
        }

        if let Some(ep) = pos.ep_square {
            // en passant source squares are the same as the squares that any
            // enemy pawn could attack from the en passant square
            let ep_source_squares = get_pawn_attacks(ep, side.opponent()) & pos.our(Role::Pawn);
            for sq in ep_source_squares {
                if Self::legal_ep_move::<BLACK>(sq, ep, pos) {
                    unsafe {
                        movelist.push_unchecked(FromAndMoves::new(
                            sq,
                            Bitboard::from(ep),
                            false,
                            true,
                        ));
                    }
                }
            }
        }
    }
}

impl PawnType {
    #[inline]
    fn legal_ep_move<const BLACK: bool>(from: Square, to: Square, pos: &Position) -> bool {
        let side = match BLACK {
            true => Color::Black,
            false => Color::White,
        };
        let ksq = Square::from(pos.king_of(side));
        let mask = pos.occupancy
            ^ Bitboard::from(from) // unset the from square
            ^ Bitboard::from(to) // set the to square
            ^ Bitboard::from(to.down(side).unwrap()); // unset the captured pawn

        // be careful about the parentheses here, the & operator has higher
        // precedence than the | operator
        let rooks =
            (pos.by_role[Role::Rook] | pos.by_role[Role::Queen]) & pos.by_color[side.opponent()];
        let bishops =
            (pos.by_role[Role::Bishop] | pos.by_role[Role::Queen]) & pos.by_color[side.opponent()];

        let mut attackers = Bitboard::EMPTY;
        attackers |= get_rook_moves(ksq, mask) & rooks;
        attackers |= get_bishop_moves(ksq, mask) & bishops;
        attackers == Bitboard::EMPTY
    }
}