8-add-legal-move-filter (#16)

works on #8

Reviewed-on: #16
Co-authored-by: Josh <josh@joshuaschuett.com>
Co-committed-by: Josh <josh@joshuaschuett.com>

engine/src/bitboard.c

@@ -220,6 +220,9 @@ void gen_white_pawn_push_promotions(const struct Board *board, struct Move *out,
         int to   = pop_lsb_index(&promos);
         int from = to - 8;
         push_move(out, count, from, to, P, Q, MF_PROMO);
+        push_move(out, count, from, to, P, R, MF_PROMO);
+        push_move(out, count, from, to, P, B, MF_PROMO);
+        push_move(out, count, from, to, P, N, MF_PROMO);
     }
 }
 
@@ -235,6 +238,9 @@ void gen_black_pawn_push_promotions(const struct Board *board, struct Move *out,
         int to   = pop_lsb_index(&promos);
         int from = to + 8;
         push_move(out, count, from, to, p, q, MF_PROMO);
+        push_move(out, count, from, to, p, r, MF_PROMO);
+        push_move(out, count, from, to, p, b, MF_PROMO);
+        push_move(out, count, from, to, p, n, MF_PROMO);
     }
 }
 
@@ -246,6 +252,9 @@ void gen_white_pawn_capture_promotions(const struct Board *board, struct Move *o
         int to = pop_lsb_index(&left);
         int from = to - 7;
         push_move(out, count, from, to, P, Q, MF_CAPTURE | MF_PROMO);
+        push_move(out, count, from, to, P, R, MF_CAPTURE | MF_PROMO);
+        push_move(out, count, from, to, P, B, MF_CAPTURE | MF_PROMO);
+        push_move(out, count, from, to, P, N, MF_CAPTURE | MF_PROMO);
     }
     // right capture: +9, mask off file H
     uint64_t right = ((board->pieces[P] & ~FILE_H) << 9) & opp & RANK_8;
@@ -253,6 +262,9 @@ void gen_white_pawn_capture_promotions(const struct Board *board, struct Move *o
         int to = pop_lsb_index(&right);
         int from = to - 9;
         push_move(out, count, from, to, P, Q, MF_CAPTURE | MF_PROMO);
+        push_move(out, count, from, to, P, R, MF_CAPTURE | MF_PROMO);
+        push_move(out, count, from, to, P, B, MF_CAPTURE | MF_PROMO);
+        push_move(out, count, from, to, P, N, MF_CAPTURE | MF_PROMO);
     }
 }
 
@@ -264,6 +276,9 @@ void gen_black_pawn_capture_promotions(const struct Board *board, struct Move *o
         int to = pop_lsb_index(&left);
         int from = to + 7;
         push_move(out, count, from, to, p, q, MF_CAPTURE | MF_PROMO);
+        push_move(out, count, from, to, p, r, MF_CAPTURE | MF_PROMO);
+        push_move(out, count, from, to, p, b, MF_CAPTURE | MF_PROMO);
+        push_move(out, count, from, to, p, n, MF_CAPTURE | MF_PROMO);
     }
     // “right” is -9 (mask off file A)
     uint64_t right = ((board->pieces[p] & ~FILE_A) >> 9) & opp & RANK_1;
@@ -271,6 +286,9 @@ void gen_black_pawn_capture_promotions(const struct Board *board, struct Move *o
         int to = pop_lsb_index(&right);
         int from = to + 9;
         push_move(out, count, from, to, p, q, MF_CAPTURE | MF_PROMO);
+        push_move(out, count, from, to, p, r, MF_CAPTURE | MF_PROMO);
+        push_move(out, count, from, to, p, b, MF_CAPTURE | MF_PROMO);
+        push_move(out, count, from, to, p, n, MF_CAPTURE | MF_PROMO);
     }
 }
 
@@ -575,6 +593,198 @@ bool square_attacked(const struct Board *board, int sq, enum Color by) {
     return attackers_to(board, sq, by) != 0;
 }
 
