along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
+#include <algorithm>
#include <cassert>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <sstream>
-#include <algorithm>
#include "bitcount.h"
#include "movegen.h"
else if ((p = PieceToChar.find(token)) != string::npos)
{
- put_piece(Piece(p), sq);
+ put_piece(sq, color_of(Piece(p)), type_of(Piece(p)));
sq++;
}
}
else
st->npMaterial[them] -= PieceValue[MG][capture];
- // Remove the captured piece
- byTypeBB[ALL_PIECES] ^= capsq;
- byTypeBB[capture] ^= capsq;
- byColorBB[them] ^= capsq;
-
- // Update piece list, move the last piece at index[capsq] position and
- // shrink the list.
- //
- // WARNING: This is a not reversible operation. When we will reinsert the
- // captured piece in undo_move() we will put it at the end of the list and
- // not in its original place, it means index[] and pieceList[] are not
- // guaranteed to be invariant to a do_move() + undo_move() sequence.
- Square lastSquare = pieceList[them][capture][--pieceCount[them][capture]];
- index[lastSquare] = index[capsq];
- pieceList[them][capture][index[lastSquare]] = lastSquare;
- pieceList[them][capture][pieceCount[them][capture]] = SQ_NONE;
+ // Update board and piece lists
+ remove_piece(capsq, them, capture);
// Update material hash key and prefetch access to materialTable
k ^= Zobrist::psq[them][capture][capsq];
// Move the piece. The tricky Chess960 castle is handled earlier
if (type_of(m) != CASTLE)
- {
- Bitboard from_to_bb = SquareBB[from] ^ SquareBB[to];
- byTypeBB[ALL_PIECES] ^= from_to_bb;
- byTypeBB[pt] ^= from_to_bb;
- byColorBB[us] ^= from_to_bb;
-
- board[from] = NO_PIECE;
- board[to] = pc;
-
- // Update piece lists, index[from] is not updated and becomes stale. This
- // works as long as index[] is accessed just by known occupied squares.
- index[to] = index[from];
- pieceList[us][pt][index[to]] = to;
- }
+ move_piece(from, to, us, pt);
// If the moving piece is a pawn do some special extra work
if (pt == PAWN)
assert(relative_rank(us, to) == RANK_8);
assert(promotion >= KNIGHT && promotion <= QUEEN);
- // Replace the pawn with the promoted piece
- byTypeBB[PAWN] ^= to;
- byTypeBB[promotion] |= to;
- board[to] = make_piece(us, promotion);
-
- // Update piece lists, move the last pawn at index[to] position
- // and shrink the list. Add a new promotion piece to the list.
- Square lastSquare = pieceList[us][PAWN][--pieceCount[us][PAWN]];
- index[lastSquare] = index[to];
- pieceList[us][PAWN][index[lastSquare]] = lastSquare;
- pieceList[us][PAWN][pieceCount[us][PAWN]] = SQ_NONE;
- index[to] = pieceCount[us][promotion];
- pieceList[us][promotion][index[to]] = to;
+ remove_piece(to, us, PAWN);
+ put_piece(to, us, promotion);
// Update hash keys
k ^= Zobrist::psq[us][PAWN][to] ^ Zobrist::psq[us][promotion][to];
st->pawnKey ^= Zobrist::psq[us][PAWN][to];
- st->materialKey ^= Zobrist::psq[us][promotion][pieceCount[us][promotion]++]
+ st->materialKey ^= Zobrist::psq[us][promotion][pieceCount[us][promotion]-1]
^ Zobrist::psq[us][PAWN][pieceCount[us][PAWN]];
// Update incremental score
assert(relative_rank(us, to) == RANK_8);
assert(promotion >= KNIGHT && promotion <= QUEEN);
- // Replace the promoted piece with the pawn
- byTypeBB[promotion] ^= to;
- byTypeBB[PAWN] |= to;
- board[to] = make_piece(us, PAWN);
-
- // Update piece lists, move the last promoted piece at index[to] position
- // and shrink the list. Add a new pawn to the list.
- Square lastSquare = pieceList[us][promotion][--pieceCount[us][promotion]];
- index[lastSquare] = index[to];
- pieceList[us][promotion][index[lastSquare]] = lastSquare;
- pieceList[us][promotion][pieceCount[us][promotion]] = SQ_NONE;
- index[to] = pieceCount[us][PAWN]++;
- pieceList[us][PAWN][index[to]] = to;
-
+ remove_piece(to, us, promotion);
+ put_piece(to, us, PAWN);
pt = PAWN;
}
do_castle(to, from, rto, rfrom);
}
else
- {
- // Put the piece back at the source square
- Bitboard from_to_bb = SquareBB[from] ^ SquareBB[to];
- byTypeBB[ALL_PIECES] ^= from_to_bb;
- byTypeBB[pt] ^= from_to_bb;
- byColorBB[us] ^= from_to_bb;
-
- board[to] = NO_PIECE;
- board[from] = make_piece(us, pt);
-
- // Update piece lists, index[to] is not updated and becomes stale. This
- // works as long as index[] is accessed just by known occupied squares.
- index[from] = index[to];
- pieceList[us][pt][index[from]] = from;
- }
+ move_piece(to, from, us, pt); // Put the piece back at the source square
if (capture)
{
assert(piece_on(capsq) == NO_PIECE);
}
- // Restore the captured piece
- byTypeBB[ALL_PIECES] |= capsq;
- byTypeBB[capture] |= capsq;
- byColorBB[them] |= capsq;
-
- board[capsq] = make_piece(them, capture);
-
- // Update piece list, add a new captured piece in capsq square
- index[capsq] = pieceCount[them][capture]++;
- pieceList[them][capture][index[capsq]] = capsq;
+ put_piece(capsq, them, capture); // Restore the captured piece
}
// Finally point our state pointer back to the previous state
void Position::do_castle(Square kfrom, Square kto, Square rfrom, Square rto) {
- Color us = sideToMove;
- Bitboard k_from_to_bb = SquareBB[kfrom] ^ SquareBB[kto];
- Bitboard r_from_to_bb = SquareBB[rfrom] ^ SquareBB[rto];
- byTypeBB[KING] ^= k_from_to_bb;
- byTypeBB[ROOK] ^= r_from_to_bb;
- byTypeBB[ALL_PIECES] ^= k_from_to_bb ^ r_from_to_bb;
- byColorBB[us] ^= k_from_to_bb ^ r_from_to_bb;
-
- // Could be from == to, so first set NO_PIECE then KING and ROOK
- board[kfrom] = board[rfrom] = NO_PIECE;
- board[kto] = make_piece(us, KING);
- board[rto] = make_piece(us, ROOK);
-
- // Could be kfrom == rto, so use a 'tmp' variable
- int tmp = index[kfrom];
- index[rto] = index[rfrom];
- index[kto] = tmp;
- pieceList[us][KING][index[kto]] = kto;
- pieceList[us][ROOK][index[rto]] = rto;
+ // Remove both pieces first since squares could overlap in Chess960
+ remove_piece(kfrom, sideToMove, KING);
+ remove_piece(rfrom, sideToMove, ROOK);
+ board[kfrom] = board[rfrom] = NO_PIECE; // Since remove_piece doesn't do it for us
+ put_piece(kto, sideToMove, KING);
+ put_piece(rto, sideToMove, ROOK);
}
}
-/// Position::put_piece() puts a piece on the given square of the board,
-/// updating the board array, pieces list, bitboards, and piece counts.
-
-void Position::put_piece(Piece p, Square s) {
-
- Color c = color_of(p);
- PieceType pt = type_of(p);
-
- board[s] = p;
- index[s] = pieceCount[c][pt]++;
- pieceList[c][pt][index[s]] = s;
-
- byTypeBB[ALL_PIECES] |= s;
- byTypeBB[pt] |= s;
- byColorBB[c] |= s;
-}
-
-
/// Position::compute_key() computes the hash key of the position. The hash
/// key is usually updated incrementally as moves are made and unmade, the
/// compute_key() function is only used when a new position is set up, and
/// Position::flip() flips position with the white and black sides reversed. This
/// is only useful for debugging especially for finding evaluation symmetry bugs.
+static char toggle_case(char c) {
+ return char(islower(c) ? toupper(c) : tolower(c));
+}
+
void Position::flip() {
- const Position pos(*this);
+ string f, token;
+ std::stringstream ss(fen());
- clear();
+ for (Rank rank = RANK_8; rank >= RANK_1; rank--) // Piece placement
+ {
+ std::getline(ss, token, rank > RANK_1 ? '/' : ' ');
+ f.insert(0, token + (f.empty() ? " " : "/"));
+ }
- sideToMove = ~pos.side_to_move();
- thisThread = pos.this_thread();
- nodes = pos.nodes_searched();
- chess960 = pos.is_chess960();
- gamePly = pos.game_ply();
+ ss >> token; // Active color
+ f += (token == "w" ? "B " : "W "); // Will be lowercased later
- for (Square s = SQ_A1; s <= SQ_H8; s++)
- if (!pos.is_empty(s))
- put_piece(Piece(pos.piece_on(s) ^ 8), ~s);
+ ss >> token; // Castling availability
+ f += token + " ";
- if (pos.can_castle(WHITE_OO))
- set_castle_right(BLACK, ~pos.castle_rook_square(WHITE, KING_SIDE));
- if (pos.can_castle(WHITE_OOO))
- set_castle_right(BLACK, ~pos.castle_rook_square(WHITE, QUEEN_SIDE));
- if (pos.can_castle(BLACK_OO))
- set_castle_right(WHITE, ~pos.castle_rook_square(BLACK, KING_SIDE));
- if (pos.can_castle(BLACK_OOO))
- set_castle_right(WHITE, ~pos.castle_rook_square(BLACK, QUEEN_SIDE));
+ std::transform(f.begin(), f.end(), f.begin(), toggle_case);
- if (pos.st->epSquare != SQ_NONE)
- st->epSquare = ~pos.st->epSquare;
+ ss >> token; // En passant square
+ f += (token == "-" ? token : token.replace(1, 1, token[1] == '3' ? "6" : "3"));
- st->checkersBB = attackers_to(king_square(sideToMove)) & pieces(~sideToMove);
+ std::getline(ss, token); // Half and full moves
+ f += token;
- st->key = compute_key();
- st->pawnKey = compute_pawn_key();
- st->materialKey = compute_material_key();
- st->psq = compute_psq_score();
- st->npMaterial[WHITE] = compute_non_pawn_material(WHITE);
- st->npMaterial[BLACK] = compute_non_pawn_material(BLACK);
+ set(f, is_chess960(), this_thread());
assert(pos_is_ok());
}