WebSVN – Games.Chess Giants – Diff – //engine-stockfish/position.cpp

   Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad
-  Copyright (C) 2015-2016 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad
+  Copyright (C) 2015-2018 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation, either version 3 of the License, or
   (at your option) any later version.
 #include "movegen.h"
 #include "position.h"
 #include "thread.h"
 #include "tt.h"
 #include "uci.h"
+#include "syzygy/tbprobe.h"
 using std::string;
 namespace PSQT {
   extern Score psq[PIECE_NB][SQUARE_NB];
 namespace Zobrist {
   Key psq[PIECE_NB][SQUARE_NB];
   Key enpassant[FILE_NB];
   Key castling[CASTLING_RIGHT_NB];
-  Key side;
+  Key side, noPawns;
+}
 namespace {
 const string PieceToChar(" PNBRQK  pnbrqk");
+const Piece Pieces[] = { W_PAWN, W_KNIGHT, W_BISHOP, W_ROOK, W_QUEEN, W_KING,
+                         B_PAWN, B_KNIGHT, B_BISHOP, B_ROOK, B_QUEEN, B_KING };
-// min_attacker() is a helper function used by see() to locate the least
+// min_attacker() is a helper function used by see_ge() to locate the least
 // valuable attacker for the side to move, remove the attacker we just found
 // from the bitboards and scan for new X-ray attacks behind it.
 template<int Pt>
 PieceType min_attacker(const Bitboard* bb, Square to, Bitboard stmAttackers,
                        Bitboard& occupied, Bitboard& attackers) {
   Bitboard b = stmAttackers & bb[Pt];
   if (!b)
-      return min_attacker<Pt+1>(bb, to, stmAttackers, occupied, attackers);
+      return min_attacker<Pt + 1>(bb, to, stmAttackers, occupied, attackers);
   occupied ^= b & ~(b - 1);
   if (Pt == PAWN || Pt == BISHOP || Pt == QUEEN)
       attackers |= attacks_bb<BISHOP>(to, occupied) & (bb[BISHOP] | bb[QUEEN]);
       os << " |\n +---+---+---+---+---+---+---+---+\n";
+  }
   os << "\nFen: " << pos.fen() << "\nKey: " << std::hex << std::uppercase
+     << std::setfill('0') << std::setw(16) << pos.key()
-     << std::setfill('0') << std::setw(16) << pos.key() << std::dec << "\nCheckers: ";
+     << std::setfill(' ') << std::dec << "\nCheckers: ";
   for (Bitboard b = pos.checkers(); b; )
       os << UCI::square(pop_lsb(&b)) << " ";
+  if (    int(Tablebases::MaxCardinality) >= popcount(pos.pieces())
+      && !pos.can_castle(ANY_CASTLING))
+  {
+      StateInfo st;
+      Position p;
+      p.set(pos.fen(), pos.is_chess960(), &st, pos.this_thread());
+      Tablebases::ProbeState s1, s2;
+      Tablebases::WDLScore wdl = Tablebases::probe_wdl(p, &s1);
+      int dtz = Tablebases::probe_dtz(p, &s2);
+      os << "\nTablebases WDL: " << std::setw(4) << wdl << " (" << s1 << ")"
+         << "\nTablebases DTZ: " << std::setw(4) << dtz << " (" << s2 << ")";
+  }
   return os;
+}
           Zobrist::castling[cr] ^= k ? k : rng.rand<Key>();
+      }
+  }
   Zobrist::side = rng.rand<Key>();
+  Zobrist::noPawns = rng.rand<Key>();
+}
 /// Position::set() initializes the position object with the given FEN string.
 /// This function is not very robust - make sure that input FENs are correct,
       can castle queenside), "k" (Black can castle kingside), and/or "q" (Black
       can castle queenside).
 ) En passant target square (in algebraic notation). If there's no en passant
       target square, this is "-". If a pawn has just made a 2-square move, this
