bugfix on en passant rule

Hardcode3 · Hardcode3 · commit 03030d3ff23f · 2026-01-01T23:08:54.000+01:00
diff --git a/include/bitbishop/movegen/pawn_moves.hpp b/include/bitbishop/movegen/pawn_moves.hpp
@@ -1,8 +1,8 @@
 #pragma once
 
+#include <bitbishop/attacks/generate_attacks.hpp>
 #include <bitbishop/board.hpp>
 #include <bitbishop/color.hpp>
-#include <bitbishop/lookups/attackers.hpp>
 #include <bitbishop/lookups/pawn_attacks.hpp>
 #include <bitbishop/move.hpp>
 #include <bitbishop/movegen/pins.hpp>
@@ -102,6 +102,19 @@ void add_pawn_promotions(std::vector<Move>& moves, Square from, Square to, Color
   }
 }
 
+/**
+ * @brief Generates all single-square pawn pushes from the given square.
+ *
+ * Applies occupancy, check mask, and pin mask filters. If the target square
+ * is a promotion rank, all promotion moves are added.
+ *
+ * @param moves Vector to append generated moves to
+ * @param from Source square of the pawn
+ * @param us Color of the pawn
+ * @param occupied Bitboard of all occupied squares
+ * @param check_mask Bitboard mask to restrict moves under check
+ * @param pin_mask Bitboard mask to restrict moves due to pins
+ */
 inline void generate_single_push(std::vector<Move>& moves, Square from, Color us, const Bitboard& occupied,
                                  const Bitboard& check_mask, const Bitboard& pin_mask) {
   const auto& single_push = Lookups::PAWN_SINGLE_PUSH[ColorUtil::to_index(us)];
@@ -121,6 +134,53 @@ inline void generate_single_push(std::vector<Move>& moves, Square from, Color us
   }
 }
 
+/**
+ * @brief Generates all double-square pawn pushes from the given square.
+ *
+ * Only allowed from the starting rank. Ensures the intermediate square is empty
+ * and respects occupancy, check mask, and pin mask constraints.
+ *
+ * @param moves Vector to append generated moves to
+ * @param from Source square of the pawn
+ * @param us Color of the pawn
+ * @param occupied Bitboard of all occupied squares
+ * @param check_mask Bitboard mask to restrict moves under check
+ * @param pin_mask Bitboard mask to restrict moves due to pins
+ */
+inline void generate_double_push(std::vector<Move>& moves, Square from, Color us, const Bitboard& occupied,
+                                 const Bitboard& check_mask, const Bitboard& pin_mask) {
+  const auto& single_push = Lookups::PAWN_SINGLE_PUSH[ColorUtil::to_index(us)];
+  const auto& double_push = Lookups::PAWN_DOUBLE_PUSH[ColorUtil::to_index(us)];
+
+  if (!is_starting_rank(from, us)) {
+    return;
+  }
+
+  Bitboard bb = double_push[from.flat_index()];
+  bb &= ~occupied;
+  bb &= check_mask;
+  bb &= pin_mask;
+
+  Bitboard single_bb = single_push[from.flat_index()] & occupied;
+  if (single_bb.empty() && bb) {
+    Square to = bb.pop_lsb().value();
+    moves.emplace_back(from, to, std::nullopt, false, false, false);
+  }
+}
+
+/**
+ * @brief Generates all pawn capture moves from the given square.
+ *
+ * Only captures squares occupied by enemy pieces. Applies check mask and pin mask.
+ * Automatically adds promotion moves if the destination is on the promotion rank.
+ *
+ * @param moves Vector to append generated moves to
+ * @param from Source square of the pawn
+ * @param us Color of the pawn
+ * @param enemy Bitboard of enemy pieces
+ * @param check_mask Bitboard mask to restrict moves under check
+ * @param pin_mask Bitboard mask to restrict moves due to pins
+ */
 inline void generate_captures(std::vector<Move>& moves, Square from, Color us, const Bitboard& enemy,
                               const Bitboard& check_mask, const Bitboard& pin_mask) {
   const auto& captures = Lookups::PAWN_ATTACKS[ColorUtil::to_index(us)];
@@ -139,6 +199,20 @@ inline void generate_captures(std::vector<Move>& moves, Square from, Color us, c
   }
 }
 
