Unify PseudoAttacks arrays

No functional change.

Signed-off-by: Marco Costalba <mcostalba@gmail.com>

src/bitboard.cpp

@@ -49,9 +49,7 @@ Bitboard SquaresInFrontMask[2][64];
 Bitboard PassedPawnMask[2][64];
 Bitboard AttackSpanMask[2][64];
 
-Bitboard BishopPseudoAttacks[64];
+Bitboard PseudoAttacks[6][64];
-Bitboard RookPseudoAttacks[64];
-Bitboard QueenPseudoAttacks[64];
 
 uint8_t BitCount8Bit[256];
 int SquareDistance[64][64];
@@ -227,14 +225,14 @@ void bitboards_init() {
 
   for (Square s = SQ_A1; s <= SQ_H8; s++)
   {
-      BishopPseudoAttacks[s] = bishop_attacks_bb(s, 0);
+      PseudoAttacks[BISHOP][s] = bishop_attacks_bb(s, 0);
-      RookPseudoAttacks[s]   = rook_attacks_bb(s, 0);
+      PseudoAttacks[ROOK][s]   = rook_attacks_bb(s, 0);
-      QueenPseudoAttacks[s]  = queen_attacks_bb(s, 0);
+      PseudoAttacks[QUEEN][s]  = queen_attacks_bb(s, 0);
   }
 
   for (Square s1 = SQ_A1; s1 <= SQ_H8; s1++)
       for (Square s2 = SQ_A1; s2 <= SQ_H8; s2++)
-          if (bit_is_set(QueenPseudoAttacks[s1], s2))
+          if (bit_is_set(PseudoAttacks[QUEEN][s1], s2))
           {
               Square delta = (s2 - s1) / square_distance(s1, s2);
 

src/bitboard.h

@@ -49,9 +49,7 @@ extern int BShifts[64];
 extern Bitboard BMasks[64];
 extern Bitboard* BAttacks[64];
 
-extern Bitboard BishopPseudoAttacks[64];
+extern Bitboard PseudoAttacks[6][64];
-extern Bitboard RookPseudoAttacks[64];
-extern Bitboard QueenPseudoAttacks[64];
 
 extern uint8_t BitCount8Bit[256];
 

src/evaluate.cpp

@@ -714,7 +714,7 @@ namespace {
         b = undefended & ei.attackedBy[Them][ROOK] & ~pos.pieces(Them);
 
         // Consider only squares where the enemy rook gives check
-        b &= RookPseudoAttacks[ksq];
+        b &= PseudoAttacks[ROOK][ksq];
 
         if (b)
         {

src/movegen.cpp

@@ -262,9 +262,8 @@ namespace {
 
     do
     {
-        if (   (Pt == QUEEN  && !(QueenPseudoAttacks[from]  & checkSqs))
+        if (    (Pt == BISHOP || Pt == ROOK || Pt == QUEEN)
-            || (Pt == ROOK   && !(RookPseudoAttacks[from]   & checkSqs))
+            && !(PseudoAttacks[Pt][from] & checkSqs))
-            || (Pt == BISHOP && !(BishopPseudoAttacks[from] & checkSqs)))
             continue;
 
         if (ci.dcCandidates && bit_is_set(ci.dcCandidates, from))
@@ -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,14 +431,13 @@ 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
   {
@@ -450,19 +448,20 @@ MoveStack* generate<MV_EVASION>(const Position& pos, MoveStack* mlist) {
 
       switch (type_of(pos.piece_on(checksq)))
       {
-      case BISHOP: sliderAttacks |= BishopPseudoAttacks[checksq]; break;
+      case BISHOP: sliderAttacks |= PseudoAttacks[BISHOP][checksq]; break;
-      case ROOK:   sliderAttacks |= RookPseudoAttacks[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
+          // If queen and king are far or not on a diagonal line we can safely
-          // in the other direction becuase are not reachable by the king anyway.
+          // remove all the squares attacked in the other direction becuase are
-          if (squares_between(ksq, checksq) || (RookPseudoAttacks[checksq] & (1ULL << ksq)))
+          // not reachable by the king anyway.
-              sliderAttacks |= QueenPseudoAttacks[checksq];
+          if (squares_between(ksq, checksq) || !bit_is_set(PseudoAttacks[BISHOP][checksq], ksq))
+              sliderAttacks |= PseudoAttacks[QUEEN][checksq];
 
-          // Otherwise, if king and queen are adjacent and on a diagonal line, we need to
+          // Otherwise we need to use real rook attacks to check if king is safe
-          // use real rook attacks to check if king is safe to move in the other direction.
+          // to move in the other direction. For example: king in B2, queen in A1
-          // For example: king in B2, queen in A1 a knight in B1, and we can safely move to C1.
+          // 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);

src/position.cpp

@@ -361,8 +361,8 @@ Bitboard Position::hidden_checkers() const {
   Square ksq = king_square(FindPinned ? sideToMove : flip(sideToMove));
 
   // Pinners are sliders, that give check when candidate pinned is removed
-  pinners &=  (pieces(ROOK, QUEEN) & RookPseudoAttacks[ksq])
+  pinners &=  (pieces(ROOK, QUEEN) & PseudoAttacks[ROOK][ksq])
-            | (pieces(BISHOP, QUEEN) & BishopPseudoAttacks[ksq]);
+            | (pieces(BISHOP, QUEEN) & PseudoAttacks[BISHOP][ksq]);
 
   while (pinners)
   {