-      is the position "behind" the pawn. This is recorded regardless of whether
+      is the position "behind" the pawn. This is recorded only if there is a pawn
-      there is a pawn in position to make an en passant capture.
+      in position to make an en passant capture, and if there really is a pawn
+      that might have advanced two squares.
 ) Halfmove clock. This is the number of halfmoves since the last pawn advance
       or capture. This is used to determine if a draw can be claimed under the
       fifty-move rule.
   // 1. Piece placement
   while ((ss >> token) && !isspace(token))
+  {
       if (isdigit(token))
-          sq += Square(token - '0'); // Advance the given number of files
+          sq += (token - '0') * EAST; // Advance the given number of files
       else if (token == '/')
-          sq -= Square(16);
+          sq += 2 * SOUTH;
       else if ((idx = PieceToChar.find(token)) != string::npos)
+      {
           put_piece(Piece(idx), sq);
           ++sq;
   if (   ((ss >> col) && (col >= 'a' && col <= 'h'))
       && ((ss >> row) && (row == '3' || row == '6')))
+  {
       st->epSquare = make_square(File(col - 'a'), Rank(row - '1'));
-      if (!(attackers_to(st->epSquare) & pieces(sideToMove, PAWN)))
+      if (   !(attackers_to(st->epSquare) & pieces(sideToMove, PAWN))
+          || !(pieces(~sideToMove, PAWN) & (st->epSquare + pawn_push(~sideToMove))))
           st->epSquare = SQ_NONE;
+  }
   else
       st->epSquare = SQ_NONE;
   // 5-6. Halfmove clock and fullmove number
   ss >> std::skipws >> st->rule50 >> gamePly;
-  // Convert from fullmove starting from 1 to ply starting from 0,
+  // Convert from fullmove starting from 1 to gamePly starting from 0,
   // handle also common incorrect FEN with fullmove = 0.
   gamePly = std::max(2 * (gamePly - 1), 0) + (sideToMove == BLACK);
   chess960 = isChess960;
   thisThread = th;
 /// The function is only used when a new position is set up, and to verify
 /// the correctness of the StateInfo data when running in debug mode.
 void Position::set_state(StateInfo* si) const {
-  si->key = si->pawnKey = si->materialKey = 0;
+  si->key = si->materialKey = 0;
+  si->pawnKey = Zobrist::noPawns;
   si->nonPawnMaterial[WHITE] = si->nonPawnMaterial[BLACK] = VALUE_ZERO;
   si->psq = SCORE_ZERO;
   si->checkersBB = attackers_to(square<KING>(sideToMove)) & pieces(~sideToMove);
   set_check_info(si);
           si->nonPawnMaterial[color_of(pc)] += pieceCount[pc] * PieceValue[MG][pc];
       for (int cnt = 0; cnt < pieceCount[pc]; ++cnt)
           si->materialKey ^= Zobrist::psq[pc][cnt];
+  }
+}
+/// Position::set() is an overload to initialize the position object with
+/// the given endgame code string like "KBPKN". It is mainly a helper to
+/// get the material key out of an endgame code.
+Position& Position::set(const string& code, Color c, StateInfo* si) {
+  assert(code.length() > 0 && code.length() < 8);
+  assert(code[0] == 'K');
+  string sides[] = { code.substr(code.find('K', 1)),      // Weak
+                     code.substr(0, code.find('K', 1)) }; // Strong
+  std::transform(sides[c].begin(), sides[c].end(), sides[c].begin(), tolower);
+  string fenStr = "8/" + sides[0] + char(8 - sides[0].length() + '0') + "/8/8/8/8/"
+                       + sides[1] + char(8 - sides[1].length() + '0') + "/8 w - - 0 10";
+  return set(fenStr, false, si, nullptr);
+}
 /// Position::fen() returns a FEN representation of the position. In case of
 /// Chess960 the Shredder-FEN notation is used. This is mainly a debugging function.
   ss << (ep_square() == SQ_NONE ? " - " : " " + UCI::square(ep_square()) + " ")
      << st->rule50 << " " << 1 + (gamePly - (sideToMove == BLACK)) / 2;
   return ss.str();
-}
-/// Position::game_phase() calculates the game phase interpolating total non-pawn
-/// material between endgame and midgame limits.
-Phase Position::game_phase() const {
-  Value npm = st->nonPawnMaterial[WHITE] + st->nonPawnMaterial[BLACK];
-  npm = std::max(EndgameLimit, std::min(npm, MidgameLimit));
-  return Phase(((npm - EndgameLimit) * PHASE_MIDGAME) / (MidgameLimit - EndgameLimit));
+}
 /// Position::slider_blockers() returns a bitboard of all the pieces (both colors)
 /// that are blocking attacks on the square 's' from 'sliders'. A piece blocks a
   Bitboard result = 0;
   pinners = 0;
   // Snipers are sliders that attack 's' when a piece is removed
