Micro-optimize do_castle_move()

[stockfish] / src / position.cpp

diff --git a/src/position.cpp b/src/position.cpp
index 318f0f2c51ad94fb98c9648aa269f4fd19d4319f..9af42558867b52aeec7c5e525dbb8c21ed2407ee 100644 (file)
--- a/src/position.cpp
+++ b/src/position.cpp
@@ -239,24 +239,24 @@ void Position::from_fen(const string& fenStr, bool isChess960, Thread* th) {
 void Position::set_castle_right(Color c, Square rfrom) {
 
   Square kfrom = king_square(c);
-  bool kingSide = kfrom < rfrom;
-  int cr = (kingSide ? WHITE_OO : WHITE_OOO) << c;
+  CastlingSide cs = kfrom < rfrom ? KING_SIDE : QUEEN_SIDE;
+  CastleRight cr = make_castle_right(c, cs);
 
   st->castleRights |= cr;
   castleRightsMask[kfrom] |= cr;
   castleRightsMask[rfrom] |= cr;
-  castleRookSquare[cr] = rfrom;
+  castleRookSquare[c][cs] = rfrom;
 
-  Square kto = relative_square(c, kingSide ? SQ_G1 : SQ_C1);
-  Square rto = relative_square(c, kingSide ? SQ_F1 : SQ_D1);
+  Square kto = relative_square(c, cs == KING_SIDE ? SQ_G1 : SQ_C1);
+  Square rto = relative_square(c, cs == KING_SIDE ? SQ_F1 : SQ_D1);
 
   for (Square s = std::min(rfrom, rto); s <= std::max(rfrom, rto); s++)
       if (s != kfrom && s != rfrom)
-          castlePath[cr] |= s;
+          castlePath[c][cs] |= s;
 
   for (Square s = std::min(kfrom, kto); s <= std::max(kfrom, kto); s++)
       if (s != kfrom && s != rfrom)
-          castlePath[cr] |= s;
+          castlePath[c][cs] |= s;
 }
 
 
@@ -300,16 +300,16 @@ const string Position::to_fen() const {
   fen << (sideToMove == WHITE ? " w " : " b ");
 
   if (can_castle(WHITE_OO))
-      fen << (chess960 ? char(toupper(file_to_char(file_of(castle_rook_square(WHITE_OO))))) : 'K');
+      fen << (chess960 ? char(toupper(file_to_char(file_of(castle_rook_square(WHITE, KING_SIDE))))) : 'K');
 
   if (can_castle(WHITE_OOO))
-      fen << (chess960 ? char(toupper(file_to_char(file_of(castle_rook_square(WHITE_OOO))))) : 'Q');
+      fen << (chess960 ? char(toupper(file_to_char(file_of(castle_rook_square(WHITE, QUEEN_SIDE))))) : 'Q');
 
   if (can_castle(BLACK_OO))
-      fen << (chess960 ? file_to_char(file_of(castle_rook_square(BLACK_OO))) : 'k');
+      fen << (chess960 ? file_to_char(file_of(castle_rook_square(BLACK, KING_SIDE))) : 'k');
 
   if (can_castle(BLACK_OOO))
-      fen << (chess960 ? file_to_char(file_of(castle_rook_square(BLACK_OOO))) : 'q');
+      fen << (chess960 ? file_to_char(file_of(castle_rook_square(BLACK, QUEEN_SIDE))) : 'q');
 
   if (st->castleRights == CASTLES_NONE)
       fen << '-';
@@ -830,7 +830,7 @@ void Position::do_move(Move m, StateInfo& newSt, const CheckInfo& ci, bool moveI
   prefetch((char*)TT.first_entry(k));
 
   // Move the piece
-  Bitboard from_to_bb = SquareBB[from] | SquareBB[to];
+  Bitboard from_to_bb = SquareBB[from] ^ SquareBB[to];
   byTypeBB[ALL_PIECES] ^= from_to_bb;
   byTypeBB[pt] ^= from_to_bb;
   byColorBB[us] ^= from_to_bb;
@@ -995,7 +995,7 @@ void Position::undo_move(Move m) {
   }
 
   // Put the piece back at the source square
-  Bitboard from_to_bb = SquareBB[from] | SquareBB[to];
+  Bitboard from_to_bb = SquareBB[from] ^ SquareBB[to];
   byTypeBB[ALL_PIECES] ^= from_to_bb;
   byTypeBB[pt] ^= from_to_bb;
   byColorBB[us] ^= from_to_bb;
@@ -1078,21 +1078,13 @@ void Position::do_castle_move(Move m) {
   assert(piece_on(kfrom) == make_piece(us, KING));
   assert(piece_on(rfrom) == make_piece(us, ROOK));
 
-  // Remove pieces from source squares
-  byTypeBB[ALL_PIECES] ^= kfrom;
-  byTypeBB[KING] ^= kfrom;
-  byColorBB[us] ^= kfrom;
-  byTypeBB[ALL_PIECES] ^= rfrom;
-  byTypeBB[ROOK] ^= rfrom;
-  byColorBB[us] ^= rfrom;
-
-  // Put pieces on destination squares
-  byTypeBB[ALL_PIECES] |= kto;
-  byTypeBB[KING] |= kto;
-  byColorBB[us] |= kto;
-  byTypeBB[ALL_PIECES] |= rto;
-  byTypeBB[ROOK] |= rto;
-  byColorBB[us] |= rto;
+  // Move the pieces, with some care; in chess960 could be kto == rfrom
+  Bitboard k_from_to_bb = SquareBB[kfrom] ^ SquareBB[kto];
+  Bitboard r_from_to_bb = SquareBB[rfrom] ^ SquareBB[rto];
+  byTypeBB[KING] ^= k_from_to_bb;
+  byTypeBB[ROOK] ^= r_from_to_bb;
+  byTypeBB[ALL_PIECES] ^= k_from_to_bb ^ r_from_to_bb;
+  byColorBB[us] ^= k_from_to_bb ^ r_from_to_bb;
 
   // Update board
   Piece king = make_piece(us, KING);
@@ -1554,13 +1546,13 @@ void Position::flip() {
           put_piece(Piece(pos.piece_on(s) ^ 8), ~s);
 
   if (pos.can_castle(WHITE_OO))
-      set_castle_right(BLACK, ~pos.castle_rook_square(WHITE_OO));
+      set_castle_right(BLACK, ~pos.castle_rook_square(WHITE, KING_SIDE));
   if (pos.can_castle(WHITE_OOO))
-      set_castle_right(BLACK, ~pos.castle_rook_square(WHITE_OOO));
+      set_castle_right(BLACK, ~pos.castle_rook_square(WHITE, QUEEN_SIDE));
   if (pos.can_castle(BLACK_OO))
-      set_castle_right(WHITE, ~pos.castle_rook_square(BLACK_OO));
+      set_castle_right(WHITE, ~pos.castle_rook_square(BLACK, KING_SIDE));
   if (pos.can_castle(BLACK_OOO))
-      set_castle_right(WHITE, ~pos.castle_rook_square(BLACK_OOO));
+      set_castle_right(WHITE, ~pos.castle_rook_square(BLACK, QUEEN_SIDE));
 
   if (pos.st->epSquare != SQ_NONE)
       st->epSquare = ~pos.st->epSquare;
@@ -1726,17 +1718,16 @@ bool Position::pos_is_ok(int* failedStep) const {
 
   if (failedStep) (*failedStep)++;
   if (debugCastleSquares)
-      for (CastleRight f = WHITE_OO; f <= BLACK_OOO; f = CastleRight(f << 1))
-      {
-          if (!can_castle(f))
-              continue;
-
-          Piece rook = (f & (WHITE_OO | WHITE_OOO) ? W_ROOK : B_ROOK);
+      for (Color c = WHITE; c <= BLACK; c++)
+          for (CastlingSide s = KING_SIDE; s <= QUEEN_SIDE; s = CastlingSide(s + 1))
+          {
+              if (!can_castle(make_castle_right(c, s)))
+                  continue;
 
-          if (   piece_on(castleRookSquare[f]) != rook
-              || castleRightsMask[castleRookSquare[f]] != f)
-              return false;
-      }
+              if (   piece_on(castleRookSquare[c][s]) != make_piece(c, ROOK)
+                  || castleRightsMask[castleRookSquare[c][s]] != make_castle_right(c, s))
+                  return false;
+          }
 
   if (failedStep) *failedStep = 0;
   return true;