]> git.sesse.net Git - stockfish/blobdiff - src/position.cpp
Convert also undo_null_move() to avoid passing UndoInfo object
[stockfish] / src / position.cpp
index 58884c37f42cb4ee778c9b0a889303b16d6a7b65..c6c315271f1f27a79ccf15ea616564127e6be4fd 100644 (file)
@@ -39,6 +39,8 @@
 //// Variables
 ////
 
+extern SearchStack EmptySearchStack;
+
 int Position::castleRightsMask[64];
 
 Key Position::zobrist[2][8][64];
@@ -50,6 +52,7 @@ Key Position::zobSideToMove;
 Value Position::MgPieceSquareTable[16][64];
 Value Position::EgPieceSquareTable[16][64];
 
+static bool RequestPending = false;
 
 ////
 //// Functions
@@ -57,11 +60,11 @@ Value Position::EgPieceSquareTable[16][64];
 
 /// Constructors
 
-Position::Position(const Position &pos) {
+Position::Position(const Positionpos) {
   copy(pos);
 }
 
-Position::Position(const std::string &fen) {
+Position::Position(const std::stringfen) {
   from_fen(fen);
 }
 
@@ -70,7 +73,7 @@ Position::Position(const std::string &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::from_fen(const std::string &fen) {
+void Position::from_fen(const std::stringfen) {
 
   static const std::string pieceLetters = "KQRBNPkqrbnp";
   static const Piece pieces[] = { WK, WQ, WR, WB, WN, WP, BK, BQ, BR, BB, BN, BP };
@@ -115,7 +118,7 @@ void Position::from_fen(const std::string &fen) {
   }
   sideToMove = (fen[i] == 'w' ? WHITE : BLACK);
 
-  // Castling rights:
+  // Castling rights
   i++;
   if (fen[i] != ' ')
   {
@@ -125,8 +128,10 @@ void Position::from_fen(const std::string &fen) {
 
   i++;
   while(strchr("KQkqabcdefghABCDEFGH-", fen[i])) {
-    if(fen[i] == '-') {
-      i++; break;
+    if (fen[i] == '-')
+    {
+      i++;
+      break;
     }
     else if(fen[i] == 'K') allow_oo(WHITE);
     else if(fen[i] == 'Q') allow_ooo(WHITE);
@@ -205,8 +210,8 @@ void Position::from_fen(const std::string &fen) {
   key = compute_key();
   pawnKey = compute_pawn_key();
   materialKey = compute_material_key();
-  mgValue = compute_mg_value();
-  egValue = compute_eg_value();
+  mgValue = compute_value<MidGame>();
+  egValue = compute_value<EndGame>();
   npMaterial[WHITE] = compute_non_pawn_material(WHITE);
   npMaterial[BLACK] = compute_non_pawn_material(BLACK);
 }
@@ -270,12 +275,18 @@ void Position::print(Move m) const {
 
   static const std::string pieceLetters = " PNBRQK  PNBRQK .";
 
+  // Check for reentrancy, as example when called from inside
+  // MovePicker that is used also here in move_to_san()
+  if (RequestPending)
+      return;
+
+  RequestPending = true;
+
   std::cout << std::endl;
   if (m != MOVE_NONE)
   {
-      Position p(*this);
       std::string col = (color_of_piece_on(move_from(m)) == BLACK ? ".." : "");
-      std::cout << "Move is: " << col << move_to_san(p, m) << std::endl;
+      std::cout << "Move is: " << col << move_to_san(*this, m) << std::endl;
   }
   for (Rank rank = RANK_8; rank >= RANK_1; rank--)
   {
@@ -295,6 +306,8 @@ void Position::print(Move m) const {
   std::cout << "+---+---+---+---+---+---+---+---+" << std::endl
             << "Fen is: " << to_fen() << std::endl
             << "Key is: " << key << std::endl;
+
+  RequestPending = false;
 }
 
 
@@ -310,29 +323,42 @@ void Position::copy(const Position &pos) {
 /// king) pieces for the given color.
 Bitboard Position::pinned_pieces(Color c) const {
 
+  if (pinned[c] != ~EmptyBoardBB)
+      return pinned[c];
+
+  Bitboard p1, p2;
   Square ksq = king_square(c);
-  return hidden_checks<ROOK, true>(c, ksq) | hidden_checks<BISHOP, true>(c, ksq);
+  pinned[c] = hidden_checks<ROOK, true>(c, ksq, p1) | hidden_checks<BISHOP, true>(c, ksq, p2);
+  pinners[c] = p1 | p2;
+  return pinned[c];
 }
 
+Bitboard Position::pinned_pieces(Color c, Bitboard& p) const {
 
-/// Position:discovered_check_candidates() returns a bitboard containing all
-/// pieces for the given side which are candidates for giving a discovered
-/// check.  The code is almost the same as the function for finding pinned
-/// pieces.
+  if (pinned[c] == ~EmptyBoardBB)
+      pinned_pieces(c);
+
+  p = pinners[c];
+  return pinned[c];
+}
 
 Bitboard Position::discovered_check_candidates(Color c) const {
 
+  if (dcCandidates[c] != ~EmptyBoardBB)
+      return dcCandidates[c];
+
+  Bitboard dummy;
   Square ksq = king_square(opposite_color(c));
-  return hidden_checks<ROOK, false>(c, ksq) | hidden_checks<BISHOP, false>(c, ksq);
+  dcCandidates[c] = hidden_checks<ROOK, false>(c, ksq, dummy) | hidden_checks<BISHOP, false>(c, ksq, dummy);
+  return dcCandidates[c];
 }
 
-
 /// Position:hidden_checks<>() returns a bitboard of all pinned (against the
 /// king) pieces for the given color and for the given pinner type. Or, when
 /// template parameter FindPinned is false, the pinned pieces of opposite color
 /// that are, indeed, the pieces candidate for a discovery check.
 template<PieceType Piece, bool FindPinned>
-Bitboard Position::hidden_checks(Color c, Square ksq) const {
+Bitboard Position::hidden_checks(Color c, Square ksq, Bitboard& pinners) const {
 
   Square s;
   Bitboard sliders, result = EmptyBoardBB;
@@ -349,7 +375,7 @@ Bitboard Position::hidden_checks(Color c, Square ksq) const {
 
       // Pinners are sliders, not checkers, that give check when
       // candidate pinned are removed.
-      Bitboard pinners = (FindPinned ? sliders & ~checkersBB : sliders);
+      pinners = (FindPinned ? sliders & ~checkersBB : sliders);
 
       if (Piece == ROOK)
           pinners &= rook_attacks_bb(ksq, occupied_squares() ^ candidate_pinned);
@@ -358,26 +384,17 @@ Bitboard Position::hidden_checks(Color c, Square ksq) const {
 
       // Finally for each pinner find the corresponding pinned piece (if same color of king)
       // or discovery checker (if opposite color) among the candidates.
-      while (pinners)
+      Bitboard p = pinners;
+      while (p)
       {
-          s = pop_1st_bit(&pinners);
+          s = pop_1st_bit(&p);
           result |= (squares_between(s, ksq) & candidate_pinned);
       }
   }
-  return result;
-}
-
-
-/// Position::square_is_attacked() checks whether the given side attacks the
-/// given square.
-
-bool Position::square_is_attacked(Square s, Color c) const {
+  else
+      pinners = EmptyBoardBB;
 
-  return   (pawn_attacks(opposite_color(c), s) & pawns(c))
-        || (piece_attacks<KNIGHT>(s) & knights(c))
-        || (piece_attacks<KING>(s)   & kings(c))
-        || (piece_attacks<ROOK>(s)   & rooks_and_queens(c))
-        || (piece_attacks<BISHOP>(s) & bishops_and_queens(c));
+  return result;
 }
 
 
@@ -396,21 +413,15 @@ Bitboard Position::attacks_to(Square s) const {
         | (piece_attacks<KING>(s)   & pieces_of_type(KING));
 }
 
-Bitboard Position::attacks_to(Square s, Color c) const {
-
-  return attacks_to(s) & pieces_of_color(c);
-}
-
-
 /// Position::piece_attacks_square() tests whether the piece on square f
 /// attacks square t.
 
-bool Position::piece_attacks_square(Square f, Square t) const {
+bool Position::piece_attacks_square(Piece p, Square f, Square t) const {
 
   assert(square_is_ok(f));
   assert(square_is_ok(t));
 
-  switch (piece_on(f))
+  switch (p)
   {
   case WP:          return pawn_attacks_square(WHITE, f, t);
   case BP:          return pawn_attacks_square(BLACK, f, t);
@@ -426,8 +437,7 @@ bool Position::piece_attacks_square(Square f, Square t) const {
 
 
 /// Position::move_attacks_square() tests whether a move from the current
-/// position attacks a given square.  Only attacks by the moving piece are
-/// considered; the function does not handle X-ray attacks.
+/// position attacks a given square.
 
 bool Position::move_attacks_square(Move m, Square s) const {
 
@@ -438,18 +448,20 @@ bool Position::move_attacks_square(Move m, Square s) const {
 
   assert(square_is_occupied(f));
 
-  switch (piece_on(f))
-  {
-  case WP:          return pawn_attacks_square(WHITE, t, s);
-  case BP:          return pawn_attacks_square(BLACK, t, s);
-  case WN: case BN: return piece_attacks_square<KNIGHT>(t, s);
-  case WB: case BB: return piece_attacks_square<BISHOP>(t, s);
-  case WR: case BR: return piece_attacks_square<ROOK>(t, s);
-  case WQ: case BQ: return piece_attacks_square<QUEEN>(t, s);
-  case WK: case BK: return piece_attacks_square<KING>(t, s);
-  default: break;
-  }
-  return false;
+  if (piece_attacks_square(piece_on(f), t, s))
+      return true;
+
+  // Move the piece and scan for X-ray attacks behind it
+  Bitboard occ = occupied_squares();
+  Color us = color_of_piece_on(f);
+  clear_bit(&occ, f);
+  set_bit(&occ, t);
+  Bitboard xray = ( (rook_attacks_bb(s, occ) & rooks_and_queens())
+                   |(bishop_attacks_bb(s, occ) & bishops_and_queens())) & pieces_of_color(us);
+
+  // If we have attacks we need to verify that are caused by our move
+  // and are not already existent ones.
+  return xray && (xray ^ (xray & piece_attacks<QUEEN>(s)));
 }
 
 
@@ -466,22 +478,12 @@ void Position::find_checkers() {
 }
 
 
-/// Position::pl_move_is_legal() tests whether a pseudo-legal move is legal.
-/// There are two versions of this function:  One which takes only a
-/// move as input, and one which takes a move and a bitboard of pinned
-/// pieces. The latter function is faster, and should always be preferred
-/// when a pinned piece bitboard has already been computed.
-
-bool Position::pl_move_is_legal(Move m)  const {
+/// Position::pl_move_is_legal() tests whether a pseudo-legal move is legal
 
-  return pl_move_is_legal(m, pinned_pieces(side_to_move()));
-}
-
-bool Position::pl_move_is_legal(Move m, Bitboard pinned) const {
+bool Position::pl_move_is_legal(Move m) const {
 
   assert(is_ok());
   assert(move_is_ok(m));
-  assert(pinned == pinned_pieces(side_to_move()));
 
   // If we're in check, all pseudo-legal moves are legal, because our
   // check evasion generator only generates true legal moves.
@@ -498,7 +500,7 @@ bool Position::pl_move_is_legal(Move m, Bitboard pinned) const {
   Square ksq = king_square(us);
 
   assert(color_of_piece_on(from) == us);
-  assert(piece_on(ksq) == king_of_color(us));
+  assert(piece_on(ksq) == piece_of_color_and_type(us, KING));
 
   // En passant captures are a tricky special case.  Because they are
   // rather uncommon, we do it simply by testing whether the king is attacked
@@ -510,8 +512,8 @@ bool Position::pl_move_is_legal(Move m, Bitboard pinned) const {
       Bitboard b = occupied_squares();
 
       assert(to == ep_square());
-      assert(piece_on(from) == pawn_of_color(us));
-      assert(piece_on(capsq) == pawn_of_color(them));
+      assert(piece_on(from) == piece_of_color_and_type(us, PAWN));
+      assert(piece_on(capsq) == piece_of_color_and_type(them, PAWN));
       assert(piece_on(to) == EMPTY);
 
       clear_bit(&b, from);
@@ -529,37 +531,27 @@ bool Position::pl_move_is_legal(Move m, Bitboard pinned) const {
 
   // 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 (   !bit_is_set(pinned, from)
+  return (   !bit_is_set(pinned_pieces(us), from)
           || (direction_between_squares(from, ksq) == direction_between_squares(move_to(m), ksq)));
 }
 
 
-/// Position::move_is_check() tests whether a pseudo-legal move is a check.
-/// There are two versions of this function:  One which takes only a move as
-/// input, and one which takes a move and a bitboard of discovered check
-/// candidates.  The latter function is faster, and should always be preferred
-/// when a discovered check candidates bitboard has already been computed.
+/// Position::move_is_check() tests whether a pseudo-legal move is a check
 
 bool Position::move_is_check(Move m) const {
 
-  Bitboard dc = discovered_check_candidates(side_to_move());
-  return move_is_check(m, dc);
-}
-
-bool Position::move_is_check(Move m, Bitboard dcCandidates) const {
-
   assert(is_ok());
   assert(move_is_ok(m));
-  assert(dcCandidates == discovered_check_candidates(side_to_move()));
 
   Color us = side_to_move();
   Color them = opposite_color(us);
   Square from = move_from(m);
   Square to = move_to(m);
   Square ksq = king_square(them);
+  Bitboard dcCandidates = discovered_check_candidates(us);
 
   assert(color_of_piece_on(from) == us);
-  assert(piece_on(ksq) == king_of_color(them));
+  assert(piece_on(ksq) == piece_of_color_and_type(them, KING));
 
   // Proceed according to the type of the moving piece
   switch (type_of_piece_on(from))
@@ -664,80 +656,57 @@ bool Position::move_is_check(Move m, Bitboard dcCandidates) const {
 
 
 /// Position::move_is_capture() tests whether a move from the current
-/// position is a capture.
+/// position is a capture. Move must not be MOVE_NONE.
 
 bool Position::move_is_capture(Move m) const {
 
+  assert(m != MOVE_NONE);
+
   return (   !square_is_empty(move_to(m))
-          && (color_of_piece_on(move_to(m)) == opposite_color(side_to_move()))
+          && (color_of_piece_on(move_to(m)) != color_of_piece_on(move_from(m)))
          )
          || move_is_ep(m);
 }
 
 
-/// Position::backup() is called when making a move. All information
-/// necessary to restore the position when the move is later unmade
-/// is saved to an UndoInfo object. The function Position::restore
-/// does the reverse operation:  When one does a backup followed by
-/// a restore with the same UndoInfo object, the position is restored
-/// to the state before backup was called.
-
-void Position::backup(UndoInfo& u) const {
-
-  u.castleRights = castleRights;
-  u.epSquare     = epSquare;
-  u.checkersBB   = checkersBB;
-  u.key          = key;
-  u.pawnKey      = pawnKey;
-  u.materialKey  = materialKey;
-  u.rule50       = rule50;
-  u.lastMove     = lastMove;
-  u.mgValue      = mgValue;
-  u.egValue      = egValue;
-  u.capture      = NO_PIECE_TYPE;
-}
+/// Position::update_checkers() is a private method to udpate chekers info
 
+template<PieceType Piece>
+inline void Position::update_checkers(Bitboard* pCheckersBB, Square ksq, Square from,
+                                      Square to, Bitboard dcCandidates) {
 
-/// Position::restore() is called when unmaking a move.  It copies back
-/// the information backed up during a previous call to Position::backup.
+  if (Piece != KING && bit_is_set(piece_attacks<Piece>(ksq), to))
+      set_bit(pCheckersBB, to);
 
-void Position::restore(const UndoInfo& u) {
+  if (Piece != QUEEN && bit_is_set(dcCandidates, from))
+  {
+      if (Piece != ROOK)
+          (*pCheckersBB) |= (piece_attacks<ROOK>(ksq) & rooks_and_queens(side_to_move()));
 
-  castleRights = u.castleRights;
-  epSquare     = u.epSquare;
-  checkersBB   = u.checkersBB;
-  key          = u.key;
-  pawnKey      = u.pawnKey;
-  materialKey  = u.materialKey;
-  rule50       = u.rule50;
-  lastMove     = u.lastMove;
-  mgValue     = u.mgValue;
-  egValue     = u.egValue;
-  // u.capture is restored in undo_move()
+      if (Piece != BISHOP)
+          (*pCheckersBB) |= (piece_attacks<BISHOP>(ksq) & bishops_and_queens(side_to_move()));
+  }
 }
 
+
 /// Position::do_move() makes a move, and backs up all information necessary
 /// to undo the move to an UndoInfo object. The move is assumed to be legal.
 /// Pseudo-legal moves should be filtered out before this function is called.
-/// There are two versions of this function, one which takes only the move and
-/// the UndoInfo as input, and one which takes a third parameter, a bitboard of
-/// discovered check candidates. The second version is faster, because knowing
-/// the discovered check candidates makes it easier to update the checkersBB
-/// member variable in the position object.
 
 void Position::do_move(Move m, UndoInfo& u) {
 
-  do_move(m, u, discovered_check_candidates(side_to_move()));
-}
-
-void Position::do_move(Move m, UndoInfo& u, Bitboard dcCandidates) {
-
   assert(is_ok());
   assert(move_is_ok(m));
 
+  // Get now the current (pre-move) dc candidates that we will use
+  // in update_checkers().
+  Bitboard oldDcCandidates = discovered_check_candidates(side_to_move());
+
   // Back up the necessary information to our UndoInfo object (except the
   // captured piece, which is taken care of later.
-  backup(u);
+  u = undoInfoUnion;
+  u.capture = NO_PIECE_TYPE;
+  previous = &u;
 
   // Save the current key to the history[] array, in order to be able to
   // detect repetition draws.
@@ -747,10 +716,14 @@ void Position::do_move(Move m, UndoInfo& u, Bitboard dcCandidates) {
   // case of non-reversible moves is taken care of later.
   rule50++;
 
+  // Reset pinned bitboard and its friends
+  for (Color c = WHITE; c <= BLACK; c++)
+      pinners[c] = pinned[c] = dcCandidates[c] = ~EmptyBoardBB;
+
   if (move_is_castle(m))
       do_castle_move(m);
   else if (move_promotion(m))
-      do_promotion_move(m, u);
+      do_promotion_move(m);
   else if (move_is_ep(m))
       do_ep_move(m);
   else
@@ -786,42 +759,43 @@ void Position::do_move(Move m, UndoInfo& u, Bitboard dcCandidates) {
     key ^= zobrist[us][piece][from] ^ zobrist[us][piece][to];
 
     // Update incremental scores
-    mgValue -= mg_pst(us, piece, from);
-    mgValue += mg_pst(us, piece, to);
-    egValue -= eg_pst(us, piece, from);
-    egValue += eg_pst(us, piece, to);
+    mgValue -= pst<MidGame>(us, piece, from);
+    mgValue += pst<MidGame>(us, piece, to);
+    egValue -= pst<EndGame>(us, piece, from);
+    egValue += pst<EndGame>(us, piece, to);
 
     // If the moving piece was a king, update the king square
     if (piece == KING)
         kingSquare[us] = to;
 
-    // If the move was a double pawn push, set the en passant square.
-    // This code is a bit ugly right now, and should be cleaned up later.
-    // FIXME
+    // Reset en passant square
     if (epSquare != SQ_NONE)
     {
         key ^= zobEp[epSquare];
         epSquare = SQ_NONE;
     }
+
+    // If the moving piece was a pawn do some special extra work
     if (piece == PAWN)
     {
+        // Reset rule 50 draw counter
+        rule50 = 0;
+
+        // Update pawn hash key
+        pawnKey ^= zobrist[us][PAWN][from] ^ zobrist[us][PAWN][to];
+
+        // Set en passant square, only if moved pawn can be captured
         if (abs(int(to) - int(from)) == 16)
         {
-            if(   (   us == WHITE
-                   && (pawn_attacks(WHITE, from + DELTA_N) & pawns(BLACK)))
-               || (   us == BLACK
-                   && (pawn_attacks(BLACK, from + DELTA_S) & pawns(WHITE))))
+            if (   (us == WHITE && (pawn_attacks(WHITE, from + DELTA_N) & pawns(BLACK)))
+                || (us == BLACK && (pawn_attacks(BLACK, from + DELTA_S) & pawns(WHITE))))
             {
                 epSquare = Square((int(from) + int(to)) / 2);
                 key ^= zobEp[epSquare];
             }
         }
-        // Reset rule 50 draw counter
-        rule50 = 0;
-
-        // Update pawn hash key
-        pawnKey ^= zobrist[us][PAWN][from] ^ zobrist[us][PAWN][to];
     }
+
     // Update piece lists
     pieceList[us][piece][index[from]] = to;
     index[to] = index[from];
@@ -832,59 +806,18 @@ void Position::do_move(Move m, UndoInfo& u, Bitboard dcCandidates) {
     castleRights &= castleRightsMask[to];
     key ^= zobCastle[castleRights];
 
-    // Update checkers bitboard
+    // Update checkers bitboard, piece must be already moved
     checkersBB = EmptyBoardBB;
     Square ksq = king_square(them);
     switch (piece)
     {
-    case PAWN:
-        if (bit_is_set(pawn_attacks(them, ksq), to))
-            set_bit(&checkersBB, to);
-
-        if (bit_is_set(dcCandidates, from))
-            checkersBB |= ( (piece_attacks<ROOK>(ksq) & rooks_and_queens(us))
-                           |(piece_attacks<BISHOP>(ksq) & bishops_and_queens(us)));
-        break;
-
-    case KNIGHT:
-        if (bit_is_set(piece_attacks<KNIGHT>(ksq), to))
-            set_bit(&checkersBB, to);
-
-        if (bit_is_set(dcCandidates, from))
-            checkersBB |= ( (piece_attacks<ROOK>(ksq) & rooks_and_queens(us))
-                           |(piece_attacks<BISHOP>(ksq) & bishops_and_queens(us)));
-        break;
-
-    case BISHOP:
-        if  (bit_is_set(piece_attacks<BISHOP>(ksq), to))
-            set_bit(&checkersBB, to);
-
-        if (bit_is_set(dcCandidates, from))
-            checkersBB |= (piece_attacks<ROOK>(ksq) & rooks_and_queens(us));
-        break;
-
-    case ROOK:
-        if (bit_is_set(piece_attacks<ROOK>(ksq), to))
-            set_bit(&checkersBB, to);
-
-        if (bit_is_set(dcCandidates, from))
-            checkersBB |= (piece_attacks<BISHOP>(ksq) & bishops_and_queens(us));
-        break;
-
-    case QUEEN:
-        if (bit_is_set(piece_attacks<QUEEN>(ksq), to))
-            set_bit(&checkersBB, to);
-        break;
-
-    case KING:
-        if (bit_is_set(dcCandidates, from))
-            checkersBB |= ( (piece_attacks<ROOK>(ksq) & rooks_and_queens(us))
-                           |(piece_attacks<BISHOP>(ksq) & bishops_and_queens(us)));
-        break;
-
-    default:
-      assert(false);
-      break;
+    case PAWN:   update_checkers<PAWN>(&checkersBB, ksq, from, to, oldDcCandidates);   break;
+    case KNIGHT: update_checkers<KNIGHT>(&checkersBB, ksq, from, to, oldDcCandidates); break;
+    case BISHOP: update_checkers<BISHOP>(&checkersBB, ksq, from, to, oldDcCandidates); break;
+    case ROOK:   update_checkers<ROOK>(&checkersBB, ksq, from, to, oldDcCandidates);   break;
+    case QUEEN:  update_checkers<QUEEN>(&checkersBB, ksq, from, to, oldDcCandidates);  break;
+    case KING:   update_checkers<KING>(&checkersBB, ksq, from, to, oldDcCandidates);   break;
+    default: assert(false); break;
     }
   }
 
@@ -919,8 +852,8 @@ void Position::do_capture_move(Move m, PieceType capture, Color them, Square to)
         pawnKey ^= zobrist[them][PAWN][to];
 
     // Update incremental scores
-    mgValue -= mg_pst(them, capture, to);
-    egValue -= eg_pst(them, capture, to);
+    mgValue -= pst<MidGame>(them, capture, to);
+    egValue -= pst<EndGame>(them, capture, to);
 
     assert(!move_promotion(m) || capture != PAWN);
 
@@ -962,8 +895,8 @@ void Position::do_castle_move(Move m) {
   Square rfrom = move_to(m);  // HACK: See comment at beginning of function
   Square kto, rto;
 
-  assert(piece_on(kfrom) == king_of_color(us));
-  assert(piece_on(rfrom) == rook_of_color(us));
+  assert(piece_on(kfrom) == piece_of_color_and_type(us, KING));
+  assert(piece_on(rfrom) == piece_of_color_and_type(us, ROOK));
 
   // Find destination squares for king and rook
   if (rfrom > kfrom) // O-O
@@ -993,8 +926,8 @@ void Position::do_castle_move(Move m) {
 
   // Update board array
   board[kfrom] = board[rfrom] = EMPTY;
-  board[kto] = king_of_color(us);
-  board[rto] = rook_of_color(us);
+  board[kto] = piece_of_color_and_type(us, KING);
+  board[rto] = piece_of_color_and_type(us, ROOK);
 
   // Update king square
   kingSquare[us] = kto;
@@ -1007,21 +940,21 @@ void Position::do_castle_move(Move m) {
   index[rto] = tmp;
 
   // Update incremental scores
-  mgValue -= mg_pst(us, KING, kfrom);
-  mgValue += mg_pst(us, KING, kto);
-  egValue -= eg_pst(us, KING, kfrom);
-  egValue += eg_pst(us, KING, kto);
-  mgValue -= mg_pst(us, ROOK, rfrom);
-  mgValue += mg_pst(us, ROOK, rto);
-  egValue -= eg_pst(us, ROOK, rfrom);
-  egValue += eg_pst(us, ROOK, rto);
+  mgValue -= pst<MidGame>(us, KING, kfrom);
+  mgValue += pst<MidGame>(us, KING, kto);
+  egValue -= pst<EndGame>(us, KING, kfrom);
+  egValue += pst<EndGame>(us, KING, kto);
+  mgValue -= pst<MidGame>(us, ROOK, rfrom);
+  mgValue += pst<MidGame>(us, ROOK, rto);
+  egValue -= pst<EndGame>(us, ROOK, rfrom);
+  egValue += pst<EndGame>(us, ROOK, rto);
 
   // Update hash key
   key ^= zobrist[us][KING][kfrom] ^ zobrist[us][KING][kto];
   key ^= zobrist[us][ROOK][rfrom] ^ zobrist[us][ROOK][rto];
 
   // Clear en passant square
-  if(epSquare != SQ_NONE)
+  if (epSquare != SQ_NONE)
   {
       key ^= zobEp[epSquare];
       epSquare = SQ_NONE;
@@ -1045,7 +978,7 @@ void Position::do_castle_move(Move m) {
 /// UndoInfo object, which has been initialized in Position::do_move, is
 /// used to store the captured piece (if any).
 
-void Position::do_promotion_move(Move m, UndoInfo &u) {
+void Position::do_promotion_move(Move m) {
 
   Color us, them;
   Square from, to;
@@ -1061,14 +994,14 @@ void Position::do_promotion_move(Move m, UndoInfo &u) {
   to = move_to(m);
 
   assert(relative_rank(us, to) == RANK_8);
-  assert(piece_on(from) == pawn_of_color(us));
+  assert(piece_on(from) == piece_of_color_and_type(us, PAWN));
   assert(color_of_piece_on(to) == them || square_is_empty(to));
 
   capture = type_of_piece_on(to);
 
   if (capture)
   {
-    u.capture = capture;
+    previous->capture = capture;
     do_capture_move(m, capture, them, to);
   }
 
@@ -1107,10 +1040,10 @@ void Position::do_promotion_move(Move m, UndoInfo &u) {
   index[to] = pieceCount[us][promotion] - 1;
 
   // Update incremental scores
-  mgValue -= mg_pst(us, PAWN, from);
-  mgValue += mg_pst(us, promotion, to);
-  egValue -= eg_pst(us, PAWN, from);
-  egValue += eg_pst(us, promotion, to);
+  mgValue -= pst<MidGame>(us, PAWN, from);
+  mgValue += pst<MidGame>(us, promotion, to);
+  egValue -= pst<EndGame>(us, PAWN, from);
+  egValue += pst<EndGame>(us, promotion, to);
 
   // Update material
   npMaterial[us] += piece_value_midgame(promotion);
@@ -1158,8 +1091,8 @@ void Position::do_ep_move(Move m) {
   assert(to == epSquare);
   assert(relative_rank(us, to) == RANK_6);
   assert(piece_on(to) == EMPTY);
-  assert(piece_on(from) == pawn_of_color(us));
-  assert(piece_on(capsq) == pawn_of_color(them));
+  assert(piece_on(from) == piece_of_color_and_type(us, PAWN));
+  assert(piece_on(capsq) == piece_of_color_and_type(them, PAWN));
 
   // Remove captured piece
   clear_bit(&(byColorBB[them]), capsq);
@@ -1201,12 +1134,12 @@ void Position::do_ep_move(Move m) {
   pawnKey ^= zobrist[them][PAWN][capsq];
 
   // Update incremental scores
-  mgValue -= mg_pst(them, PAWN, capsq);
-  mgValue -= mg_pst(us, PAWN, from);
-  mgValue += mg_pst(us, PAWN, to);
-  egValue -= eg_pst(them, PAWN, capsq);
-  egValue -= eg_pst(us, PAWN, from);
-  egValue += eg_pst(us, PAWN, to);
+  mgValue -= pst<MidGame>(them, PAWN, capsq);
+  mgValue -= pst<MidGame>(us, PAWN, from);
+  mgValue += pst<MidGame>(us, PAWN, to);
+  egValue -= pst<EndGame>(them, PAWN, capsq);
+  egValue -= pst<EndGame>(us, PAWN, from);
+  egValue += pst<EndGame>(us, PAWN, to);
 
   // Reset en passant square
   epSquare = SQ_NONE;
@@ -1219,12 +1152,12 @@ void Position::do_ep_move(Move m) {
 }
 
 
-/// Position::undo_move() unmakes a move.  When it returns, the position should
-/// be restored to exactly the same state as before the move was made.  It is
+/// Position::undo_move() unmakes a move. When it returns, the position should
+/// be restored to exactly the same state as before the move was made. It is
 /// important that Position::undo_move is called with the same move and UndoInfo
 /// object as the earlier call to Position::do_move.
 
-void Position::undo_move(Move m, const UndoInfo &u) {
+void Position::undo_move(Move m) {
 
   assert(is_ok());
   assert(move_is_ok(m));
@@ -1234,19 +1167,19 @@ void Position::undo_move(Move m, const UndoInfo &u) {
 
   // Restore information from our UndoInfo object (except the captured piece,
   // which is taken care of later)
-  restore(u);
+  undoInfoUnion = *previous;
 
   if (move_is_castle(m))
       undo_castle_move(m);
   else if (move_promotion(m))
-      undo_promotion_move(m, u);
+      undo_promotion_move(m);
   else if (move_is_ep(m))
       undo_ep_move(m);
   else
   {
       Color us, them;
       Square from, to;
-      PieceType piece, capture;
+      PieceType piece;
 
       us = side_to_move();
       them = opposite_color(us);
@@ -1276,8 +1209,6 @@ void Position::undo_move(Move m, const UndoInfo &u) {
       pieceList[us][piece][index[to]] = from;
       index[from] = index[to];
 
-      capture = u.capture;
-
       if (capture)
       {
           assert(capture != KING);
@@ -1336,8 +1267,8 @@ void Position::undo_castle_move(Move m) {
       rto = relative_square(us, SQ_D1);
   }
 
-  assert(piece_on(kto) == king_of_color(us));
-  assert(piece_on(rto) == rook_of_color(us));
+  assert(piece_on(kto) == piece_of_color_and_type(us, KING));
+  assert(piece_on(rto) == piece_of_color_and_type(us, ROOK));
 
   // Remove pieces from destination squares
   clear_bit(&(byColorBB[us]), kto);
@@ -1357,8 +1288,8 @@ void Position::undo_castle_move(Move m) {
 
   // Update board
   board[rto] = board[kto] = EMPTY;
-  board[rfrom] = rook_of_color(us);
-  board[kfrom] = king_of_color(us);
+  board[rfrom] = piece_of_color_and_type(us, ROOK);
+  board[kfrom] = piece_of_color_and_type(us, KING);
 
   // Update king square
   kingSquare[us] = kfrom;
@@ -1377,11 +1308,11 @@ void Position::undo_castle_move(Move m) {
 /// function. The UndoInfo object, which has been initialized in
 /// Position::do_move, is used to put back the captured piece (if any).
 
-void Position::undo_promotion_move(Move m, const UndoInfo &u) {
+void Position::undo_promotion_move(Move m) {
 
   Color us, them;
   Square from, to;
-  PieceType capture, promotion;
+  PieceType promotion;
 
   assert(move_is_ok(m));
   assert(move_promotion(m));
@@ -1409,7 +1340,7 @@ void Position::undo_promotion_move(Move m, const UndoInfo &u) {
   set_bit(&(byColorBB[us]), from);
   set_bit(&(byTypeBB[PAWN]), from);
   set_bit(&(byTypeBB[0]), from); // HACK: byTypeBB[0] == occupied squares
-  board[from] = pawn_of_color(us);
+  board[from] = piece_of_color_and_type(us, PAWN);
 
   // Update material
   npMaterial[us] -= piece_value_midgame(promotion);
@@ -1425,8 +1356,6 @@ void Position::undo_promotion_move(Move m, const UndoInfo &u) {
   pieceCount[us][promotion]--;
   pieceCount[us][PAWN]++;
 
-  capture = u.capture;
-
   if (capture)
   {
       assert(capture != KING);
@@ -1474,7 +1403,7 @@ void Position::undo_ep_move(Move m) {
 
   assert(to == ep_square());
   assert(relative_rank(us, to) == RANK_6);
-  assert(piece_on(to) == pawn_of_color(us));
+  assert(piece_on(to) == piece_of_color_and_type(us, PAWN));
   assert(piece_on(from) == EMPTY);
   assert(piece_on(capsq) == EMPTY);
 
@@ -1482,7 +1411,7 @@ void Position::undo_ep_move(Move m) {
   set_bit(&(byColorBB[them]), capsq);
   set_bit(&(byTypeBB[PAWN]), capsq);
   set_bit(&(byTypeBB[0]), capsq);
-  board[capsq] = pawn_of_color(them);
+  board[capsq] = piece_of_color_and_type(them, PAWN);
 
   // Remove moving piece from destination square
   clear_bit(&(byColorBB[us]), to);
@@ -1494,7 +1423,7 @@ void Position::undo_ep_move(Move m) {
   set_bit(&(byColorBB[us]), from);
   set_bit(&(byTypeBB[PAWN]), from);
   set_bit(&(byTypeBB[0]), from);
-  board[from] = pawn_of_color(us);
+  board[from] = piece_of_color_and_type(us, PAWN);
 
   // Update piece list:
   pieceList[us][PAWN][index[to]] = from;
@@ -1510,16 +1439,18 @@ void Position::undo_ep_move(Move m) {
 /// Position::do_null_move makes() a "null move": It switches the side to move
 /// and updates the hash key without executing any move on the board.
 
-void Position::do_null_move(UndoInfo &u) {
+void Position::do_null_move(UndoInfou) {
 
   assert(is_ok());
   assert(!is_check());
 
   // Back up the information necessary to undo the null move to the supplied
-  // UndoInfo object.  In the case of a null move, the only thing we need to
+  // UndoInfo object. In the case of a null move, the only thing we need to
   // remember is the last move made and the en passant square.
   u.lastMove = lastMove;
   u.epSquare = epSquare;
+  u.previous = previous;
+  previous = &u;
 
   // Save the current key to the history[] array, in order to be able to
   // detect repetition draws.
@@ -1544,18 +1475,20 @@ void Position::do_null_move(UndoInfo &u) {
 
 /// Position::undo_null_move() unmakes a "null move".
 
-void Position::undo_null_move(const UndoInfo &u) {
+void Position::undo_null_move() {
 
   assert(is_ok());
   assert(!is_check());
 
-  // Restore information from the supplied UndoInfo object:
-  lastMove = u.lastMove;
-  epSquare = u.epSquare;
+  // Restore information from the our UndoInfo object
+  lastMove = previous->lastMove;
+  epSquare = previous->epSquare;
+  previous = previous->previous;
+
   if (epSquare != SQ_NONE)
       key ^= zobEp[epSquare];
 
-  // Update the necessary information.
+  // Update the necessary information
   sideToMove = opposite_color(sideToMove);
   rule50--;
   gamePly--;
@@ -1568,11 +1501,17 @@ void Position::undo_null_move(const UndoInfo &u) {
 }
 
 
-/// Position::see() is a static exchange evaluator:  It tries to estimate the
-/// material gain or loss resulting from a move.  There are two versions of
-/// this function: One which takes a move as input, and one which takes a
-/// 'from' and a 'to' square.  The function does not yet understand promotions
-/// or en passant captures.
+/// Position::see() is a static exchange evaluator: It tries to estimate the
+/// material gain or loss resulting from a move.  There are three versions of
+/// this function: One which takes a destination square as input, one takes a
+/// move, and one which takes a 'from' and a 'to' square. The function does
+/// not yet understand promotions captures.
+
+int Position::see(Square to) const {
+
+  assert(square_is_ok(to));
+  return see(SQ_NONE, to);
+}
 
 int Position::see(Move m) const {
 
@@ -1582,18 +1521,22 @@ int Position::see(Move m) const {
 
 int Position::see(Square from, Square to) const {
 
-  // Approximate material values, with pawn = 1
+  // Material values
   static const int seeValues[18] = {
-    0, 1, 3, 3, 5, 10, 100, 0, 0, 1, 3, 3, 5, 10, 100, 0, 0, 0
+    0, PawnValueMidgame, KnightValueMidgame, BishopValueMidgame,
+       RookValueMidgame, QueenValueMidgame, QueenValueMidgame*10, 0,
+    0, PawnValueMidgame, KnightValueMidgame, BishopValueMidgame,
+       RookValueMidgame, QueenValueMidgame, QueenValueMidgame*10, 0,
+    0, 0
   };
 
   Bitboard attackers, occ, b;
 
-  assert(square_is_ok(from));
+  assert(square_is_ok(from) || from == SQ_NONE);
   assert(square_is_ok(to));
 
   // Initialize colors
-  Color us = color_of_piece_on(from);
+  Color us = (from != SQ_NONE ? color_of_piece_on(from) : opposite_color(color_of_piece_on(to)));
   Color them = opposite_color(us);
 
   // Initialize pieces
@@ -1603,15 +1546,49 @@ int Position::see(Square from, Square to) const {
   // Find all attackers to the destination square, with the moving piece
   // removed, but possibly an X-ray attacker added behind it.
   occ = occupied_squares();
-  clear_bit(&occ, from);
-  attackers =  (rook_attacks_bb(to, occ)   & rooks_and_queens())
-             | (bishop_attacks_bb(to, occ) & bishops_and_queens())
-             | (piece_attacks<KNIGHT>(to)  & knights())
-             | (piece_attacks<KING>(to)    & kings())
-             | (pawn_attacks(WHITE, to)    & pawns(BLACK))
-             | (pawn_attacks(BLACK, to)    & pawns(WHITE));
-
-  // If the opponent has no attackers, we are finished
+
+  // Handle en passant moves
+  if (epSquare == to && type_of_piece_on(from) == PAWN)
+  {
+      assert(capture == EMPTY);
+
+      Square capQq = (side_to_move() == WHITE)? (to - DELTA_N) : (to - DELTA_S);
+      capture = piece_on(capQq);
+
+      assert(type_of_piece_on(capQq) == PAWN);
+
+      // Remove the captured pawn
+      clear_bit(&occ, capQq);
+  }
+
+  while (true)
+  {
+      clear_bit(&occ, from);
+      attackers =  (rook_attacks_bb(to, occ)   & rooks_and_queens())
+                 | (bishop_attacks_bb(to, occ) & bishops_and_queens())
+                 | (piece_attacks<KNIGHT>(to)  & knights())
+                 | (piece_attacks<KING>(to)    & kings())
+                 | (pawn_attacks(WHITE, to)    & pawns(BLACK))
+                 | (pawn_attacks(BLACK, to)    & pawns(WHITE));
+
+      if (from != SQ_NONE)
+          break;
+
+      // If we don't have any attacker we are finished
+      if ((attackers & pieces_of_color(us)) == EmptyBoardBB)
+          return 0;
+
+      // Locate the least valuable attacker to the destination square
+      // and use it to initialize from square.
+      PieceType pt;
+      for (pt = PAWN; !(attackers & pieces_of_color_and_type(us, pt)); pt++)
+          assert(pt < KING);
+
+      from = first_1(attackers & pieces_of_color_and_type(us, pt));
+      piece = piece_on(from);
+  }
+
+  // If the opponent has no attackers we are finished
   if ((attackers & pieces_of_color(them)) == EmptyBoardBB)
       return seeValues[capture];
 
@@ -1697,6 +1674,8 @@ void Position::clear() {
   }
 
   checkersBB = EmptyBoardBB;
+  for (Color c = WHITE; c <= BLACK; c++)
+      pinners[c] = pinned[c] = dcCandidates[c] = ~EmptyBoardBB;
 
   lastMove = MOVE_NONE;
 
@@ -1708,10 +1687,11 @@ void Position::clear() {
   epSquare = SQ_NONE;
   rule50 = 0;
   gamePly = 0;
+  previous = NULL;
 }
 
 
-/// Position::reset_game_ply() simply sets gamePly to 0.  It is used from the
+/// Position::reset_game_ply() simply sets gamePly to 0. It is used from the
 /// UCI interface code, whenever a non-reversible move is made in a
 /// 'position fen <fen> moves m1 m2 ...' command.  This makes it possible
 /// for the program to handle games of arbitrary length, as long as the GUI
@@ -1788,7 +1768,7 @@ Key Position::compute_key() const {
 }
 
 
-/// Position::compute_pawn_key() computes the hash key of the position.  The
+/// Position::compute_pawn_key() computes the hash key of the position. The
 /// hash key is usually updated incrementally as moves are made and unmade,
 /// the compute_pawn_key() function is only used when a new position is set
 /// up, and to verify the correctness of the pawn hash key when running in
@@ -1833,13 +1813,12 @@ Key Position::compute_material_key() const {
 }
 
 
-/// Position::compute_mg_value() and Position::compute_eg_value() compute the
-/// incremental scores for the middle game and the endgame.  These functions
-/// are used to initialize the incremental scores when a new position is set
-/// up, and to verify that the scores are correctly updated by do_move
-/// and undo_move when the program is running in debug mode.
-
-Value Position::compute_mg_value() const {
+/// Position::compute_value() compute the incremental scores for the middle
+/// game and the endgame. These functions are used to initialize the incremental
+/// scores when a new position is set up, and to verify that the scores are correctly
+/// updated by do_move and undo_move when the program is running in debug mode.
+template<Position::GamePhase Phase>
+Value Position::compute_value() const {
 
   Value result = Value(0);
   Bitboard b;
@@ -1853,37 +1832,18 @@ Value Position::compute_mg_value() const {
           {
               s = pop_1st_bit(&b);
               assert(piece_on(s) == piece_of_color_and_type(c, pt));
-              result += mg_pst(c, pt, s);
+              result += pst<Phase>(c, pt, s);
           }
       }
-  result += (side_to_move() == WHITE)? TempoValueMidgame / 2 : -TempoValueMidgame / 2;
-  return result;
-}
-
-Value Position::compute_eg_value() const {
-
-  Value result = Value(0);
-  Bitboard b;
-  Square s;
 
-  for (Color c = WHITE; c <= BLACK; c++)
-    for (PieceType pt = PAWN; pt <= KING; pt++)
-    {
-        b = pieces_of_color_and_type(c, pt);
-        while(b)
-        {
-            s = pop_1st_bit(&b);
-            assert(piece_on(s) == piece_of_color_and_type(c, pt));
-            result += eg_pst(c, pt, s);
-        }
-    }
-  result += (side_to_move() == WHITE)? TempoValueEndgame / 2 : -TempoValueEndgame / 2;
+  const Value TempoValue = (Phase == MidGame ? TempoValueMidgame : TempoValueEndgame);
+  result += (side_to_move() == WHITE)? TempoValue / 2 : -TempoValue / 2;
   return result;
 }
 
 
 /// Position::compute_non_pawn_material() computes the total non-pawn middle
-/// game material score for the given side.  Material scores are updated
+/// game material score for the given side. Material scores are updated
 /// incrementally during the search, this function is only used while
 /// initializing a new Position object.
 
@@ -1910,7 +1870,7 @@ Value Position::compute_non_pawn_material(Color c) const {
 /// side to move is checkmated. Note that this function is currently very
 /// slow, and shouldn't be used frequently inside the search.
 
-bool Position::is_mate() {
+bool Position::is_mate() const {
 
   if (is_check())
   {
@@ -1922,7 +1882,7 @@ bool Position::is_mate() {
 
 
 /// Position::is_draw() tests whether the position is drawn by material,
-/// repetition, or the 50 moves rule.  It does not detect stalemates, this
+/// repetition, or the 50 moves rule. It does not detect stalemates, this
 /// must be done by the search.
 
 bool Position::is_draw() const {
@@ -1981,12 +1941,12 @@ bool Position::has_mate_threat(Color c) {
       if (is_mate())
           result = true;
 
-      undo_move(mlist[i].move, u2);
+      undo_move(mlist[i].move);
   }
 
   // Undo null move, if necessary
   if (c != stm)
-      undo_null_move(u1);
+      undo_null_move();
 
   return result;
 }
@@ -2048,7 +2008,7 @@ void Position::init_piece_square_tables() {
 
 
 /// Position::flipped_copy() makes a copy of the input position, but with
-/// the white and black sides reversed.  This is only useful for debugging,
+/// the white and black sides reversed. This is only useful for debugging,
 /// especially for finding evaluation symmetry bugs.
 
 void Position::flipped_copy(const Position &pos) {
@@ -2098,8 +2058,8 @@ void Position::flipped_copy(const Position &pos) {
   materialKey = compute_material_key();
 
   // Incremental scores
-  mgValue = compute_mg_value();
-  egValue = compute_eg_value();
+  mgValue = compute_value<MidGame>();
+  egValue = compute_value<EndGame>();
 
   // Material
   npMaterial[WHITE] = compute_non_pawn_material(WHITE);
@@ -2159,7 +2119,7 @@ bool Position::is_ok(int* failedStep) const {
           if (type_of_piece_on(s) == KING)
               kingCount[color_of_piece_on(s)]++;
 
-      if(kingCount[0] != 1 || kingCount[1] != 1)
+      if (kingCount[0] != 1 || kingCount[1] != 1)
           return false;
   }
 
@@ -2228,10 +2188,10 @@ bool Position::is_ok(int* failedStep) const {
   if (failedStep) (*failedStep)++;
   if (debugIncrementalEval)
   {
-      if (mgValue != compute_mg_value())
+      if (mgValue != compute_value<MidGame>())
           return false;
 
-      if (egValue != compute_eg_value())
+      if (egValue != compute_value<EndGame>())
           return false;
   }
 
@@ -2239,10 +2199,10 @@ bool Position::is_ok(int* failedStep) const {
   if (failedStep) (*failedStep)++;
   if (debugNonPawnMaterial)
   {
-      if(npMaterial[WHITE] != compute_non_pawn_material(WHITE))
+      if (npMaterial[WHITE] != compute_non_pawn_material(WHITE))
           return false;
 
-      if(npMaterial[BLACK] != compute_non_pawn_material(BLACK))
+      if (npMaterial[BLACK] != compute_non_pawn_material(BLACK))
           return false;
   }