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

   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 #include <algorithm>
 #include <cassert>
+#include <cstddef> // For offsetof()
-#include <cstring>   // For std::memset, std::memcmp
+#include <cstring> // For std::memset, std::memcmp
 #include <iomanip>
 #include <sstream>
-#include "bitcount.h"
+#include "bitboard.h"
 #include "misc.h"
 #include "movegen.h"
 #include "position.h"
 #include "thread.h"
 #include "tt.h"
 #include "uci.h"
 using std::string;
-Value PieceValue[PHASE_NB][PIECE_NB] = {
+namespace PSQT {
-{ VALUE_ZERO, PawnValueMg, KnightValueMg, BishopValueMg, RookValueMg, QueenValueMg },
-{ VALUE_ZERO, PawnValueEg, KnightValueEg, BishopValueEg, RookValueEg, QueenValueEg } };
+  extern Score psq[PIECE_NB][SQUARE_NB];
+}
 namespace Zobrist {
-  Key psq[COLOR_NB][PIECE_TYPE_NB][SQUARE_NB];
+  Key psq[PIECE_NB][SQUARE_NB];
   Key enpassant[FILE_NB];
   Key castling[CASTLING_RIGHT_NB];
   Key side;
-  Key exclusion;
+}
-Key Position::exclusion_key() const { return st->key ^ Zobrist::exclusion; }
 namespace {
 const string PieceToChar(" PNBRQK  pnbrqk");
 PieceType min_attacker<KING>(const Bitboard*, Square, Bitboard, Bitboard&, Bitboard&) {
   return KING; // No need to update bitboards: it is the last cycle
+}
 } // namespace
-/// CheckInfo constructor
-CheckInfo::CheckInfo(const Position& pos) {
-  Color them = ~pos.side_to_move();
-  ksq = pos.square<KING>(them);
-  pinned = pos.pinned_pieces(pos.side_to_move());
-  dcCandidates = pos.discovered_check_candidates();
-  checkSquares[PAWN]   = pos.attacks_from<PAWN>(ksq, them);
-  checkSquares[KNIGHT] = pos.attacks_from<KNIGHT>(ksq);
-  checkSquares[BISHOP] = pos.attacks_from<BISHOP>(ksq);
-  checkSquares[ROOK]   = pos.attacks_from<ROOK>(ksq);
-  checkSquares[QUEEN]  = checkSquares[BISHOP] | checkSquares[ROOK];
-  checkSquares[KING]   = 0;
-}
 /// operator<<(Position) returns an ASCII representation of the position
 std::ostream& operator<<(std::ostream& os, const Position& pos) {
 void Position::init() {
   PRNG rng(1070372);
-  for (Color c = WHITE; c <= BLACK; ++c)
+  for (Piece pc : Pieces)
-      for (PieceType pt = PAWN; pt <= KING; ++pt)
-          for (Square s = SQ_A1; s <= SQ_H8; ++s)
+      for (Square s = SQ_A1; s <= SQ_H8; ++s)
-              Zobrist::psq[c][pt][s] = rng.rand<Key>();
+          Zobrist::psq[pc][s] = rng.rand<Key>();
   for (File f = FILE_A; f <= FILE_H; ++f)
       Zobrist::enpassant[f] = rng.rand<Key>();
   for (int cr = NO_CASTLING; cr <= ANY_CASTLING; ++cr)
           Zobrist::castling[cr] ^= k ? k : rng.rand<Key>();
+      }
+  }
   Zobrist::side = rng.rand<Key>();
-  Zobrist::exclusion  = rng.rand<Key>();
-}
-/// Position::operator=() creates a copy of 'pos' but detaching the state pointer
-/// from the source to be self-consistent and not depending on any external data.
-Position& Position::operator=(const Position& pos) {
-  std::memcpy(this, &pos, sizeof(Position));
-  std::memcpy(&startState, st, sizeof(StateInfo));
-  st = &startState;
-  nodes = 0;
-  assert(pos_is_ok());
-  return *this;
-}
-/// Position::clear() erases the position object to a pristine state, with an
-/// empty board, white to move, and no castling rights.
-void Position::clear() {
-  std::memset(this, 0, sizeof(Position));
-  startState.epSquare = SQ_NONE;
-  st = &startState;
-  for (int i = 0; i < PIECE_TYPE_NB; ++i)
-      for (int j = 0; j < 16; ++j)
-          pieceList[WHITE][i][j] = pieceList[BLACK][i][j] = SQ_NONE;
+}
 /// Position::set() initializes the position object with the given FEN string.
 /// This function is not very robust - make sure that input FENs are correct,
 /// this is assumed to be the responsibility of the GUI.