-  Bitboard snipers = (  (PseudoAttacks[ROOK  ][s] & pieces(QUEEN, ROOK))
+  Bitboard snipers = (  (PseudoAttacks[  ROOK][s] & pieces(QUEEN, ROOK))
                       | (PseudoAttacks[BISHOP][s] & pieces(QUEEN, BISHOP))) & sliders;
   while (snipers)
+  {
     Square sniperSq = pop_lsb(&snipers);
 Bitboard Position::attackers_to(Square s, Bitboard occupied) const {
   return  (attacks_from<PAWN>(s, BLACK)    & pieces(WHITE, PAWN))
         | (attacks_from<PAWN>(s, WHITE)    & pieces(BLACK, PAWN))
         | (attacks_from<KNIGHT>(s)         & pieces(KNIGHT))
-        | (attacks_bb<ROOK  >(s, occupied) & pieces(ROOK,   QUEEN))
+        | (attacks_bb<  ROOK>(s, occupied) & pieces(  ROOK, QUEEN))
         | (attacks_bb<BISHOP>(s, occupied) & pieces(BISHOP, QUEEN))
         | (attacks_from<KING>(s)           & pieces(KING));
+}
                && (rank_of(from) == relative_rank(us, RANK_2))
                && empty(to)
                && empty(to - pawn_push(us))))
           return false;
+  }
-  else if (!(attacks_from(pc, from) & to))
+  else if (!(attacks_from(type_of(pc), from) & to))
       return false;
   // Evasions generator already takes care to avoid some kind of illegal moves
   // and legal() relies on this. We therefore have to take care that the same
   // kind of moves are filtered out here.
