Enable easy move detection only for recaptures

[stockfish] / src / movegen.cpp

diff --git a/src/movegen.cpp b/src/movegen.cpp
index 865f9a8229ad947477324ddedb5eed3b6c3dd2df..0ec1fceabbf7a132fbd931d5e7481b37affc0c52 100644 (file)
--- a/src/movegen.cpp
+++ b/src/movegen.cpp
@@ -49,7 +49,7 @@ namespace {
     Square rfrom = pos.castle_rook_square(CR[us]);
     Square kto = relative_square(us, Side == KING_SIDE ? SQ_G1 : SQ_C1);
     Square rto = relative_square(us, Side == KING_SIDE ? SQ_F1 : SQ_D1);
-    Bitboard enemies = pos.pieces(flip(us));
+    Bitboard enemies = pos.pieces(~us);
 
     assert(!pos.in_check());
     assert(pos.piece_on(kfrom) == make_piece(us, KING));
@@ -262,9 +262,8 @@ namespace {
 
     do
     {
-        if (   (Pt == QUEEN  && !(QueenPseudoAttacks[from]  & checkSqs))
-            || (Pt == ROOK   && !(RookPseudoAttacks[from]   & checkSqs))
-            || (Pt == BISHOP && !(BishopPseudoAttacks[from] & checkSqs)))
+        if (    (Pt == BISHOP || Pt == ROOK || Pt == QUEEN)
+            && !(PseudoAttacks[Pt][from] & checkSqs))
             continue;
 
         if (ci.dcCandidates && bit_is_set(ci.dcCandidates, from))
@@ -347,13 +346,13 @@ MoveStack* generate(const Position& pos, MoveStack* mlist) {
   Bitboard target;
 
   if (Type == MV_CAPTURE)
-      target = pos.pieces(flip(us));
+      target = pos.pieces(~us);
 
   else if (Type == MV_NON_CAPTURE)
       target = pos.empty_squares();
 
   else if (Type == MV_NON_EVASION)
-      target = pos.pieces(flip(us)) | pos.empty_squares();
+      target = pos.pieces(~us) | pos.empty_squares();
 
   mlist = generate_piece_moves<PAWN, Type>(pos, mlist, us, target);
   mlist = generate_piece_moves<KNIGHT>(pos, mlist, us, target);
@@ -399,7 +398,7 @@ MoveStack* generate<MV_NON_CAPTURE_CHECK>(const Position& pos, MoveStack* mlist)
      Bitboard b = pos.attacks_from(Piece(pt), from) & pos.empty_squares();
 
      if (pt == KING)
-         b &= ~QueenPseudoAttacks[ci.ksq];
+         b &= ~PseudoAttacks[QUEEN][ci.ksq];
 
      SERIALIZE(b);
   }
@@ -432,37 +431,37 @@ MoveStack* generate<MV_EVASION>(const Position& pos, MoveStack* mlist) {
   int checkersCnt = 0;
   Color us = pos.side_to_move();
   Square ksq = pos.king_square(us);
-  Bitboard checkers = pos.checkers();
   Bitboard sliderAttacks = 0;
+  Bitboard checkers = pos.checkers();
 
-  assert(pos.piece_on(ksq) == make_piece(us, KING));
   assert(checkers);
 
   // Find squares attacked by slider checkers, we will remove them from the king
-  // evasions set so to skip known illegal moves and avoid to do legality check later.
+  // evasions so to skip known illegal moves avoiding useless legality check later.
   b = checkers;
   do
   {
       checkersCnt++;
       checksq = pop_1st_bit(&b);
 
-      assert(color_of(pos.piece_on(checksq)) == flip(us));
+      assert(color_of(pos.piece_on(checksq)) == ~us);
 
       switch (type_of(pos.piece_on(checksq)))
       {
-      case BISHOP: sliderAttacks |= BishopPseudoAttacks[checksq]; break;
-      case ROOK:   sliderAttacks |= RookPseudoAttacks[checksq];   break;
+      case BISHOP: sliderAttacks |= PseudoAttacks[BISHOP][checksq]; break;
+      case ROOK:   sliderAttacks |= PseudoAttacks[ROOK][checksq];   break;
       case QUEEN:
-          // If queen and king are far we can safely remove all the squares attacked
-          // in the other direction becuase are not reachable by the king anyway.
-          if (squares_between(ksq, checksq) || (RookPseudoAttacks[checksq] & (1ULL << ksq)))
-              sliderAttacks |= QueenPseudoAttacks[checksq];
-
-          // Otherwise, if king and queen are adjacent and on a diagonal line, we need to
-          // use real rook attacks to check if king is safe to move in the other direction.
-          // For example: king in B2, queen in A1 a knight in B1, and we can safely move to C1.
+          // If queen and king are far or not on a diagonal line we can safely
+          // remove all the squares attacked in the other direction becuase are
+          // not reachable by the king anyway.
+          if (squares_between(ksq, checksq) || !bit_is_set(PseudoAttacks[BISHOP][checksq], ksq))
+              sliderAttacks |= PseudoAttacks[QUEEN][checksq];
+
+          // Otherwise we need to use real rook attacks to check if king is safe
+          // to move in the other direction. For example: king in B2, queen in A1
+          // a knight in B1, and we can safely move to C1.
           else
-              sliderAttacks |= BishopPseudoAttacks[checksq] | pos.attacks_from<ROOK>(checksq);
+              sliderAttacks |= PseudoAttacks[BISHOP][checksq] | pos.attacks_from<ROOK>(checksq);
 
       default:
           break;
@@ -478,7 +477,7 @@ MoveStack* generate<MV_EVASION>(const Position& pos, MoveStack* mlist) {
   if (checkersCnt > 1)
       return mlist;
 
-  // Target for blocking evasions or captures of the checking piece
+  // Blocking evasions or captures of the checking piece
   target = squares_between(checksq, ksq) | checkers;
 
   mlist = generate_piece_moves<PAWN, MV_EVASION>(pos, mlist, us, target);