-void Position::set(const string& fenStr, bool isChess960, Thread* th) {
+Position& Position::set(const string& fenStr, bool isChess960, StateInfo* si, Thread* th) {
 /*
    A FEN string defines a particular position using only the ASCII character set.
    A FEN string contains six fields separated by a space. The fields are:
   unsigned char col, row, token;
   size_t idx;
   Square sq = SQ_A8;
   std::istringstream ss(fenStr);
+  std::memset(this, 0, sizeof(Position));
+  std::memset(si, 0, sizeof(StateInfo));
+  std::fill_n(&pieceList[0][0], sizeof(pieceList) / sizeof(Square), SQ_NONE);
-  clear();
+  st = si;
   ss >> std::noskipws;
   // 1. Piece placement
   while ((ss >> token) && !isspace(token))
+  {
       else if (token == '/')
           sq -= Square(16);
       else if ((idx = PieceToChar.find(token)) != string::npos)
+      {
-          put_piece(color_of(Piece(idx)), type_of(Piece(idx)), sq);
+          put_piece(Piece(idx), sq);
           ++sq;
+      }
+  }
   // 2. Active color
       st->epSquare = make_square(File(col - 'a'), Rank(row - '1'));
       if (!(attackers_to(st->epSquare) & pieces(sideToMove, PAWN)))
           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,
   chess960 = isChess960;
   thisThread = th;
   set_state(st);
   assert(pos_is_ok());
+  return *this;
+}
 /// Position::set_castling_right() is a helper function used to set castling
 /// rights given the corresponding color and the rook starting square.
           castlingPath[cr] |= s;
   for (Square s = std::min(kfrom, kto); s <= std::max(kfrom, kto); ++s)
       if (s != kfrom && s != rfrom)
           castlingPath[cr] |= s;
+}
+/// Position::set_check_info() sets king attacks to detect if a move gives check
+void Position::set_check_info(StateInfo* si) const {
+  si->blockersForKing[WHITE] = slider_blockers(pieces(BLACK), square<KING>(WHITE), si->pinnersForKing[WHITE]);
+  si->blockersForKing[BLACK] = slider_blockers(pieces(WHITE), square<KING>(BLACK), si->pinnersForKing[BLACK]);
+  Square ksq = square<KING>(~sideToMove);
+  si->checkSquares[PAWN]   = attacks_from<PAWN>(ksq, ~sideToMove);
+  si->checkSquares[KNIGHT] = attacks_from<KNIGHT>(ksq);
+  si->checkSquares[BISHOP] = attacks_from<BISHOP>(ksq);
+  si->checkSquares[ROOK]   = attacks_from<ROOK>(ksq);
+  si->checkSquares[QUEEN]  = si->checkSquares[BISHOP] | si->checkSquares[ROOK];
+  si->checkSquares[KING]   = 0;
+}
 /// Position::set_state() computes the hash keys of the position, and other
 /// data that once computed is updated incrementally as moves are made.
 void Position::set_state(StateInfo* si) const {
   si->key = si->pawnKey = si->materialKey = 0;
   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);
   for (Bitboard b = pieces(); b; )
+  {
       Square s = pop_lsb(&b);
       Piece pc = piece_on(s);
-      si->key ^= Zobrist::psq[color_of(pc)][type_of(pc)][s];
+      si->key ^= Zobrist::psq[pc][s];
-      si->psq += PSQT::psq[color_of(pc)][type_of(pc)][s];
+      si->psq += PSQT::psq[pc][s];
+  }
   if (si->epSquare != SQ_NONE)
       si->key ^= Zobrist::enpassant[file_of(si->epSquare)];
   si->key ^= Zobrist::castling[si->castlingRights];
   for (Bitboard b = pieces(PAWN); b; )
+  {
       Square s = pop_lsb(&b);
-      si->pawnKey ^= Zobrist::psq[color_of(piece_on(s))][PAWN][s];
+      si->pawnKey ^= Zobrist::psq[piece_on(s)][s];
+  }
-  for (Color c = WHITE; c <= BLACK; ++c)
+  for (Piece pc : Pieces)
+  {
-      for (PieceType pt = PAWN; pt <= KING; ++pt)
+      if (type_of(pc) != PAWN && type_of(pc) != KING)
-          for (int cnt = 0; cnt < pieceCount[c][pt]; ++cnt)
+          si->nonPawnMaterial[color_of(pc)] += pieceCount[pc] * PieceValue[MG][pc];
-              si->materialKey ^= Zobrist::psq[c][pt][cnt];
-  for (Color c = WHITE; c <= BLACK; ++c)
-      for (PieceType pt = KNIGHT; pt <= QUEEN; ++pt)
+      for (int cnt = 0; cnt < pieceCount[pc]; ++cnt)
-          si->nonPawnMaterial[c] += pieceCount[c][pt] * PieceValue[MG][pt];
+          si->materialKey ^= Zobrist::psq[pc][cnt];
+  }
+}
 /// 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.
   return Phase(((npm - EndgameLimit) * PHASE_MIDGAME) / (MidgameLimit - EndgameLimit));
+}
-/// Position::check_blockers() returns a bitboard of all the pieces with color
+/// Position::slider_blockers() returns a bitboard of all the pieces (both colors)
-/// 'c' that are blocking check on the king with color 'kingColor'. A piece
+/// that are blocking attacks on the square 's' from 'sliders'. A piece blocks a
-/// blocks a check if removing that piece from the board would result in a
+/// slider if removing that piece from the board would result in a position where
-/// position where the king is in check. A check blocking piece can be either a
+/// square 's' is attacked. For example, a king-attack blocking piece can be either
-/// pinned or a discovered check piece, according if its color 'c' is the same
+/// a pinned or a discovered check piece, according if its color is the opposite
-/// or the opposite of 'kingColor'.
+/// or the same of the color of the slider.
-Bitboard Position::check_blockers(Color c, Color kingColor) const {
+Bitboard Position::slider_blockers(Bitboard sliders, Square s, Bitboard& pinners) const {
-  Bitboard b, pinners, result = 0;
+  Bitboard result = 0;
-  Square ksq = square<KING>(kingColor);
+  pinners = 0;
-  // Pinners are sliders that give check when a pinned piece is removed
+  // Snipers are sliders that attack 's' when a piece is removed
-  pinners = (  (pieces(  ROOK, QUEEN) & PseudoAttacks[ROOK  ][ksq])
+  Bitboard snipers = (  (PseudoAttacks[ROOK  ][s] & pieces(QUEEN, ROOK))
-             | (pieces(BISHOP, QUEEN) & PseudoAttacks[BISHOP][ksq])) & pieces(~kingColor);
+                      | (PseudoAttacks[BISHOP][s] & pieces(QUEEN, BISHOP))) & sliders;
-  while (pinners)
+  while (snipers)
+  {
+    Square sniperSq = pop_lsb(&snipers);
-      b = between_bb(ksq, pop_lsb(&pinners)) & pieces();
+    Bitboard b = between_bb(s, sniperSq) & pieces();
-      if (!more_than_one(b))
+    if (!more_than_one(b))
+    {
-          result |= b & pieces(c);
+        result |= b;
+        if (b & pieces(color_of(piece_on(s))))
+            pinners |= sniperSq;
+    }
+  }
   return result;
+}
+}
 /// Position::legal() tests whether a pseudo-legal move is legal
-bool Position::legal(Move m, Bitboard pinned) const {
+bool Position::legal(Move m) const {
   assert(is_ok(m));
-  assert(pinned == pinned_pieces(sideToMove));
   Color us = sideToMove;
   Square from = from_sq(m);
   assert(color_of(moved_piece(m)) == us);
   if (type_of(piece_on(from)) == KING)
       return type_of(m) == CASTLING || !(attackers_to(to_sq(m)) & pieces(~us));
   // A non-king move is legal if and only if it is not pinned or it
   // is moving along the ray towards or away from the king.
-  return   !pinned
-        || !(pinned & from)
+  return   !(pinned_pieces(us) & from)
         ||  aligned(from, to_sq(m), square<KING>(us));
+}
 /// Position::pseudo_legal() takes a random move and tests whether the move is
+}
 /// Position::gives_check() tests whether a pseudo-legal move gives a check
-bool Position::gives_check(Move m, const CheckInfo& ci) const {
+bool Position::gives_check(Move m) const {
   assert(is_ok(m));
-  assert(ci.dcCandidates == discovered_check_candidates());
   assert(color_of(moved_piece(m)) == sideToMove);
   Square from = from_sq(m);
   Square to = to_sq(m);
   // Is there a direct check?
-  if (ci.checkSquares[type_of(piece_on(from))] & to)
+  if (st->checkSquares[type_of(piece_on(from))] & to)
       return true;
   // Is there a discovered check?
-  if (    ci.dcCandidates
-      && (ci.dcCandidates & from)
+  if (   (discovered_check_candidates() & from)
-      && !aligned(from, to, ci.ksq))
+      && !aligned(from, to, square<KING>(~sideToMove)))
       return true;
   switch (type_of(m))
+  {
   case NORMAL:
       return false;
   case PROMOTION:
-      return attacks_bb(Piece(promotion_type(m)), to, pieces() ^ from) & ci.ksq;
+      return attacks_bb(Piece(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.
   case ENPASSANT:
+  {
       Square capsq = make_square(file_of(to), rank_of(from));
       Bitboard b = (pieces() ^ from ^ capsq) | to;
-      return  (attacks_bb<  ROOK>(ci.ksq, b) & pieces(sideToMove, QUEEN, ROOK))
+      return  (attacks_bb<  ROOK>(square<KING>(~sideToMove), b) & pieces(sideToMove, QUEEN, ROOK))
-            | (attacks_bb<BISHOP>(ci.ksq, b) & pieces(sideToMove, QUEEN, BISHOP));
+            | (attacks_bb<BISHOP>(square<KING>(~sideToMove), b) & pieces(sideToMove, QUEEN, BISHOP));
+  }
   case CASTLING:
+  {
       Square kfrom = from;
       Square rfrom = to; // Castling is encoded as 'King captures the rook'
       Square kto = relative_square(sideToMove, rfrom > kfrom ? SQ_G1 : SQ_C1);
       Square rto = relative_square(sideToMove, rfrom > kfrom ? SQ_F1 : SQ_D1);
-      return   (PseudoAttacks[ROOK][rto] & ci.ksq)
+      return   (PseudoAttacks[ROOK][rto] & square<KING>(~sideToMove))
-            && (attacks_bb<ROOK>(rto, (pieces() ^ kfrom ^ rfrom) | rto | kto) & ci.ksq);
+            && (attacks_bb<ROOK>(rto, (pieces() ^ kfrom ^ rfrom) | rto | kto) & square<KING>(~sideToMove));
+  }
   default:
       assert(false);
       return false;
+  }
   Color us = sideToMove;
   Color them = ~us;
   Square from = from_sq(m);
   Square to = to_sq(m);
-  PieceType pt = type_of(piece_on(from));
+  Piece pc = piece_on(from);
-  PieceType captured = type_of(m) == ENPASSANT ? PAWN : type_of(piece_on(to));
+  Piece captured = type_of(m) == ENPASSANT ? make_piece(them, PAWN) : piece_on(to);
-  assert(color_of(piece_on(from)) == us);
+  assert(color_of(pc) == us);
-  assert(piece_on(to) == NO_PIECE || color_of(piece_on(to)) == (type_of(m) != CASTLING ? them : us));
+  assert(captured == NO_PIECE || color_of(captured) == (type_of(m) != CASTLING ? them : us));
-  assert(captured != KING);
+  assert(type_of(captured) != KING);
   if (type_of(m) == CASTLING)
+  {
-      assert(pt == KING);
+      assert(pc == make_piece(us, KING));
+      assert(captured == make_piece(us, ROOK));
       Square rfrom, rto;
       do_castling<true>(us, from, to, rfrom, rto);
-      captured = NO_PIECE_TYPE;
-      st->psq += PSQT::psq[us][ROOK][rto] - PSQT::psq[us][ROOK][rfrom];
+      st->psq += PSQT::psq[captured][rto] - PSQT::psq[captured][rfrom];
-      k ^= Zobrist::psq[us][ROOK][rfrom] ^ Zobrist::psq[us][ROOK][rto];
+      k ^= Zobrist::psq[captured][rfrom] ^ Zobrist::psq[captured][rto];
+      captured = NO_PIECE;
+  }
   if (captured)
+  {
       Square capsq = to;
       // If the captured piece is a pawn, update pawn hash key, otherwise
       // update non-pawn material.
-      if (captured == PAWN)
+      if (type_of(captured) == PAWN)
+      {
           if (type_of(m) == ENPASSANT)
+          {
               capsq -= pawn_push(us);
-              assert(pt == PAWN);
+              assert(pc == make_piece(us, PAWN));
               assert(to == st->epSquare);
               assert(relative_rank(us, to) == RANK_6);
               assert(piece_on(to) == NO_PIECE);
               assert(piece_on(capsq) == make_piece(them, PAWN));
               board[capsq] = NO_PIECE; // Not done by remove_piece()
+          }
-          st->pawnKey ^= Zobrist::psq[them][PAWN][capsq];
+          st->pawnKey ^= Zobrist::psq[captured][capsq];
+      }
       else
           st->nonPawnMaterial[them] -= PieceValue[MG][captured];
       // Update board and piece lists
-      remove_piece(them, captured, capsq);
+      remove_piece(captured, capsq);
       // Update material hash key and prefetch access to materialTable
-      k ^= Zobrist::psq[them][captured][capsq];
+      k ^= Zobrist::psq[captured][capsq];
-      st->materialKey ^= Zobrist::psq[them][captured][pieceCount[them][captured]];
+      st->materialKey ^= Zobrist::psq[captured][pieceCount[captured]];
       prefetch(thisThread->materialTable[st->materialKey]);
       // Update incremental scores
-      st->psq -= PSQT::psq[them][captured][capsq];
+      st->psq -= PSQT::psq[captured][capsq];
       // Reset rule 50 counter
       st->rule50 = 0;
+  }
   // Update hash key
-  k ^= Zobrist::psq[us][pt][from] ^ Zobrist::psq[us][pt][to];
+  k ^= Zobrist::psq[pc][from] ^ Zobrist::psq[pc][to];
   // Reset en passant square
   if (st->epSquare != SQ_NONE)
+  {
       k ^= Zobrist::enpassant[file_of(st->epSquare)];
       st->castlingRights &= ~cr;
+  }
   // Move the piece. The tricky Chess960 castling is handled earlier
   if (type_of(m) != CASTLING)
-      move_piece(us, pt, from, to);
+      move_piece(pc, from, to);
   // If the moving piece is a pawn do some special extra work
-  if (pt == PAWN)
+  if (type_of(pc) == PAWN)
+  {
       // 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)))
+      {
           k ^= Zobrist::enpassant[file_of(st->epSquare)];
+      }
       else if (type_of(m) == PROMOTION)
+      {
-          PieceType promotion = promotion_type(m);
+          Piece promotion = make_piece(us, promotion_type(m));
           assert(relative_rank(us, to) == RANK_8);
-          assert(promotion >= KNIGHT && promotion <= QUEEN);
+          assert(type_of(promotion) >= KNIGHT && type_of(promotion) <= QUEEN);
-          remove_piece(us, PAWN, to);
+          remove_piece(pc, to);
-          put_piece(us, promotion, to);
+          put_piece(promotion, to);
           // Update hash keys
-          k ^= Zobrist::psq[us][PAWN][to] ^ Zobrist::psq[us][promotion][to];
+          k ^= Zobrist::psq[pc][to] ^ Zobrist::psq[promotion][to];
-          st->pawnKey ^= Zobrist::psq[us][PAWN][to];
+          st->pawnKey ^= Zobrist::psq[pc][to];
-          st->materialKey ^=  Zobrist::psq[us][promotion][pieceCount[us][promotion]-1]
+          st->materialKey ^=  Zobrist::psq[promotion][pieceCount[promotion]-1]
-                            ^ Zobrist::psq[us][PAWN][pieceCount[us][PAWN]];
+                            ^ Zobrist::psq[pc][pieceCount[pc]];
           // Update incremental score
-          st->psq += PSQT::psq[us][promotion][to] - PSQT::psq[us][PAWN][to];
+          st->psq += PSQT::psq[promotion][to] - PSQT::psq[pc][to];
           // Update material
           st->nonPawnMaterial[us] += PieceValue[MG][promotion];
+      }
       // Update pawn hash key and prefetch access to pawnsTable
-      st->pawnKey ^= Zobrist::psq[us][PAWN][from] ^ Zobrist::psq[us][PAWN][to];
+      st->pawnKey ^= Zobrist::psq[pc][from] ^ Zobrist::psq[pc][to];
       prefetch(thisThread->pawnsTable[st->pawnKey]);
       // Reset rule 50 draw counter
       st->rule50 = 0;
+  }
   // Update incremental scores
-  st->psq += PSQT::psq[us][pt][to] - PSQT::psq[us][pt][from];
+  st->psq += PSQT::psq[pc][to] - PSQT::psq[pc][from];
   // Set capture piece
-  st->capturedType = captured;
+  st->capturedPiece = captured;
   // Update the key with the final value
   st->key = k;
   // Calculate checkers bitboard (if move gives check)
   st->checkersBB = givesCheck ? attackers_to(square<KING>(them)) & pieces(us) : 0;
   sideToMove = ~sideToMove;
+  // Update king attacks used for fast check detection
+  set_check_info(st);
   assert(pos_is_ok());
+}
   sideToMove = ~sideToMove;
   Color us = sideToMove;
   Square from = from_sq(m);
   Square to = to_sq(m);
-  PieceType pt = type_of(piece_on(to));
+  Piece pc = piece_on(to);
   assert(empty(from) || type_of(m) == CASTLING);
-  assert(st->capturedType != KING);
+  assert(type_of(st->capturedPiece) != KING);
   if (type_of(m) == PROMOTION)
+  {
       assert(relative_rank(us, to) == RANK_8);
-      assert(pt == promotion_type(m));
+      assert(type_of(pc) == promotion_type(m));
-      assert(pt >= KNIGHT && pt <= QUEEN);
+      assert(type_of(pc) >= KNIGHT && type_of(pc) <= QUEEN);
-      remove_piece(us, pt, to);
+      remove_piece(pc, to);
-      put_piece(us, PAWN, to);
+      pc = make_piece(us, PAWN);
-      pt = PAWN;
+      put_piece(pc, to);
+  }
   if (type_of(m) == CASTLING)
+  {
       Square rfrom, rto;
       do_castling<false>(us, from, to, rfrom, rto);
+  }
   else
+  {
-      move_piece(us, pt, to, from); // Put the piece back at the source square
+      move_piece(pc, to, from); // Put the piece back at the source square
-      if (st->capturedType)
+      if (st->capturedPiece)
+      {
           Square capsq = to;
           if (type_of(m) == ENPASSANT)
+          {
               capsq -= pawn_push(us);
-              assert(pt == PAWN);
+              assert(type_of(pc) == PAWN);
               assert(to == st->previous->epSquare);
               assert(relative_rank(us, to) == RANK_6);
               assert(piece_on(capsq) == NO_PIECE);
-              assert(st->capturedType == PAWN);
+              assert(st->capturedPiece == make_piece(~us, PAWN));
+          }
-          put_piece(~us, st->capturedType, capsq); // Restore the captured piece
+          put_piece(st->capturedPiece, capsq); // Restore the captured piece
+      }
+  }
   // Finally point our state pointer back to the previous state
   st = st->previous;
   assert(pos_is_ok());
+}
 /// Position::do_castling() is a helper used to do/undo a castling move. This
-/// is a bit tricky, especially in Chess960.
+/// is a bit tricky in Chess960 where from/to squares can overlap.
 template<bool Do>
 void Position::do_castling(Color us, Square from, Square& to, Square& rfrom, Square& rto) {
   bool kingSide = to > from;
   rfrom = to; // Castling is encoded as "king captures friendly rook"
   rto = relative_square(us, kingSide ? SQ_F1 : SQ_D1);
   to = relative_square(us, kingSide ? SQ_G1 : SQ_C1);
   // Remove both pieces first since squares could overlap in Chess960
-  remove_piece(us, KING, Do ? from : to);
+  remove_piece(make_piece(us, KING), Do ? from : to);
-  remove_piece(us, ROOK, Do ? rfrom : rto);
+  remove_piece(make_piece(us, ROOK), Do ? rfrom : rto);
   board[Do ? from : to] = board[Do ? rfrom : rto] = NO_PIECE; // Since remove_piece doesn't do it for us
-  put_piece(us, KING, Do ? to : from);
+  put_piece(make_piece(us, KING), Do ? to : from);
-  put_piece(us, ROOK, Do ? rto : rfrom);
+  put_piece(make_piece(us, ROOK), Do ? rto : rfrom);
+}
 /// Position::do(undo)_null_move() is used to do(undo) a "null move": It flips
 /// the side to move without executing any move on the board.
   ++st->rule50;
   st->pliesFromNull = 0;
   sideToMove = ~sideToMove;
+  set_check_info(st);
   assert(pos_is_ok());
+}
 void Position::undo_null_move() {
 /// for speculative prefetch. It doesn't recognize special moves like castling,
 /// en-passant and promotions.
 Key Position::key_after(Move m) const {
-  Color us = sideToMove;
   Square from = from_sq(m);
   Square to = to_sq(m);
-  PieceType pt = type_of(piece_on(from));
+  Piece pc = piece_on(from);
-  PieceType captured = type_of(piece_on(to));
+  Piece captured = piece_on(to);
   Key k = st->key ^ Zobrist::side;
   if (captured)
-      k ^= Zobrist::psq[~us][captured][to];
+      k ^= Zobrist::psq[captured][to];
-  return k ^ Zobrist::psq[us][pt][to] ^ Zobrist::psq[us][pt][from];
+  return k ^ Zobrist::psq[pc][to] ^ Zobrist::psq[pc][from];
+}
-/// Position::see() is a static exchange evaluator: It tries to estimate the
+/// 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
-/// material gain or loss resulting from a move.
+/// algorithm similar to alpha-beta pruning with a null window.
-Value Position::see_sign(Move m) const {
+bool Position::see_ge(Move m, Value v) const {
   assert(is_ok(m));
-  // Early return if SEE cannot be negative because captured piece value
+  // Castling moves are implemented as king capturing the rook so cannot be
-  // is not less then capturing one. Note that king moves always return
+  // handled correctly. Simply assume the SEE value is VALUE_ZERO that is always
-  // here because king midgame value is set to 0.
+  // correct unless in the rare case the rook ends up under attack.
-  if (PieceValue[MG][moved_piece(m)] <= PieceValue[MG][piece_on(to_sq(m))])
+  if (type_of(m) == CASTLING)
-      return VALUE_KNOWN_WIN;
+      return VALUE_ZERO >= v;
+  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
-  return see(m);
+  Bitboard occupied, stmAttackers;
-}
+  if (type_of(m) == ENPASSANT)
+  {
+      occupied = SquareBB[to - pawn_push(~stm)]; // Remove the captured pawn
+      balance = PieceValue[MG][PAWN];
+  }
+  else
+  {
-Value Position::see(Move m) const {
+      balance = PieceValue[MG][piece_on(to)];
+      occupied = 0;
+  }
-  Square from, to;
-  Bitboard occupied, attackers, stmAttackers;
-  Value swapList[32];
-  int slIndex = 1;
+  if (balance < v)
-  PieceType captured;
+      return false;
-  Color stm;
+  if (nextVictim == KING)
-  assert(is_ok(m));
+      return true;
-  from = from_sq(m);
-  to = to_sq(m);
-  swapList[0] = PieceValue[MG][piece_on(to)];
+  balance -= PieceValue[MG][nextVictim];
-  stm = color_of(piece_on(from));
-  occupied = pieces() ^ from;
-  // Castling moves are implemented as king capturing the rook so cannot
-  // be handled correctly. Simply return VALUE_ZERO that is always correct
-  // unless in the rare case the rook ends up under attack.
-  if (type_of(m) == CASTLING)
+  if (balance >= v)
-      return VALUE_ZERO;
+      return true;
-  if (type_of(m) == ENPASSANT)
-  {
-      occupied ^= to - pawn_push(stm); // Remove the captured pawn
+  bool relativeStm = true; // True if the opponent is to move
-      swapList[0] = PieceValue[MG][PAWN];
+  occupied ^= pieces() ^ from ^ to;
-  }
-  // Find all attackers to the destination square, with the moving piece
+  // Find all attackers to the destination square, with the moving piece removed,
-  // removed, but possibly an X-ray attacker added behind it.
+  // but possibly an X-ray attacker added behind it.
-  attackers = attackers_to(to, occupied) & occupied;
+  Bitboard attackers = attackers_to(to, occupied) & occupied;
-  // If the opponent has no attackers we are finished
-  stm = ~stm;
+  while (true)
+  {
-  stmAttackers = attackers & pieces(stm);
+      stmAttackers = attackers & pieces(stm);
-  if (!stmAttackers)
-      return swapList[0];
-  // The destination square is defended, which makes things rather more
+      // Don't allow pinned pieces to attack pieces except the king as long all
-  // difficult to compute. We proceed by building up a "swap list" containing
-  // the material gain or loss at each stop in a sequence of captures to the
-  // destination square, where the sides alternately capture, and always
+      // pinners are on their original square.
-  // capture with the least valuable piece. After each capture, we look for
-  // new X-ray attacks from behind the capturing piece.
+      if (!(st->pinnersForKing[stm] & ~occupied))
-  captured = type_of(piece_on(from));
+          stmAttackers &= ~st->blockersForKing[stm];
-  do {
-      assert(slIndex < 32);
+      if (!stmAttackers)
-      // Add the new entry to the swap list
+          return relativeStm;
-      swapList[slIndex] = -swapList[slIndex - 1] + PieceValue[MG][captured];
       // Locate and remove the next least valuable attacker
-      captured = min_attacker<PAWN>(byTypeBB, to, stmAttackers, occupied, attackers);
+      nextVictim = min_attacker<PAWN>(byTypeBB, to, stmAttackers, occupied, attackers);
-      stm = ~stm;
-      stmAttackers = attackers & pieces(stm);
-      ++slIndex;
+      if (nextVictim == KING)
-  } while (stmAttackers && (captured != KING || (--slIndex, false))); // Stop before a king capture
+          return relativeStm == bool(attackers & pieces(~stm));
-  // Having built the swap list, we negamax through it to find the best
+      balance += relativeStm ?  PieceValue[MG][nextVictim]
-  // achievable score from the point of view of the side to move.
+                             : -PieceValue[MG][nextVictim];
-  while (--slIndex)
-      swapList[slIndex - 1] = std::min(-swapList[slIndex], swapList[slIndex - 1]);
+      relativeStm = !relativeStm;
+      if (relativeStm == (balance >= v))
-  return swapList[0];
+          return relativeStm;
+      stm = ~stm;
+  }
+}
 /// Position::is_draw() tests whether the position is drawn by 50-move rule
 /// or by repetition. It does not detect stalemates.
   f += (token == "-" ? token : token.replace(1, 1, token[1] == '3' ? "6" : "3"));
   std::getline(ss, token); // Half and full moves
   f += token;
-  set(f, is_chess960(), this_thread());
+  set(f, is_chess960(), st, this_thread());
   assert(pos_is_ok());
+}
           if (std::memcmp(&si, st, sizeof(StateInfo)))
               return false;
+      }
       if (step == Lists)
-          for (Color c = WHITE; c <= BLACK; ++c)
+          for (Piece pc : Pieces)
-              for (PieceType pt = PAWN; pt <= KING; ++pt)
-              {
+          {
-                  if (pieceCount[c][pt] != popcount<Full>(pieces(c, pt)))
+              if (pieceCount[pc] != popcount(pieces(color_of(pc), type_of(pc))))
-                      return false;
+                  return false;
-                  for (int i = 0; i < pieceCount[c][pt];  ++i)
+              for (int i = 0; i < pieceCount[pc]; ++i)
-                      if (   board[pieceList[c][pt][i]] != make_piece(c, pt)
+                  if (board[pieceList[pc][i]] != pc || index[pieceList[pc][i]] != i)
-                          || index[pieceList[c][pt][i]] != i)
-                          return false;
+                      return false;
-              }
+          }
       if (step == Castling)
           for (Color c = WHITE; c <= BLACK; ++c)
               for (CastlingSide s = KING_SIDE; s <= QUEEN_SIDE; s = CastlingSide(s + 1))
+              {

Subversion Repositories Games.Chess Giants

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