Fix missing pawn color check in move_is_legal()

[stockfish] / src / movegen.cpp

diff --git a/src/movegen.cpp b/src/movegen.cpp
index 258f9c710616a208339b055599f999c0817b382a..9a6b902bb3efc8b66d2b08a52f63bbad7419a0d5 100644 (file)
--- a/src/movegen.cpp
+++ b/src/movegen.cpp
@@ -64,6 +64,19 @@ namespace {
   template<Color, Color, Bitboard, Bitboard, SquareDelta>
   MoveStack* generate_pawn_checks(const Position&, Bitboard, Square, MoveStack*);
 
+  template<Color Us, SquareDelta Direction>
+  inline Bitboard move_pawns(Bitboard p) {
+
+    if (Direction == DELTA_N)
+        return Us == WHITE ? p << 8 : p >> 8;
+    else if (Direction == DELTA_NE)
+        return Us == WHITE ? p << 9 : p >> 7;
+    else if (Direction == DELTA_NW)
+        return Us == WHITE ? p << 7 : p >> 9;
+    else
+        return p;
+  }
+
   // Template generate_piece_checks() with specializations
   template<PieceType>
   MoveStack* generate_piece_checks(const Position&, MoveStack*, Color, Bitboard, Square);
@@ -163,10 +176,10 @@ int generate_noncaptures(const Position& pos, MoveStack* mlist) {
 }
 
 
-/// generate_checks() generates all pseudo-legal non-capturing, non-promoting
-/// checks. It returns the number of generated moves.
+/// generate_non_capture_checks() generates all pseudo-legal non-capturing,
+/// non-promoting checks. It returns the number of generated moves.
 
-int generate_checks(const Position& pos, MoveStack* mlist, Bitboard dc) {
+int generate_non_capture_checks(const Position& pos, MoveStack* mlist, Bitboard dc) {
 
   assert(pos.is_ok());
   assert(!pos.is_check());
@@ -483,6 +496,11 @@ bool move_is_legal(const Position& pos, const Move m, Bitboard pinned) {
   // Proceed according to the type of the moving piece.
   if (type_of_piece(pc) == PAWN)
   {
+      // Move direction must be compatible with pawn color
+      int direction = to - from;
+      if ((us == WHITE) != (direction > 0))
+          return false;
+
       // If the destination square is on the 8/1th rank, the move must
       // be a promotion.
       if (   (  (square_rank(to) == RANK_8 && us == WHITE)
@@ -492,7 +510,7 @@ bool move_is_legal(const Position& pos, const Move m, Bitboard pinned) {
 
       // Proceed according to the square delta between the source and
       // destionation squares.
-      switch (to - from)
+      switch (direction)
       {
       case DELTA_NW:
       case DELTA_NE:
@@ -601,7 +619,7 @@ namespace {
     Bitboard enemyPieces = pos.pieces_of_color(Them);
 
     // Captures in the a1-h8 (a8-h1 for black) direction
-    Bitboard b1 = (Us == WHITE ? pawns << 9 : pawns >> 7) & ~FileABB & enemyPieces;
+    Bitboard b1 = move_pawns<Us, DELTA_NE>(pawns) & ~FileABB & enemyPieces;
 
     // Capturing promotions
     Bitboard b2 = b1 & TRank8BB;
@@ -620,7 +638,7 @@ namespace {
     }
 
     // Captures in the h1-a8 (h8-a1 for black) direction
-    b1 = (Us == WHITE ? pawns << 7 : pawns >> 9) & ~FileHBB & enemyPieces;
+    b1 = move_pawns<Us, DELTA_NW>(pawns) & ~FileHBB & enemyPieces;
 
     // Capturing promotions
     b2 = b1 & TRank8BB;
@@ -639,7 +657,7 @@ namespace {
     }
 
     // Non-capturing promotions
-    b1 = (Us == WHITE ? pawns << 8 : pawns >> 8) & pos.empty_squares() & TRank8BB;
+    b1 = move_pawns<Us, DELTA_N>(pawns) & pos.empty_squares() & TRank8BB;
     while (b1)
     {
         to = pop_1st_bit(&b1);
@@ -676,7 +694,7 @@ namespace {
     Square to;
 
     // Underpromotion captures in the a1-h8 (a8-h1 for black) direction
-    b1 = (Us == WHITE ? pawns << 9 : pawns >> 7) & ~FileABB & enemyPieces & TRank8BB;
+    b1 = move_pawns<Us, DELTA_NE>(pawns) & ~FileABB & enemyPieces & TRank8BB;
     while (b1)
     {
         to = pop_1st_bit(&b1);
@@ -686,7 +704,7 @@ namespace {
     }
 
     // Underpromotion captures in the h1-a8 (h8-a1 for black) direction
-    b1 = (Us == WHITE ? pawns << 7 : pawns >> 9) & ~FileHBB & enemyPieces & TRank8BB;
+    b1 = move_pawns<Us, DELTA_NW>(pawns) & ~FileHBB & enemyPieces & TRank8BB;
     while (b1)
     {
         to = pop_1st_bit(&b1);
@@ -696,7 +714,7 @@ namespace {
     }
 
     // Single pawn pushes
-    b1 = (Us == WHITE ? pawns << 8 : pawns >> 8) & emptySquares;
+    b1 = move_pawns<Us, DELTA_N>(pawns) & emptySquares;
     b2 = b1 & TRank8BB;
     while (b2)
     {
@@ -713,7 +731,7 @@ namespace {
     }
 
     // Double pawn pushes
-    b2 = (Us == WHITE ? (b1 & TRank3BB) << 8 : (b1 & TRank3BB) >> 8) & emptySquares;
+    b2 = move_pawns<Us, DELTA_N>(b1 & TRank3BB) & emptySquares;
     while (b2)
     {
         to = pop_1st_bit(&b2);
@@ -738,7 +756,7 @@ namespace {
         b1 = pos.pawns(Us) & ~file_bb(ksq);
 
         // Discovered checks, single pawn pushes, no promotions
-        b2 = b3 = (Us == WHITE ? (b1 & dc) << 8 : (b1 & dc) >> 8) & empty & ~TRank8BB;
+        b2 = b3 = move_pawns<Us, DELTA_N>(b1 & dc) & empty & ~TRank8BB;
         while (b3)
         {
             Square to = pop_1st_bit(&b3);
@@ -746,7 +764,7 @@ namespace {
         }
 
         // Discovered checks, double pawn pushes
-        b3 = (Us == WHITE ? (b2 & TRank3BB) << 8 : (b2 & TRank3BB) >> 8) & empty;
+        b3 = move_pawns<Us, DELTA_N>(b2 & TRank3BB) & empty;
         while (b3)
         {
             Square to = pop_1st_bit(&b3);
@@ -759,7 +777,7 @@ namespace {
     b1 = pos.pawns(Us) & neighboring_files_bb(ksq) & ~dc;
 
     // Direct checks, single pawn pushes
-    b2 = (Us == WHITE ? b1 << 8 : b1 >> 8) & empty;
+    b2 = move_pawns<Us, DELTA_N>(b1) & empty;
     b3 = b2 & pos.pawn_attacks(Them, ksq);
     while (b3)
     {
@@ -768,9 +786,7 @@ namespace {
     }
 
     // Direct checks, double pawn pushes
-    b3 =  (Us == WHITE ? (b2 & TRank3BB) << 8 : (b2 & TRank3BB) >> 8)
-        & empty
-        & pos.pawn_attacks(Them, ksq);
+    b3 =  move_pawns<Us, DELTA_N>(b2 & TRank3BB) & empty & pos.pawn_attacks(Them, ksq);
     while (b3)
     {
         Square to = pop_1st_bit(&b3);
@@ -803,9 +819,17 @@ namespace {
         return mlist;
 
     Bitboard checkSqs = pos.piece_attacks<Piece>(ksq) & pos.empty_squares();
+    if (!checkSqs)
+        return mlist;
+
     while (b)
     {
         Square from = pop_1st_bit(&b);
+        if (   (Piece == QUEEN  && !(QueenPseudoAttacks[from]  & checkSqs))
+            || (Piece == ROOK   && !(RookPseudoAttacks[from]   & checkSqs))
+            || (Piece == BISHOP && !(BishopPseudoAttacks[from] & checkSqs)))
+            continue;
+
         Bitboard bb = pos.piece_attacks<Piece>(from) & checkSqs;
         SERIALIZE_MOVES(bb);
     }
@@ -817,12 +841,12 @@ namespace {
                                              Bitboard blockSquares, MoveStack* mlist) {
     Square to;
 
-    // Find non-pinned pawns
-    Bitboard b1 = pos.pawns(Us) & ~pinned;
+    // Find non-pinned pawns and push them one square
+    Bitboard b1 = move_pawns<Us, DELTA_N>(pos.pawns(Us) & ~pinned);
 
-    // Single pawn pushes. We don't have to AND with empty squares here,
+    // We don't have to AND with empty squares here,
     // because the blocking squares will always be empty.
-    Bitboard b2 = (Us == WHITE ? b1 << 8 : b1 >> 8) & blockSquares;
+    Bitboard b2 = b1 & blockSquares;
     while (b2)
     {
         to = pop_1st_bit(&b2);
@@ -840,8 +864,8 @@ namespace {
     }
 
     // Double pawn pushes
-    b2 = (Us == WHITE ? b1 << 8 : b1 >> 8) & pos.empty_squares() & TRank3BB;
-    b2 = (Us == WHITE ? b2 << 8 : b2 >> 8) & blockSquares;
+    b2 = b1 & pos.empty_squares() & TRank3BB;
+    b2 = move_pawns<Us, DELTA_N>(b2) & blockSquares;
     while (b2)
     {
         to = pop_1st_bit(&b2);