+  {
   case NORMAL:
       return false;
   case PROMOTION:
-      return attacks_bb(Piece(promotion_type(m)), to, pieces() ^ from) & square<KING>(~sideToMove);
+      return attacks_bb(promotion_type(m), to, pieces() ^ from) & square<KING>(~sideToMove);
   // En passant capture with check? We have already handled the case
   // of direct checks and ordinary discovered check, so the only case we
   // need to handle is the unusual case of a discovered check through
   // the captured pawn.
 void Position::do_move(Move m, StateInfo& newSt, bool givesCheck) {
   assert(is_ok(m));
   assert(&newSt != st);
-  ++nodes;
+  thisThread->nodes.fetch_add(1, std::memory_order_relaxed);
   Key k = st->key ^ Zobrist::side;
   // Copy some fields of the old state to our new StateInfo object except the
   // ones which are going to be recalculated from scratch anyway and then switch
   // our state pointer to point to the new (ready to be updated) state.
+  {
       // Set en-passant square if the moved pawn can be captured
       if (   (int(to) ^ int(from)) == 16
           && (attacks_from<PAWN>(to - pawn_push(us), us) & pieces(them, PAWN)))
+      {
-          st->epSquare = (from + to) / 2;
+          st->epSquare = to - pawn_push(us);
           k ^= Zobrist::enpassant[file_of(st->epSquare)];
+      }
       else if (type_of(m) == PROMOTION)
+      {
           st->nonPawnMaterial[us] += PieceValue[MG][promotion];
+      }
       // Update pawn hash key and prefetch access to pawnsTable
       st->pawnKey ^= Zobrist::psq[pc][from] ^ Zobrist::psq[pc][to];
-      prefetch(thisThread->pawnsTable[st->pawnKey]);
+      prefetch2(thisThread->pawnsTable[st->pawnKey]);
       // Reset rule 50 draw counter
       st->rule50 = 0;
+  }
   return k ^ Zobrist::psq[pc][to] ^ Zobrist::psq[pc][from];
+}
 /// Position::see_ge (Static Exchange Evaluation Greater or Equal) tests if the
-/// SEE value of move is greater or equal to the given value. We'll use an
+/// SEE value of move is greater or equal to the given threshold. We'll use an
 /// algorithm similar to alpha-beta pruning with a null window.
-bool Position::see_ge(Move m, Value v) const {
+bool Position::see_ge(Move m, Value threshold) const {
   assert(is_ok(m));
-  // Castling moves are implemented as king capturing the rook so cannot be
-  // handled correctly. Simply assume the SEE value is VALUE_ZERO that is always
-  // correct unless in the rare case the rook ends up under attack.
+  // Only deal with normal moves, assume others pass a simple see
-  if (type_of(m) == CASTLING)
+  if (type_of(m) != NORMAL)
-      return VALUE_ZERO >= v;
+      return VALUE_ZERO >= threshold;
   Square from = from_sq(m), to = to_sq(m);
   PieceType nextVictim = type_of(piece_on(from));
   Color stm = ~color_of(piece_on(from)); // First consider opponent's move
   Value balance; // Values of the pieces taken by us minus opponent's ones
   Bitboard occupied, stmAttackers;
-  if (type_of(m) == ENPASSANT)
-  {
-      occupied = SquareBB[to - pawn_push(~stm)]; // Remove the captured pawn
+  // The opponent may be able to recapture so this is the best result
-      balance = PieceValue[MG][PAWN];
+  // we can hope for.
-  }
-  else
-  {
-      balance = PieceValue[MG][piece_on(to)];
+  balance = PieceValue[MG][piece_on(to)] - threshold;
-      occupied = 0;
-  }
-  if (balance < v)
+  if (balance < VALUE_ZERO)
       return false;
-  if (nextVictim == KING)
+  // Now assume the worst possible result: that the opponent can
-      return true;
+  // capture our piece for free.
   balance -= PieceValue[MG][nextVictim];
-  if (balance >= v)
+  if (balance >= VALUE_ZERO) // Always true if nextVictim == KING
       return true;
-  bool relativeStm = true; // True if the opponent is to move
+  bool opponentToMove = true;
-  occupied ^= pieces() ^ from ^ to;
+  occupied = pieces() ^ from ^ to;
   // Find all attackers to the destination square, with the moving piece removed,
   // but possibly an X-ray attacker added behind it.
   Bitboard attackers = attackers_to(to, occupied) & occupied;
   while (true)
+  {
+      // The balance is negative only because we assumed we could win
+      // the last piece for free. We are truly winning only if we can
+      // win the last piece _cheaply enough_. Test if we can actually
+      // do this otherwise "give up".
+      assert(balance < VALUE_ZERO);
       stmAttackers = attackers & pieces(stm);
       // Don't allow pinned pieces to attack pieces except the king as long all
       // pinners are on their original square.
       if (!(st->pinnersForKing[stm] & ~occupied))
           stmAttackers &= ~st->blockersForKing[stm];
+      // If we have no more attackers we must give up
       if (!stmAttackers)
-          return relativeStm;
+          break;
       // Locate and remove the next least valuable attacker
       nextVictim = min_attacker<PAWN>(byTypeBB, to, stmAttackers, occupied, attackers);
       if (nextVictim == KING)
+      {
+          // Our only attacker is the king. If the opponent still has
+          // attackers we must give up. Otherwise we make the move and
+          // (having no more attackers) the opponent must give up.
-          return relativeStm == bool(attackers & pieces(~stm));
+          if (!(attackers & pieces(~stm)))
+              opponentToMove = !opponentToMove;
+          break;
+      }
+      // Assume the opponent can win the next piece for free and switch sides
-      balance += relativeStm ?  PieceValue[MG][nextVictim]
+      balance += PieceValue[MG][nextVictim];
-                             : -PieceValue[MG][nextVictim];
+      opponentToMove = !opponentToMove;
-      relativeStm = !relativeStm;
+      // If balance is negative after receiving a free piece then give up
-      if (relativeStm == (balance >= v))
+      if (balance < VALUE_ZERO)
-          return relativeStm;
+          break;
+      // Complete the process of switching sides. The first line swaps
+      // all negative numbers with non-negative numbers. The compiler
+      // probably knows that it is just the bitwise negation ~balance.
+      balance = -balance-1;
       stm = ~stm;
+  }
+  // If the opponent gave up we win, otherwise we lose.
+  return opponentToMove;
+}
 /// Position::is_draw() tests whether the position is drawn by 50-move rule
 /// or by repetition. It does not detect stalemates.
-bool Position::is_draw() const {
+bool Position::is_draw(int ply) const {
   if (st->rule50 > 99 && (!checkers() || MoveList<LEGAL>(*this).size()))
       return true;
+  int end = std::min(st->rule50, st->pliesFromNull);
+  if (end < 4)
+    return false;
-  StateInfo* stp = st;
+  StateInfo* stp = st->previous->previous;
+  int cnt = 0;
-  for (int i = 2, e = std::min(st->rule50, st->pliesFromNull); i <= e; i += 2)
+  for (int i = 4; i <= end; i += 2)
+  {
       stp = stp->previous->previous;
+      // Return a draw score if a position repeats once earlier but strictly
+      // after the root, or repeats twice before or at the root.
-      if (stp->key == st->key)
+      if (   stp->key == st->key
-          return true; // Draw at first repetition
+          && ++cnt + (ply > i) == 2)
+          return true;
+  }
   return false;
+}
   assert(pos_is_ok());
+}
-/// Position::pos_is_ok() performs some consistency checks for the position object.
+/// Position::pos_is_ok() performs some consistency checks for the
+/// position object and raises an asserts if something wrong is detected.
 /// This is meant to be helpful when debugging.
-bool Position::pos_is_ok(int* failedStep) const {
+bool Position::pos_is_ok() const {
   const bool Fast = true; // Quick (default) or full check?
+  if (   (sideToMove != WHITE && sideToMove != BLACK)
+      || piece_on(square<KING>(WHITE)) != W_KING
+      || piece_on(square<KING>(BLACK)) != B_KING
+      || (   ep_square() != SQ_NONE
-  enum { Default, King, Bitboards, State, Lists, Castling };
+          && relative_rank(sideToMove, ep_square()) != RANK_6))
+      assert(0 && "pos_is_ok: Default");
-  for (int step = Default; step <= (Fast ? Default : Castling); step++)
-  {
-      if (failedStep)
+  if (Fast)
-          *failedStep = step;
+      return true;
-      if (step == Default)
-          if (   (sideToMove != WHITE && sideToMove != BLACK)
-              || piece_on(square<KING>(WHITE)) != W_KING
+  if (   pieceCount[W_KING] != 1
-              || piece_on(square<KING>(BLACK)) != B_KING
+      || pieceCount[B_KING] != 1
-              || (   ep_square() != SQ_NONE
-                  && relative_rank(sideToMove, ep_square()) != RANK_6))
+      || attackers_to(square<KING>(~sideToMove)) & pieces(sideToMove))
-              return false;
+      assert(0 && "pos_is_ok: Kings");
-      if (step == King)
+  if (   (pieces(PAWN) & (Rank1BB | Rank8BB))
-          if (   std::count(board, board + SQUARE_NB, W_KING) != 1
+      || pieceCount[W_PAWN] > 8
-              || std::count(board, board + SQUARE_NB, B_KING) != 1
+      || pieceCount[B_PAWN] > 8)
-              || attackers_to(square<KING>(~sideToMove)) & pieces(sideToMove))
-              return false;
+      assert(0 && "pos_is_ok: Pawns");
-      if (step == Bitboards)
+  if (   (pieces(WHITE) & pieces(BLACK))
-      {
-          if (  (pieces(WHITE) & pieces(BLACK))
+      || (pieces(WHITE) | pieces(BLACK)) != pieces()
+      || popcount(pieces(WHITE)) > 16
-              ||(pieces(WHITE) | pieces(BLACK)) != pieces())
+      || popcount(pieces(BLACK)) > 16)
-              return false;
+      assert(0 && "pos_is_ok: Bitboards");
-          for (PieceType p1 = PAWN; p1 <= KING; ++p1)
+  for (PieceType p1 = PAWN; p1 <= KING; ++p1)
-              for (PieceType p2 = PAWN; p2 <= KING; ++p2)
+      for (PieceType p2 = PAWN; p2 <= KING; ++p2)
-                  if (p1 != p2 && (pieces(p1) & pieces(p2)))
+          if (p1 != p2 && (pieces(p1) & pieces(p2)))
-                      return false;
+              assert(0 && "pos_is_ok: Bitboards");
-      }
-      if (step == State)
-      {
-          StateInfo si = *st;
+  StateInfo si = *st;
-          set_state(&si);
+  set_state(&si);
-          if (std::memcmp(&si, st, sizeof(StateInfo)))
+  if (std::memcmp(&si, st, sizeof(StateInfo)))
-              return false;
+      assert(0 && "pos_is_ok: State");
-      }
-      if (step == Lists)
-          for (Piece pc : Pieces)
+  for (Piece pc : Pieces)
-          {
+  {
-              if (pieceCount[pc] != popcount(pieces(color_of(pc), type_of(pc))))
+      if (   pieceCount[pc] != popcount(pieces(color_of(pc), type_of(pc)))
+          || pieceCount[pc] != std::count(board, board + SQUARE_NB, pc))
-                  return false;
+          assert(0 && "pos_is_ok: Pieces");
-              for (int i = 0; i < pieceCount[pc]; ++i)
+      for (int i = 0; i < pieceCount[pc]; ++i)
-                  if (board[pieceList[pc][i]] != pc || index[pieceList[pc][i]] != i)
+          if (board[pieceList[pc][i]] != pc || index[pieceList[pc][i]] != i)
-                      return false;
+              assert(0 && "pos_is_ok: Index");
-          }
+  }
-      if (step == Castling)
-          for (Color c = WHITE; c <= BLACK; ++c)
+  for (Color c = WHITE; c <= BLACK; ++c)
-              for (CastlingSide s = KING_SIDE; s <= QUEEN_SIDE; s = CastlingSide(s + 1))
+      for (CastlingSide s = KING_SIDE; s <= QUEEN_SIDE; s = CastlingSide(s + 1))
-              {
+      {
-                  if (!can_castle(c | s))
+          if (!can_castle(c | s))
-                      continue;
+              continue;
-                  if (   piece_on(castlingRookSquare[c | s]) != make_piece(c, ROOK)
+          if (   piece_on(castlingRookSquare[c | s]) != make_piece(c, ROOK)
-                      || castlingRightsMask[castlingRookSquare[c | s]] != (c | s)
+              || castlingRightsMask[castlingRookSquare[c | s]] != (c | s)
-                      ||(castlingRightsMask[square<KING>(c)] & (c | s)) != (c | s))
+              || (castlingRightsMask[square<KING>(c)] & (c | s)) != (c | s))
-                      return false;
+              assert(0 && "pos_is_ok: Castling");
-              }
-  }
+      }
   return true;
+}

Subversion Repositories Games.Chess Giants

Games.Chess Giants//engine-stockfish/position.cpp – Rev 154 → 169