+/**
+ * @brief Generates a pawn en passant move from the given square, if legal.
+ *
+ * Verifies en passant square exists, the pawn can capture, and that
+ * performing the move does not leave the king in check.
+ *
+ * @param moves Vector to append generated moves to
+ * @param from Source square of the pawn
+ * @param us Color of the pawn
+ * @param board Current board position
+ * @param king_sq Square of the king for this side
+ * @param check_mask Bitboard mask to restrict moves under check
+ * @param pin_mask Bitboard mask to restrict moves due to pins
+ */
 inline void generate_en_passant(std::vector<Move>& moves, Square from, Color us, const Board& board, Square king_sq,
                                 const Bitboard& check_mask, const Bitboard& pin_mask) {
   const std::optional<Square> epsq_opt = board.en_passant_square();
@@ -147,6 +221,7 @@ inline void generate_en_passant(std::vector<Move>& moves, Square from, Color us,
     return;
   }
 
+  const Color them = ColorUtil::opposite(us);
   Square epsq = epsq_opt.value();
   auto bb = Bitboard(epsq);
   bb &= check_mask;
@@ -163,32 +238,27 @@ inline void generate_en_passant(std::vector<Move>& moves, Square from, Color us,
   tmp.remove_piece(cap_sq);
   tmp.move_piece(from, epsq);
 
-  if (!attackers_to(king_sq, us)) {
-    moves.emplace_back(from, epsq, std::nullopt, true, true, false);
-  }
-}
-
-inline void generate_double_push(std::vector<Move>& moves, Square from, Color us, const Bitboard& occupied,
-                                 const Bitboard& check_mask, const Bitboard& pin_mask) {
-  const auto& single_push = Lookups::PAWN_SINGLE_PUSH[ColorUtil::to_index(us)];
-  const auto& double_push = Lookups::PAWN_DOUBLE_PUSH[ColorUtil::to_index(us)];
+  Bitboard attackers = generate_attacks(tmp, them);
 
-  if (!is_starting_rank(from, us)) {
-    return;
-  }
-
-  Bitboard bb = double_push[from.flat_index()];
-  bb &= ~occupied;
-  bb &= check_mask;
-  bb &= pin_mask;
-
-  Bitboard single_bb = single_push[from.flat_index()] & occupied;
-  if (single_bb.empty() && bb) {
-    Square to = bb.pop_lsb().value();
-    moves.emplace_back(from, to, std::nullopt, false, false, false);
+  if (!attackers.test(king_sq)) {
+    moves.emplace_back(from, epsq, std::nullopt, true, true, false);
   }
 }
 
+/**
+ * @brief Generates all legal pawn moves for the given side.
+ *
+ * Includes single pushes, double pushes, captures, promotions, and en passant,
+ * taking into account occupancy, checks, and pins. Iterates over all pawns of
+ * the specified color.
+ *
+ * @param moves Vector to append generated moves to
+ * @param board Current board position
+ * @param us Color of the side to generate moves for
+ * @param king_sq Square of the king for this side
+ * @param check_mask Bitboard mask to restrict moves under check
+ * @param pins Pin result structure indicating which pieces are pinned
+ */
 void generate_pawn_legal_moves(std::vector<Move>& moves, const Board& board, Color us, Square king_sq,
                                const Bitboard& check_mask, const PinResult& pins) {
   const Bitboard enemy = board.enemy(us);
diff --git a/tests/bitbishop/movegen/test_pawn_moves/test_generate_pawn_legal_moves.cpp b/tests/bitbishop/movegen/test_pawn_moves/test_generate_pawn_legal_moves.cpp
@@ -549,3 +549,212 @@ TEST(GeneratePawnLegalMovesTest, NoDoublePushOffStartingRank) {
   EXPECT_TRUE(contains_move(moves, {E3, E4, std::nullopt, false, false, false}));
   EXPECT_FALSE(contains_move(moves, {E3, E5, std::nullopt, false, false, false}));
 }
+
+/**
+ * @test White en passant capture.
+ * @brief Confirms generate_pawn_legal_moves() generates en passant capture
+ *        for white pawn.
+ */
+TEST(GeneratePawnLegalMovesTest, WhiteEnPassantCapture) {
+  Board board("rnbqkbnr/pppp1ppp/8/3Pp3/8/8/PPP1PPPP/RNBQKBNR w KQkq e6 0 1");
+
+  std::vector<Move> moves;
+  Bitboard check_mask = Bitboard::Ones();
+  PinResult pins = compute_pins(E1, board, Color::WHITE);
+
+  generate_pawn_legal_moves(moves, board, Color::WHITE, E1, check_mask, pins);
+
+  // Should include en passant capture
+  EXPECT_TRUE(contains_move(moves, {D5, E6, std::nullopt, true, true, false}));
+}
+
+/**
+ * @test Black en passant capture.
+ * @brief Confirms generate_pawn_legal_moves() generates en passant capture
+ *        for black pawn.
+ */
+TEST(GeneratePawnLegalMovesTest, BlackEnPassantCapture) {
+  Board board("rnbqkbnr/ppp1pppp/8/8/3pP3/8/PPPP1PPP/RNBQKBNR b KQkq e3 0 1");
+
+  std::vector<Move> moves;
+  Bitboard check_mask = Bitboard::Ones();
+  PinResult pins = compute_pins(E8, board, Color::BLACK);
+
+  generate_pawn_legal_moves(moves, board, Color::BLACK, E8, check_mask, pins);
+
+  // Should include en passant capture
+  EXPECT_TRUE(contains_move(moves, {D4, E3, std::nullopt, true, true, false}));
+}
+
+/**
+ * @test En passant on both sides.
+ * @brief Confirms generate_pawn_legal_moves() generates en passant when
+ *        two pawns can capture same target.
+ */
+TEST(GeneratePawnLegalMovesTest, EnPassantBothSides) {
+  Board board("rnbqkbnr/ppp1pppp/8/2PpP3/8/8/PP1P1PPP/RNBQKBNR w KQkq d6 0 1");
+
+  std::vector<Move> moves;
+  Bitboard check_mask = Bitboard::Ones();
+  PinResult pins = compute_pins(E1, board, Color::WHITE);
+
+  generate_pawn_legal_moves(moves, board, Color::WHITE, E1, check_mask, pins);
+
+  // Both pawns can capture en passant
+  EXPECT_TRUE(contains_move(moves, {C5, D6, std::nullopt, true, true, false}));
+  EXPECT_TRUE(contains_move(moves, {E5, D6, std::nullopt, true, true, false}));
+}
+
+/**
+ * @test No en passant without target square.
+ * @brief Confirms generate_pawn_legal_moves() does not generate en passant
+ *        when no en passant square is set.
+ */
+TEST(GeneratePawnLegalMovesTest, NoEnPassantWithoutTarget) {
+  Board board = Board::Empty();
+  board.set_piece(E1, WHITE_KING);
+  board.set_piece(D5, WHITE_PAWN);
+  board.set_piece(E5, BLACK_PAWN);
+
+  std::vector<Move> moves;
+  Bitboard check_mask = Bitboard::Ones();
+  PinResult pins;
+
+  generate_pawn_legal_moves(moves, board, Color::WHITE, E1, check_mask, pins);
+
+  // No en passant without target square
+  EXPECT_FALSE(contains_move(moves, {D5, E6, std::nullopt, true, true, false}));
+}
+
+/**
+ * @test En passant blocked by check mask.
+ * @brief Confirms generate_pawn_legal_moves() does not generate en passant
+ *        when target square not in check mask.
+ */
+TEST(GeneratePawnLegalMovesTest, EnPassantBlockedByCheckMask) {
+  Board board("rnbqkbnr/pppp1ppp/8/3Pp3/8/8/PPP1PPPP/RNBQKBNR w KQkq e6 0 1");
+
+  Bitboard check_mask = Bitboard::Zeros();
+  check_mask.set(D6);  // En passant square E6 not in mask
+
+  std::vector<Move> moves;
+  PinResult pins = compute_pins(E1, board, Color::WHITE);
+
+  generate_pawn_legal_moves(moves, board, Color::WHITE, E1, check_mask, pins);
+
+  // En passant not allowed
+  EXPECT_FALSE(contains_move(moves, {D5, E6, std::nullopt, true, true, false}));
+}
+
+/**
+ * @test En passant blocked by pin.
+ * @brief Confirms generate_pawn_legal_moves() does not generate en passant
+ *        when pawn is pinned perpendicular to en passant direction.
+ */
+TEST(GeneratePawnLegalMovesTest, EnPassantBlockedByPin) {
+  Board board = Board::Empty();
+  board.set_piece(E1, WHITE_KING);
+  board.set_piece(E5, WHITE_PAWN);
+  board.set_piece(D5, BLACK_PAWN);
+  board.set_piece(E8, BLACK_ROOK);
+
+  // Manually set en passant square
+  Board board_with_ep("8/8/8/3pP3/8/8/8/4K2r b - e6 0 1");
+
+  std::vector<Move> moves;
+  Bitboard check_mask = Bitboard::Ones();
+  PinResult pins = compute_pins(E1, board_with_ep, Color::WHITE);
+
+  generate_pawn_legal_moves(moves, board_with_ep, Color::WHITE, E1, check_mask, pins);
+
+  // Pinned pawn cannot capture en passant
+  EXPECT_FALSE(contains_move(moves, {E5, D6, std::nullopt, true, true, false}));
+}
+
+/**
+ * @test En passant reveals check (horizontal pin).
+ * @brief Confirms generate_pawn_legal_moves() does not generate en passant
+ *        when capturing would expose king to horizontal attack.
+ */
+TEST(GeneratePawnLegalMovesTest, EnPassantRevealsHorizontalCheck) {
+  // White king on E5, white pawn on D5, black pawn on E5, black rook on A5
+  // If white captures en passant on E6, removes both pawns and exposes king
+  Board board("8/8/8/r2PpK2/8/8/8/8 w - e6 0 1");
+
+  std::vector<Move> moves;
+  Bitboard check_mask = Bitboard::Ones();
+  PinResult pins = compute_pins(F5, board, Color::WHITE);
+
+  generate_pawn_legal_moves(moves, board, Color::WHITE, F5, check_mask, pins);
+
+  // En passant not allowed as it would expose king
+  EXPECT_FALSE(contains_move(moves, {D5, E6, std::nullopt, true, true, false}));
+}
+
+/**
+ * @test En passant legal when safe.
+ * @brief Confirms generate_pawn_legal_moves() generates en passant when
+ *        it doesn't expose king to check.
+ */
+TEST(GeneratePawnLegalMovesTest, EnPassantLegalWhenSafe) {
+  Board board("rnbqkbnr/ppp2ppp/8/3Pp3/8/8/PPP1PPPP/RNBQKBNR w KQkq e6 0 1");
+
+  std::vector<Move> moves;
+  Bitboard check_mask = Bitboard::Ones();
+  PinResult pins = compute_pins(E1, board, Color::WHITE);
+
+  generate_pawn_legal_moves(moves, board, Color::WHITE, E1, check_mask, pins);
+
+  // En passant is safe
+  EXPECT_TRUE(contains_move(moves, {D5, E6, std::nullopt, true, true, false}));
+}
+
+/**
+ * @test En passant with promotion (edge case).
+ * @brief Confirms en passant is only available on correct ranks
+ *        (5th for white, 4th for black).
+ */
+TEST(GeneratePawnLegalMovesTest, EnPassantOnlyOnCorrectRank) {
+  // White pawn on 6th rank - cannot do en passant from here
+  Board board = Board::Empty();
+  board.set_piece(E1, WHITE_KING);
+  board.set_piece(D6, WHITE_PAWN);
+  board.set_piece(E6, BLACK_PAWN);
+
+  std::vector<Move> moves;
+  Bitboard check_mask = Bitboard::Ones();
+  PinResult pins;
+
+  generate_pawn_legal_moves(moves, board, Color::WHITE, E1, check_mask, pins);
+
+  // No en passant from 6th rank
+  EXPECT_FALSE(contains_move(moves, {D6, E7, std::nullopt, true, true, false}));
+}
+
+/**
+ * @test En passant move properties correct.
+ * @brief Confirms en passant move has correct flags set.
+ */
+TEST(GeneratePawnLegalMovesTest, EnPassantMoveProperties) {
+  Board board("rnbqkbnr/pppp1ppp/8/3Pp3/8/8/PPP1PPPP/RNBQKBNR w KQkq e6 0 1");
+
+  std::vector<Move> moves;
+  Bitboard check_mask = Bitboard::Ones();
+  PinResult pins = compute_pins(E1, board, Color::WHITE);
+
+  generate_pawn_legal_moves(moves, board, Color::WHITE, E1, check_mask, pins);
+
+  // Find en passant move
+  bool found = false;
+  for (const Move& move : moves) {
+    if (move.from == D5 && move.to == E6) {
+      EXPECT_TRUE(move.is_capture);
+      EXPECT_TRUE(move.is_en_passant);
+      EXPECT_FALSE(move.is_castling);
+      EXPECT_FALSE(move.promotion.has_value());
+      found = true;
+      break;
+    }
+  }
+  EXPECT_TRUE(found);
+}
