Don't need to assert for pos.is_ok() when position is constant

[stockfish] / src / position.cpp

diff --git a/src/position.cpp b/src/position.cpp
index 43de667841764ee5fcf4bfe58e46955856a3d2d4..f4f0db77547ba7bd7ea9d85c9450ed908e4c1ebb 100644 (file)
--- a/src/position.cpp
+++ b/src/position.cpp
@@ -78,12 +78,11 @@ namespace {
 
 CheckInfo::CheckInfo(const Position& pos) {
 
-  Color us = pos.side_to_move();
-  Color them = opposite_color(us);
+  Color them = opposite_color(pos.side_to_move());
   Square ksq = pos.king_square(them);
 
-  dcCandidates = pos.discovered_check_candidates(us);
-  pinned = pos.pinned_pieces(us);
+  pinned = pos.pinned_pieces();
+  dcCandidates = pos.discovered_check_candidates();
 
   checkSq[PAWN]   = pos.attacks_from<PAWN>(ksq, them);
   checkSq[KNIGHT] = pos.attacks_from<KNIGHT>(ksq);
@@ -104,6 +103,8 @@ Position::Position(const Position& pos, int th) {
   detach(); // Always detach() in copy c'tor to avoid surprises
   threadID = th;
   nodes = 0;
+
+  assert(is_ok());
 }
 
 Position::Position(const string& fen, bool isChess960, int th) {
@@ -215,6 +216,8 @@ void Position::from_fen(const string& fenStr, bool isChess960) {
   st->value = compute_value();
   st->npMaterial[WHITE] = compute_non_pawn_material(WHITE);
   st->npMaterial[BLACK] = compute_non_pawn_material(BLACK);
+
+  assert(is_ok());
 }
 
 
@@ -366,12 +369,12 @@ void Position::print(Move move) const {
 /// discovery check against the enemy king.
 
 template<bool FindPinned>
-Bitboard Position::hidden_checkers(Color c) const {
+Bitboard Position::hidden_checkers() const {
 
   // Pinned pieces protect our king, dicovery checks attack the enemy king
   Bitboard b, result = EmptyBoardBB;
-  Bitboard pinners = pieces(FindPinned ? opposite_color(c) : c);
-  Square ksq = king_square(FindPinned ? c : opposite_color(c));
+  Bitboard pinners = pieces(FindPinned ? opposite_color(sideToMove) : sideToMove);
+  Square ksq = king_square(FindPinned ? sideToMove : opposite_color(sideToMove));
 
   // Pinners are sliders, that give check when candidate pinned is removed
   pinners &=  (pieces(ROOK, QUEEN) & RookPseudoAttacks[ksq])
@@ -382,7 +385,7 @@ Bitboard Position::hidden_checkers(Color c) const {
       b = squares_between(ksq, pop_1st_bit(&pinners)) & occupied_squares();
 
       // Only one bit set and is an our piece?
-      if (b && !(b & (b - 1)) && (b & pieces(c)))
+      if (b && !(b & (b - 1)) && (b & pieces(sideToMove)))
           result |= b;
   }
   return result;
@@ -390,23 +393,21 @@ Bitboard Position::hidden_checkers(Color c) const {
 
 
 /// Position:pinned_pieces() returns a bitboard of all pinned (against the
-/// king) pieces for the given color. Note that checkersBB bitboard must
-/// be already updated.
+/// king) pieces for the side to move.
 
-Bitboard Position::pinned_pieces(Color c) const {
+Bitboard Position::pinned_pieces() const {
 
-  return hidden_checkers<true>(c);
+  return hidden_checkers<true>();
 }
 
 
 /// Position:discovered_check_candidates() returns a bitboard containing all
-/// pieces for the given side which are candidates for giving a discovered
-/// check. Contrary to pinned_pieces() here there is no need of checkersBB
-/// to be already updated.
+/// pieces for the side to move which are candidates for giving a discovered
+/// check.
 
-Bitboard Position::discovered_check_candidates(Color c) const {
+Bitboard Position::discovered_check_candidates() const {
 
-  return hidden_checkers<false>(c);
+  return hidden_checkers<false>();
 }
 
 /// Position::attackers_to() computes a bitboard containing all pieces which
@@ -495,9 +496,8 @@ bool Position::move_attacks_square(Move m, Square s) const {
 
 bool Position::pl_move_is_legal(Move m, Bitboard pinned) const {
 
-  assert(is_ok());
   assert(move_is_ok(m));
-  assert(pinned == pinned_pieces(side_to_move()));
+  assert(pinned == pinned_pieces());
 
   Color us = side_to_move();
   Square from = move_from(m);
@@ -562,8 +562,6 @@ bool Position::move_is_legal(const Move m) const {
 
 bool Position::move_is_pl(const Move m) const {
 
-  assert(is_ok());
-
   Color us = sideToMove;
   Color them = opposite_color(sideToMove);
   Square from = move_from(m);
@@ -686,9 +684,8 @@ bool Position::move_is_pl(const Move m) const {
 
 bool Position::move_gives_check(Move m, const CheckInfo& ci) const {
 
-  assert(is_ok());
   assert(move_is_ok(m));
-  assert(ci.dcCandidates == discovered_check_candidates(side_to_move()));
+  assert(ci.dcCandidates == discovered_check_candidates());
   assert(piece_color(piece_on(move_from(m))) == side_to_move());
 
   Square from = move_from(m);
@@ -797,6 +794,8 @@ void Position::do_setup_move(Move m) {
   // Our StateInfo newSt is about going out of scope so copy
   // its content before it disappears.
   detach();
+
+  assert(is_ok());
 }
 
 
@@ -812,7 +811,6 @@ void Position::do_move(Move m, StateInfo& newSt) {
 
 void Position::do_move(Move m, StateInfo& newSt, const CheckInfo& ci, bool moveIsCheck) {
 
-  assert(is_ok());
   assert(move_is_ok(m));
   assert(&newSt != st);
 
@@ -1184,7 +1182,6 @@ void Position::do_castle_move(Move m) {
 
 void Position::undo_move(Move m) {
 
-  assert(is_ok());
   assert(move_is_ok(m));
 
   sideToMove = opposite_color(sideToMove);
@@ -1358,7 +1355,6 @@ void Position::undo_castle_move(Move m) {
 
 void Position::do_null_move(StateInfo& backupSt) {
 
-  assert(is_ok());
   assert(!in_check());
 
   // Back up the information necessary to undo the null move to the supplied
@@ -1388,6 +1384,8 @@ void Position::do_null_move(StateInfo& backupSt) {
   st->rule50++;
   st->pliesFromNull = 0;
   st->value += (sideToMove == WHITE) ?  TempoValue : -TempoValue;
+
+  assert(is_ok());
 }
 
 
@@ -1395,7 +1393,6 @@ void Position::do_null_move(StateInfo& backupSt) {
 
 void Position::undo_null_move() {
 
-  assert(is_ok());
   assert(!in_check());
 
   // Restore information from the our backup StateInfo object
@@ -1410,6 +1407,8 @@ void Position::undo_null_move() {
   sideToMove = opposite_color(sideToMove);
   st->rule50--;
   st->gamePly--;
+
+  assert(is_ok());
 }
 
 
@@ -1760,8 +1759,6 @@ void Position::init() {
 
 void Position::flip() {
 
-  assert(is_ok());
-
   // Make a copy of current position before to start changing
   const Position pos(*this, threadID);