Prefer 0 to EmptyBoardBB

[stockfish] / src / position.cpp

diff --git a/src/position.cpp b/src/position.cpp
index abde14593bbf833914be4651387e867770262744..bed08ebad00865a1cbe4c67347552ed4872e8196 100644 (file)
--- a/src/position.cpp
+++ b/src/position.cpp
@@ -22,6 +22,7 @@
 #include <fstream>
 #include <iostream>
 #include <sstream>
+#include <algorithm>
 
 #include "bitcount.h"
 #include "movegen.h"
@@ -88,7 +89,7 @@ CheckInfo::CheckInfo(const Position& pos) {
   checkSq[BISHOP] = pos.attacks_from<BISHOP>(ksq);
   checkSq[ROOK]   = pos.attacks_from<ROOK>(ksq);
   checkSq[QUEEN]  = checkSq[BISHOP] | checkSq[ROOK];
-  checkSq[KING]   = EmptyBoardBB;
+  checkSq[KING]   = 0;
 }
 
 
@@ -96,7 +97,7 @@ CheckInfo::CheckInfo(const Position& pos) {
 /// or the FEN string, we want the new born Position object do not depend
 /// on any external data so we detach state pointer from the source one.
 
-Position::Position(const Position& pos, int th) {
+void Position::copy(const Position& pos, int th) {
 
   memcpy(this, &pos, sizeof(Position));
   threadID = th;
@@ -223,7 +224,7 @@ void Position::from_fen(const string& fenStr, bool isChess960) {
 
   // Convert from fullmove starting from 1 to ply starting from 0,
   // handle also common incorrect FEN with fullmove = 0.
-  startPosPly = Max(2 * (startPosPly - 1), 0) + int(sideToMove == BLACK);
+  startPosPly = std::max(2 * (startPosPly - 1), 0) + int(sideToMove == BLACK);
 
   st->key = compute_key();
   st->pawnKey = compute_pawn_key();
@@ -349,7 +350,6 @@ void Position::print(Move move) const {
 /// king) pieces for the given color. Or, when template parameter FindPinned is
 /// false, the function return the pieces of the given color candidate for a
 /// discovery check against the enemy king.
-
 template<bool FindPinned>
 Bitboard Position::hidden_checkers() const {
 
@@ -373,26 +373,12 @@ Bitboard Position::hidden_checkers() const {
   return result;
 }
 
+// Explicit template instantiations
+template Bitboard Position::hidden_checkers<true>() const;
+template Bitboard Position::hidden_checkers<false>() const;
 
-/// Position:pinned_pieces() returns a bitboard of all pinned (against the
-/// king) pieces for the side to move.
-
-Bitboard Position::pinned_pieces() const {
-
-  return hidden_checkers<true>();
-}
-
-
-/// Position:discovered_check_candidates() returns a bitboard containing all
-/// pieces for the side to move which are candidates for giving a discovered
-/// check.
-
-Bitboard Position::discovered_check_candidates() const {
 
-  return hidden_checkers<false>();
-}
-
-/// Position::attackers_to() computes a bitboard of all pieces which attacks a
+/// Position::attackers_to() computes a bitboard of all pieces which attack a
 /// given square. Slider attacks use occ bitboard as occupancy.
 
 Bitboard Position::attackers_to(Square s, Bitboard occ) const {
@@ -405,6 +391,7 @@ Bitboard Position::attackers_to(Square s, Bitboard occ) const {
         | (attacks_from<KING>(s)        & pieces(KING));
 }
 
+
 /// Position::attacks_from() computes a bitboard of all attacks of a given piece
 /// put in a given square. Slider attacks use occ bitboard as occupancy.
 
@@ -431,22 +418,25 @@ bool Position::move_attacks_square(Move m, Square s) const {
   assert(square_is_ok(s));
 
   Bitboard occ, xray;
-  Square f = move_from(m), t = move_to(m);
+  Square from = move_from(m);
+  Square to = move_to(m);
+  Piece piece = piece_on(from);
+
+  assert(!square_is_empty(from));
 
-  assert(!square_is_empty(f));
+  // Update occupancy as if the piece is moving
+  occ = occupied_squares();
+  do_move_bb(&occ, make_move_bb(from, to));
 
-  if (bit_is_set(attacks_from(piece_on(f), t), s))
+  // The piece moved in 'to' attacks the square 's' ?
+  if (bit_is_set(attacks_from(piece, to, occ), s))
       return true;
 
-  // Move the piece and scan for X-ray attacks behind it
-  occ = occupied_squares();
-  do_move_bb(&occ, make_move_bb(f, t));
-  xray = ( (rook_attacks_bb(s, occ)   & pieces(ROOK, QUEEN))
-          |(bishop_attacks_bb(s, occ) & pieces(BISHOP, QUEEN)))
-         & pieces(color_of(piece_on(f)));
+  // Scan for possible X-ray attackers behind the moved piece
+  xray = (rook_attacks_bb(s, occ)   & pieces(ROOK, QUEEN, color_of(piece)))
+        |(bishop_attacks_bb(s, occ) & pieces(BISHOP, QUEEN, color_of(piece)));
 
-  // If we have attacks we need to verify that are caused by our move
-  // and are not already existent ones.
+  // Verify attackers are triggered by our move and not already existing
   return xray && (xray ^ (xray & attacks_from<QUEEN>(s)));
 }
 
@@ -503,8 +493,8 @@ bool Position::pl_move_is_legal(Move m, Bitboard pinned) const {
 
 
 /// Position::move_is_legal() takes a random move and tests whether the move
-/// is legal. This version is not very fast and should be used only
-/// in non time-critical paths.
+/// is legal. This version is not very fast and should be used only in non
+/// time-critical paths.
 
 bool Position::move_is_legal(const Move m) const {
 
@@ -941,7 +931,7 @@ void Position::do_move(Move m, StateInfo& newSt, const CheckInfo& ci, bool moveI
   st->key = key;
 
   // Update checkers bitboard, piece must be already moved
-  st->checkersBB = EmptyBoardBB;
+  st->checkersBB = 0;
 
   if (moveIsCheck)
   {
@@ -1341,7 +1331,7 @@ int Position::see(Move m) const {
   // Having built the swap list, we negamax through it to find the best
   // achievable score from the point of view of the side to move.
   while (--slIndex)
-      swapList[slIndex-1] = Min(-swapList[slIndex], swapList[slIndex-1]);
+      swapList[slIndex-1] = std::min(-swapList[slIndex], swapList[slIndex-1]);
 
   return swapList[0];
 }
@@ -1513,7 +1503,7 @@ bool Position::is_draw() const {
   // Draw by repetition?
   if (!SkipRepetition)
   {
-      int i = 4, e = Min(st->rule50, st->pliesFromNull);
+      int i = 4, e = std::min(st->rule50, st->pliesFromNull);
 
       if (i <= e)
       {
@@ -1707,7 +1697,7 @@ bool Position::pos_is_ok(int* failedStep) const {
   if (debugBitboards)
   {
       // The intersection of the white and black pieces must be empty
-      if ((pieces(WHITE) & pieces(BLACK)) != EmptyBoardBB)
+      if (!(pieces(WHITE) & pieces(BLACK)))
           return false;
 
       // The union of the white and black pieces must be equal to all