+int piece_at(const struct Board *board, int sq) {
+    uint64_t mask = 1ULL << sq;
+    for (int piece = 0; piece < 12; ++piece)
+        if (board->pieces[piece] & mask) return piece;
+    return -1;
+}
+
+void rebuild_occ(struct Board *board) {
+    uint64_t white=0;
+    uint64_t black=0;
+
+    for (int p = P; p <= K; ++p) white |= board->pieces[p];
+    for (int p = p; p <= k; ++p) black |= board->pieces[p];
+
+    board->occ[WHITE] = white;
+    board->occ[BLACK] = black;
+    board->occ[BOTH]  = white | black;
+}
+
+uint8_t castlerights_without(uint8_t castlerights, uint8_t mask) {
+    // Update castle rights by removing mask.
+    return castlerights & ~mask;
+}
+
+uint8_t update_castlerights_after_move(
+    uint8_t cr, int moved_pid, int from, int to, int cap_pid
+) {
+    // King moved: lose both
+    if (moved_pid == K) cr &= ~(CASTLE_WK | CASTLE_WQ);
+    if (moved_pid == k) cr &= ~(CASTLE_BK | CASTLE_BQ);
+
+    // Rook moved from its home square
+    if (moved_pid == R) {
+        if (from == H1) cr &= ~CASTLE_WK;
+        if (from == A1) cr &= ~CASTLE_WQ;
+    } else if (moved_pid == r) {
+        if (from == H8) cr &= ~CASTLE_BK;
+        if (from == A8) cr &= ~CASTLE_BQ;
+    }
+
+    // Captured a rook on its home square.
+    // Obviously if a rook has moved and is captured,
+    // the prior check accounts for that.
+    if (cap_pid == R) {
+        if (to == H1) cr &= ~CASTLE_WK;
+        if (to == A1) cr &= ~CASTLE_WQ;
+    } else if (cap_pid == r) {
+        if (to == H8) cr &= ~CASTLE_BK;
+        if (to == A8) cr &= ~CASTLE_BQ;
+    }
+    return cr;
+}
+
+void put_piece(struct Board *board, int pid, int sq) {
+    board->pieces[pid] |= 1ULL << sq;
+}
+
+void del_piece(struct Board *board, int pid, int sq) {
+    board->pieces[pid] &= ~(1ULL << sq);
+}
+
+// Create a copy of the board to simulate move and test state.
+bool apply_move_on_copy(struct Board *in, struct Board *out, struct Move m) {
+    *out = *in;
+    const enum Color us = in->side_to_move;
+    const enum Color opp = us ^ 1;
+
+    // Reset enpassant.
+    out->ep_square = -1;
+
+    // Handle capture / EP capture
+    int captured_pid = -1;
+    if (m.flags & MF_ENPASSANT) {
+        int cap_sq = (us == WHITE) ? (m.to - 8) : (m.to + 8);
+        captured_pid = piece_at(out, cap_sq);
+        if (captured_pid < 0) return false;
+        del_piece(out, captured_pid, cap_sq);
+    } else if (m.flags & MF_CAPTURE) {
+        captured_pid = piece_at(out, m.to);
+        if (captured_pid < 0) {      
+            return false;
+        };
+        del_piece(out, captured_pid, m.to);
+    }
+
+    // Move (with promotion)
+    del_piece(out, m.piece, m.from);
+    // move.promo is the promotion piece.
+    int placed = (m.flags & MF_PROMO) ? m.promo : m.piece;
+    put_piece(out, placed, m.to);
+
+    // Castling: move rook
+    if (m.flags & MF_CASTLE) {
+        if (us == WHITE) {
+            if (m.to == WK_TO) { 
+                del_piece(out, R, H1);
+                put_piece(out, R, F1);
+            }
+            else {
+                del_piece(out, R, A1);
+                put_piece(out, R, D1);
+            }
+        } else {
+            if (m.to == BK_TO) {
+                del_piece(out, r, H8);
+                put_piece(out, r, F8);
+            }
+            else {
+                del_piece(out, r, A8);
+                put_piece(out, r, D8);
+            }
+        }
+    }
+
+    // Double pawn push -> set EP square
+    if (m.flags & MF_DOUBLE_PUSH) out->ep_square = (us == WHITE) ? (m.to - 8) : (m.to + 8);
+
+    // Update castling rights
+    out->castling_rights = update_castlerights_after_move(
+        in->castling_rights, m.piece, m.from, m.to, captured_pid
+    );
+
+    // Side to move flips
+    out->side_to_move = opp;
+
+    rebuild_occ(out);
+    return true;
+}
+
+bool castle_path_safe(const struct Board *board, enum Color side, int king_to) {
+    enum Color opp = side ^ 1;
+    if (side == WHITE) {
+        if (king_to == WK_TO) {
+            // E1-F1-G1
+            if (square_attacked(board, E1, opp)) return false;
+            if (square_attacked(board, F1, opp)) return false;
+        } else {
+            // E1-D1-C1
+            if (square_attacked(board, E1, opp)) return false;
+            if (square_attacked(board, D1, opp)) return false;
+        }
+    } else {
+        if (king_to == BK_TO) {
+            // E8-F8-G8
+            if (square_attacked(board, E8, opp)) return false;
+            if (square_attacked(board, F8, opp)) return false;
+        } else {
+            // E8-D8-C8
+            if (square_attacked(board, E8, opp)) return false;
+            if (square_attacked(board, D8, opp)) return false;
+        }
+    }
+    return true;
+}
+
+bool move_is_legal(struct Board *board, struct Move move) {
+    enum Color us  = board->side_to_move;
+    enum Color opp = us ^ 1;
+
+    // Castle-through-check rule
+    if (move.flags & MF_CASTLE) {
+        if (!castle_path_safe(board, us, move.to)) {
+            return false;
+        }
+    }
+
+    struct Board after;
+    if (!apply_move_on_copy(board, &after, move)) {
+        return false;
+    }
+
+
+    // Our king must not be in check after the move
+    uint64_t king_bb = (us == WHITE) ? after.pieces[K] : after.pieces[k];
+
+    if (!king_bb) return false;
+
+    int king_sq = first_set_index(king_bb);
+    return !square_attacked(&after, king_sq, opp);
+}
+
+int get_legal_moves(struct Board *board, struct Move *out) {
+    struct Move tmp[256];
+    int n = gen_pseudo_moves(board, tmp, false);
+    
+    int count = 0;
+    for (int i = 0; i < n; ++i)
+        if (move_is_legal(board, tmp[i]))
+            out[count++] = tmp[i];
+    return count;
+}
+
 void print_board(const struct Board *board) {
     const char PIECE_CH[12] = {
         'P','N','B','R','Q','K',

test/chess_ffi.py

@@ -91,10 +91,12 @@ gen_king_moves    = _bind_opt("gen_king_moves",    *PIECE_SIG)
 ATTACKED_SIG = (C.POINTER(Board), C.c_int, C.c_int)
 INCHECK_ARGS = (C.POINTER(Board), C.c_int)
 ATTACKERS_TO = (C.POINTER(Board), C.c_int, C.c_int)
+GEN_LEGAL_MOVES = (C.POINTER(Board), C.POINTER(Move))
 
 square_attacked = _bind_opt("square_attacked", ATTACKED_SIG, C.c_bool)
 in_check = _bind_opt("in_check", INCHECK_ARGS, C.c_bool)
 attackers_to = _bind_opt("attackers_to", ATTACKERS_TO, C.c_uint64)
+get_legal_moves = _bind_opt("get_legal_moves", GEN_LEGAL_MOVES, C.c_int)
 
 
 # Attack cache tables.
@@ -126,6 +128,10 @@ def gen_moves(board, captures_only=False, cap=256):
     return buf, n
 
 
+def gen_legal_moves(board, out):
+    return int(get_legal_moves(C.byref(board), out))
+
+
 def is_square_attacked(board, sq, by):
     return bool(square_attacked(C.byref(board), int(sq), int(by)))
 

test/test_legal_move_gen.py

@@ -0,0 +1,110 @@
+from test.base import ChessLibTestBase
+from test.chess_ffi import Move
+from test.chess_ffi import Board
+from test.chess_ffi import BLACK
+from test.chess_ffi import is_in_check
+from test.chess_ffi import gen_legal_moves
+from test.chess_ffi import sq
+
+MAX_MOVES = 256
+
+
+class TestLegalMoveGen(ChessLibTestBase):
+    def _gen_legal(self, board):
+        """Support either return-count or out-parameter signatures."""
+        moves = (Move * MAX_MOVES)()
+        n = gen_legal_moves(board, moves)
+        return n, moves
+
+
+    def test_start_position(self):
+        # 20 legal moves from the initial chess position
+        # https://www.chessprogramming.org/Perft_Results#Initial_Position
+        fen = "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1"
+        b = Board()
+        self.load_fen(fen, board=b)
+
+        n, _ = self._gen_legal(b)
+        self.assertEqual(n, 20, "Start position must have 20 legal moves for White")
+
+
+    def test_kiwipete_depth1_count(self):
+        # Kiwipete: perft(1) = 48
+        # https://www.chessprogramming.org/Perft_Results#Position_2
+        fen = "r3k2r/p1ppqpb1/bn2pnp1/3PN3/1p2P3/2N2Q1p/PPPBBPPP/R3K2R w KQkq - 0 1"
+        b = Board(); self.load_fen(fen, board=b)
+
+        n, moves = self._gen_legal(b)
+        self.assertEqual(n, 48, "Kiwipete perft(1) should be 48")
+
+
+    def test_perft_position_3(self):
+        # https://www.chessprogramming.org/Perft_Results#Position_3
+        fen = "8/2p5/3p4/KP5r/1R3p1k/8/4P1P1/8 w - - 0 1"
+        b = Board(); self.load_fen(fen, board=b)
+
+        n, moves = self._gen_legal(b)
+        self.assertEqual(n, 14)
+
+
+    def test_perft_position_4(self):
+        # https://www.chessprogramming.org/Perft_Results#Position_4
+        fen = "r3k2r/Pppp1ppp/1b3nbN/nP6/BBP1P3/q4N2/Pp1P2PP/R2Q1RK1 w kq - 0 1"
+        b = Board(); self.load_fen(fen, board=b)
+
+        n, moves = self._gen_legal(b)
+        self.assertEqual(n, 6)
+
+
+    def test_perft_position_5(self):
+        # https://www.chessprogramming.org/Perft_Results#Position_5
+        fen = "rnbq1k1r/pp1Pbppp/2p5/8/2B5/8/PPP1NnPP/RNBQK2R w KQ - 1 8"
+        b = Board(); self.load_fen(fen, board=b)
+
+        n, moves = self._gen_legal(b)
+        self.assertEqual(n, 44)
+
+    
+    def test_perft_position_6(self):
+        # https://www.chessprogramming.org/Perft_Results#Position_6
+        fen = "r4rk1/1pp1qppp/p1np1n2/2b1p1B1/2B1P1b1/P1NP1N2/1PP1QPPP/R4RK1 w - - 0 10"
+        b = Board(); self.load_fen(fen, board=b)
+
+        n, moves = self._gen_legal(b)
+        self.assertEqual(n, 46)
+
+
+    def test_stalemate_black_to_move(self):
+        # Classic stalemate: Black to move, no legal moves, not in check
+        fen = "7k/5Q2/6K1/8/8/8/8/8 b - - 0 1"
+        b = Board()
+        self.load_fen(fen, board=b)
+
+        moves = (Move * MAX_MOVES)()
+        n = gen_legal_moves(b, moves)
+
+        self.assertEqual(n, 0, "Stalemate should have 0 legal moves")
+        self.assertFalse(is_in_check(b, BLACK), "Side to move must not be in check in stalemate")
+    
+
+    def test_simple_checkmate(self):
+        # Black to move; mated (Qg7# with Kg6 support)
+        fen = "7k/6Q1/6K1/8/8/8/8/8 b - - 0 1"
+        b = Board(); self.load_fen(fen, board=b)
+        moves = (Move * MAX_MOVES)()
+        n = gen_legal_moves(b, moves)
+
+        self.assertEqual(n, 0, "Checkmated side should have 0 legal moves")
+        self.assertTrue(is_in_check(b, BLACK), "Mated side must be in check")
+
+
+    def test_pinned_piece_cannot_move(self):
+            # White knight e2 pinned by rook e8 vs king e1
+            fen = "4r3/8/8/8/8/8/4N3/4K3 w - - 0 1"
+            b = Board(); self.load_fen(fen, board=b)
+            moves = (Move * MAX_MOVES)()
+            n = gen_legal_moves(b, moves)
+
+            for move in moves:
+                # Pinned knight cannot move from it's square.
+                self.assertFalse(getattr(move, "from") == sq("e2"))

test/test_movegen.py

@@ -253,7 +253,7 @@ class TestPseudoMoveGeneration(ChessLibTestBase):
 
     def test_quiet_pawn_promotions_white(self):
         cases = [
-            ("8/PPPPPPPP/8/8/8/8/8/8 w - - 0 1", 8, "all open on 7th rank"),
+            ("8/PPPPPPPP/8/8/8/8/8/8 w - - 0 1", 32, "all open on 7th rank"),
             ("8/8/7P/8/8/8/8/8 w - - 0 1", 0, "no promotions"),
             ("7n/7P/8/8/8/8/8/8 w - - 0 1", 0, "blocked by enemy"),
             ("7N/7P/8/8/8/8/8/8 w - - 0 1", 0, "blocked by friendly"),
@@ -263,8 +263,8 @@ class TestPseudoMoveGeneration(ChessLibTestBase):
 
     def test_capture_pawn_promotions_white(self):
         cases = [
-            ("6n1/7P/8/8/8/8/8/8 w - - 0 1", 1, "one capture"),
+            ("6n1/7P/8/8/8/8/8/8 w - - 0 1", 4, "one capture"),
-            ("5n1n/6P1/8/8/8/8/8/8 w - - 0 1", 2, "two captures"),
+            ("5n1n/6P1/8/8/8/8/8/8 w - - 0 1", 8, "two captures"),
             ("8/7P/8/8/8/8/8/8 w - - 0 1", 0, "no capture"),
         ]
         self.run_subtests(cases, gen_white_pawn_capture_promotions)