Revert to byTypeBB[0] storing occupied squares

[stockfish] / src / position.cpp

diff --git a/src/position.cpp b/src/position.cpp
index bf415b34d22ac48485e9b6cc24dd1d5928fb8fdc..12ef1a3092fc9befaa6baf6b889741f655c6bc0d 100644 (file)
--- a/src/position.cpp
+++ b/src/position.cpp
@@ -242,14 +242,27 @@ void Position::from_fen(const string& fenStr, bool isChess960) {
 /// Position::set_castle_right() is an helper function used to set castling
 /// rights given the corresponding color and the rook starting square.
 
-void Position::set_castle_right(Color c, Square rsq) {
+void Position::set_castle_right(Color c, Square rfrom) {
 
-  int f = (rsq < king_square(c) ? WHITE_OOO : WHITE_OO) << c;
+  Square kfrom = king_square(c);
+  bool kingSide = kfrom < rfrom;
+  int cr = (kingSide ? WHITE_OO : WHITE_OOO) << c;
 
-  st->castleRights |= f;
-  castleRightsMask[king_square(c)] |= f;
-  castleRightsMask[rsq] |= f;
-  castleRookSquare[f] = rsq;
+  st->castleRights |= cr;
+  castleRightsMask[kfrom] |= cr;
+  castleRightsMask[rfrom] |= cr;
+  castleRookSquare[cr] = rfrom;
+
+  Square kto = relative_square(c, kingSide ? SQ_G1 : SQ_C1);
+  Square rto = relative_square(c, kingSide ? 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;
+
+  for (Square s = std::min(kfrom, kto); s <= std::max(kfrom, kto); s++)
+      if (s != kfrom && s != rfrom)
+          castlePath[cr] |= s;
 }
 
 
@@ -364,10 +377,9 @@ Bitboard Position::hidden_checkers() const {
 
   while (pinners)
   {
-      b = squares_between(ksq, pop_1st_bit(&pinners)) & occupied_squares();
+      b = squares_between(ksq, pop_1st_bit(&pinners)) & pieces();
 
-      // Only one bit set and is an our piece?
-      if (b && !(b & (b - 1)) && (b & pieces(sideToMove)))
+      if (b && single_bit(b) && (b & pieces(sideToMove)))
           result |= b;
   }
   return result;
@@ -425,7 +437,7 @@ bool Position::move_attacks_square(Move m, Square s) const {
   assert(!square_is_empty(from));
 
   // Update occupancy as if the piece is moving
-  occ = occupied_squares() ^ from ^ to;
+  occ = pieces() ^ from ^ to;
 
   // The piece moved in 'to' attacks the square 's' ?
   if (attacks_from(piece, to, occ) & s)
@@ -462,7 +474,7 @@ bool Position::pl_move_is_legal(Move m, Bitboard pinned) const {
       Square to = to_sq(m);
       Square capsq = to + pawn_push(them);
       Square ksq = king_square(us);
-      Bitboard b = (occupied_squares() ^ from ^ capsq) | to;
+      Bitboard b = (pieces() ^ from ^ capsq) | to;
 
       assert(to == ep_square());
       assert(piece_moved(m) == make_piece(us, PAWN));
@@ -614,7 +626,7 @@ bool Position::is_pseudo_legal(const Move m) const {
       }
       // In case of king moves under check we have to remove king so to catch
       // as invalid moves like b1a1 when opposite queen is on c1.
-      else if (attackers_to(to, occupied_squares() ^ from) & pieces(~us))
+      else if (attackers_to(to, pieces() ^ from) & pieces(~us))
           return false;
   }
 
@@ -656,7 +668,7 @@ bool Position::move_gives_check(Move m, const CheckInfo& ci) const {
 
   // Promotion with check ?
   if (is_promotion(m))
-      return attacks_from(Piece(promotion_type(m)), to, occupied_squares() ^ from) & ksq;
+      return attacks_from(Piece(promotion_type(m)), to, pieces() ^ from) & ksq;
 
   // En passant capture with check ? We have already handled the case
   // of direct checks and ordinary discovered check, the only case we
@@ -665,7 +677,7 @@ bool Position::move_gives_check(Move m, const CheckInfo& ci) const {
   if (is_enpassant(m))
   {
       Square capsq = make_square(file_of(to), rank_of(from));
-      Bitboard b = (occupied_squares() ^ from ^ capsq) | to;
+      Bitboard b = (pieces() ^ from ^ capsq) | to;
 
       return  (attacks_bb<  ROOK>(ksq, b) & pieces(  ROOK, QUEEN, us))
             | (attacks_bb<BISHOP>(ksq, b) & pieces(BISHOP, QUEEN, us));
@@ -678,7 +690,7 @@ bool Position::move_gives_check(Move m, const CheckInfo& ci) const {
       Square rfrom = to; // 'King captures the rook' notation
       Square kto = relative_square(us, rfrom > kfrom ? SQ_G1 : SQ_C1);
       Square rto = relative_square(us, rfrom > kfrom ? SQ_F1 : SQ_D1);
-      Bitboard b = (occupied_squares() ^ kfrom ^ rfrom) | rto | kto;
+      Bitboard b = (pieces() ^ kfrom ^ rfrom) | rto | kto;
 
       return attacks_bb<ROOK>(rto, b) & ksq;
   }
@@ -775,9 +787,9 @@ void Position::do_move(Move m, StateInfo& newSt, const CheckInfo& ci, bool moveI
           st->npMaterial[them] -= PieceValueMidgame[capture];
 
       // Remove the captured piece
-      byColorBB[them] ^= capsq;
+      byTypeBB[ALL_PIECES] ^= capsq;
       byTypeBB[capture] ^= capsq;
-      occupied ^= capsq;
+      byColorBB[them] ^= capsq;
 
       // Update piece list, move the last piece at index[capsq] position and
       // shrink the list.
@@ -825,9 +837,9 @@ void Position::do_move(Move m, StateInfo& newSt, const CheckInfo& ci, bool moveI
 
   // Move the piece
   Bitboard from_to_bb = SquareBB[from] | SquareBB[to];
-  byColorBB[us] ^= from_to_bb;
+  byTypeBB[ALL_PIECES] ^= from_to_bb;
   byTypeBB[pt] ^= from_to_bb;
-  occupied ^= from_to_bb;
+  byColorBB[us] ^= from_to_bb;
 
   board[to] = board[from];
   board[from] = NO_PIECE;
@@ -990,9 +1002,9 @@ void Position::undo_move(Move m) {
 
   // Put the piece back at the source square
   Bitboard from_to_bb = SquareBB[from] | SquareBB[to];
-  byColorBB[us] ^= from_to_bb;
+  byTypeBB[ALL_PIECES] ^= from_to_bb;
   byTypeBB[pt] ^= from_to_bb;
-  occupied ^= from_to_bb;
+  byColorBB[us] ^= from_to_bb;
 
   board[from] = board[to];
   board[to] = NO_PIECE;
@@ -1017,9 +1029,9 @@ void Position::undo_move(Move m) {
       }
 
       // Restore the captured piece
-      byColorBB[them] |= capsq;
+      byTypeBB[ALL_PIECES] |= capsq;
       byTypeBB[capture] |= capsq;
-      occupied |= capsq;
+      byColorBB[them] |= capsq;
 
       board[capsq] = make_piece(them, capture);
 
@@ -1073,20 +1085,20 @@ void Position::do_castle_move(Move m) {
   assert(piece_on(rfrom) == make_piece(us, ROOK));
 
   // Remove pieces from source squares
-  byColorBB[us] ^= kfrom;
+  byTypeBB[ALL_PIECES] ^= kfrom;
   byTypeBB[KING] ^= kfrom;
-  occupied ^= kfrom;
-  byColorBB[us] ^= rfrom;
+  byColorBB[us] ^= kfrom;
+  byTypeBB[ALL_PIECES] ^= rfrom;
   byTypeBB[ROOK] ^= rfrom;
-  occupied ^= rfrom;
+  byColorBB[us] ^= rfrom;
 
   // Put pieces on destination squares
-  byColorBB[us] |= kto;
+  byTypeBB[ALL_PIECES] |= kto;
   byTypeBB[KING] |= kto;
-  occupied |= kto;
-  byColorBB[us] |= rto;
+  byColorBB[us] |= kto;
+  byTypeBB[ALL_PIECES] |= rto;
   byTypeBB[ROOK] |= rto;
-  occupied |= rto;
+  byColorBB[us] |= rto;
 
   // Update board
   Piece king = make_piece(us, KING);
@@ -1223,7 +1235,7 @@ int Position::see(Move m) const {
   from = from_sq(m);
   to = to_sq(m);
   capturedType = type_of(piece_on(to));
-  occ = occupied_squares();
+  occ = pieces();
 
   // Handle en passant moves
   if (is_enpassant(m))
@@ -1333,9 +1345,9 @@ void Position::put_piece(Piece p, Square s) {
   index[s] = pieceCount[c][pt]++;
   pieceList[c][pt][index[s]] = s;
 
+  byTypeBB[ALL_PIECES] |= s;
   byTypeBB[pt] |= s;
   byColorBB[c] |= s;
-  occupied |= s;
 }
 
 
@@ -1507,7 +1519,7 @@ void Position::init() {
       Bitboard b = cr;
       while (b)
       {
-          Key k = zobCastle[1 << pop_1st_bit(&b)];
+          Key k = zobCastle[1ULL << pop_1st_bit(&b)];
           zobCastle[cr] ^= k ? k : rk.rand<Key>();
       }
   }
@@ -1655,7 +1667,7 @@ bool Position::pos_is_ok(int* failedStep) const {
 
       // The union of the white and black pieces must be equal to all
       // occupied squares
-      if ((pieces(WHITE) | pieces(BLACK)) != occupied_squares())
+      if ((pieces(WHITE) | pieces(BLACK)) != pieces())
           return false;
 
       // Separate piece type bitboards must have empty intersections