#include <fstream>
#include <iostream>
+#include "bitcount.h"
#include "mersenne.h"
#include "movegen.h"
#include "movepick.h"
/// Position::copy() creates a copy of the input position.
-void Position::copy(const Position &pos) {
+void Position::copy(const Position& pos) {
memcpy(this, &pos, sizeof(Position));
+ saveState(); // detach and copy state info
}
&& (direction_between_squares(from, ksq) != direction_between_squares(to, ksq)))
return true;
- if (move_promotion(m)) // Promotion with check?
+ if (move_is_promotion(m)) // Promotion with check?
{
Bitboard b = occupied_squares();
clear_bit(&b, from);
- switch (move_promotion(m))
+ switch (move_promotion_piece(m))
{
case KNIGHT:
return bit_is_set(piece_attacks<KNIGHT>(to), ksq);
if (move_is_castle(m))
do_castle_move(m);
- else if (move_promotion(m))
+ else if (move_is_promotion(m))
do_promotion_move(m);
else if (move_is_ep(m))
do_ep_move(m);
assert(color_of_piece_on(from) == us);
assert(color_of_piece_on(to) == them || piece_on(to) == EMPTY);
- PieceType piece = type_of_piece_on(from);
+ Piece piece = piece_on(from);
+ PieceType pt = type_of_piece(piece);
st->capture = type_of_piece_on(to);
do_capture_move(st->capture, them, to);
// Move the piece
- clear_bit(&(byColorBB[us]), from);
- clear_bit(&(byTypeBB[piece]), from);
- clear_bit(&(byTypeBB[0]), from); // HACK: byTypeBB[0] == occupied squares
- set_bit(&(byColorBB[us]), to);
- set_bit(&(byTypeBB[piece]), to);
- set_bit(&(byTypeBB[0]), to); // HACK: byTypeBB[0] == occupied squares
+ Bitboard move_bb = make_move_bb(from, to);
+ do_move_bb(&(byColorBB[us]), move_bb);
+ do_move_bb(&(byTypeBB[pt]), move_bb);
+ do_move_bb(&(byTypeBB[0]), move_bb); // HACK: byTypeBB[0] == occupied squares
+
board[to] = board[from];
board[from] = EMPTY;
// Update hash key
- st->key ^= zobrist[us][piece][from] ^ zobrist[us][piece][to];
+ st->key ^= zobrist[us][pt][from] ^ zobrist[us][pt][to];
// Update incremental scores
- st->mgValue -= pst<MidGame>(us, piece, from);
- st->mgValue += pst<MidGame>(us, piece, to);
- st->egValue -= pst<EndGame>(us, piece, from);
- st->egValue += pst<EndGame>(us, piece, to);
+ st->mgValue += pst_delta<MidGame>(piece, from, to);
+ st->egValue += pst_delta<EndGame>(piece, from, to);
// If the moving piece was a king, update the king square
- if (piece == KING)
+ if (pt == KING)
kingSquare[us] = to;
// Reset en passant square
}
// If the moving piece was a pawn do some special extra work
- if (piece == PAWN)
+ if (pt == PAWN)
{
// Reset rule 50 draw counter
st->rule50 = 0;
}
// Update piece lists
- pieceList[us][piece][index[from]] = to;
+ pieceList[us][pt][index[from]] = to;
index[to] = index[from];
- // Update castle rights
- st->key ^= zobCastle[st->castleRights];
- st->castleRights &= castleRightsMask[from];
- st->castleRights &= castleRightsMask[to];
- st->key ^= zobCastle[st->castleRights];
+ // Update castle rights, try to shortcut a common case
+ if ((castleRightsMask[from] & castleRightsMask[to]) != ALL_CASTLES)
+ {
+ st->key ^= zobCastle[st->castleRights];
+ st->castleRights &= castleRightsMask[from];
+ st->castleRights &= castleRightsMask[to];
+ st->key ^= zobCastle[st->castleRights];
+ }
// Update checkers bitboard, piece must be already moved
st->checkersBB = EmptyBoardBB;
Square ksq = king_square(them);
- switch (piece)
+ switch (pt)
{
case PAWN: update_checkers<PAWN>(&(st->checkersBB), ksq, from, to, dcCandidates); break;
case KNIGHT: update_checkers<KNIGHT>(&(st->checkersBB), ksq, from, to, dcCandidates); break;
// Remove captured piece
clear_bit(&(byColorBB[them]), to);
clear_bit(&(byTypeBB[capture]), to);
+ clear_bit(&(byTypeBB[0]), to);
// Update hash key
st->key ^= zobrist[them][capture][to];
set_bit(&(byTypeBB[0]), rto); // HACK: byTypeBB[0] == occupied squares
// Update board array
+ Piece king = piece_of_color_and_type(us, KING);
+ Piece rook = piece_of_color_and_type(us, ROOK);
board[kfrom] = board[rfrom] = EMPTY;
- board[kto] = piece_of_color_and_type(us, KING);
- board[rto] = piece_of_color_and_type(us, ROOK);
+ board[kto] = king;
+ board[rto] = rook;
// Update king square
kingSquare[us] = kto;
index[rto] = tmp;
// Update incremental scores
- st->mgValue -= pst<MidGame>(us, KING, kfrom);
- st->mgValue += pst<MidGame>(us, KING, kto);
- st->egValue -= pst<EndGame>(us, KING, kfrom);
- st->egValue += pst<EndGame>(us, KING, kto);
- st->mgValue -= pst<MidGame>(us, ROOK, rfrom);
- st->mgValue += pst<MidGame>(us, ROOK, rto);
- st->egValue -= pst<EndGame>(us, ROOK, rfrom);
- st->egValue += pst<EndGame>(us, ROOK, rto);
+ st->mgValue += pst_delta<MidGame>(king, kfrom, kto);
+ st->egValue += pst_delta<EndGame>(king, kfrom, kto);
+ st->mgValue += pst_delta<MidGame>(rook, rfrom, rto);
+ st->egValue += pst_delta<EndGame>(rook, rfrom, rto);
// Update hash key
st->key ^= zobrist[us][KING][kfrom] ^ zobrist[us][KING][kto];
assert(is_ok());
assert(move_is_ok(m));
- assert(move_promotion(m));
+ assert(move_is_promotion(m));
us = side_to_move();
them = opposite_color(us);
board[from] = EMPTY;
// Insert promoted piece
- promotion = move_promotion(m);
+ promotion = move_promotion_piece(m);
assert(promotion >= KNIGHT && promotion <= QUEEN);
set_bit(&(byColorBB[us]), to);
set_bit(&(byTypeBB[promotion]), to);
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
+ // Remove captured pawn
clear_bit(&(byColorBB[them]), capsq);
clear_bit(&(byTypeBB[PAWN]), capsq);
clear_bit(&(byTypeBB[0]), capsq); // HACK: byTypeBB[0] == occupied squares
board[capsq] = EMPTY;
- // Remove moving piece from source square
- clear_bit(&(byColorBB[us]), from);
- clear_bit(&(byTypeBB[PAWN]), from);
- clear_bit(&(byTypeBB[0]), from); // HACK: byTypeBB[0] == occupied squares
-
- // Put moving piece on destination square
- set_bit(&(byColorBB[us]), to);
- set_bit(&(byTypeBB[PAWN]), to);
- set_bit(&(byTypeBB[0]), to); // HACK: byTypeBB[0] == occupied squares
+ // Move capturing pawn
+ Bitboard move_bb = make_move_bb(from, to);
+ do_move_bb(&(byColorBB[us]), move_bb);
+ do_move_bb(&(byTypeBB[PAWN]), move_bb);
+ do_move_bb(&(byTypeBB[0]), move_bb); // HACK: byTypeBB[0] == occupied squares
board[to] = board[from];
board[from] = EMPTY;
st->pawnKey ^= zobrist[them][PAWN][capsq];
// Update incremental scores
+ Piece pawn = piece_of_color_and_type(us, PAWN);
+ st->mgValue += pst_delta<MidGame>(pawn, from, to);
+ st->egValue += pst_delta<EndGame>(pawn, from, to);
st->mgValue -= pst<MidGame>(them, PAWN, capsq);
- st->mgValue -= pst<MidGame>(us, PAWN, from);
- st->mgValue += pst<MidGame>(us, PAWN, to);
st->egValue -= pst<EndGame>(them, PAWN, capsq);
- st->egValue -= pst<EndGame>(us, PAWN, from);
- st->egValue += pst<EndGame>(us, PAWN, to);
// Reset en passant square
st->epSquare = SQ_NONE;
if (move_is_castle(m))
undo_castle_move(m);
- else if (move_promotion(m))
+ else if (move_is_promotion(m))
undo_promotion_move(m);
else if (move_is_ep(m))
undo_ep_move(m);
assert(color_of_piece_on(to) == us);
// Put the piece back at the source square
+ Bitboard move_bb = make_move_bb(to, from);
piece = type_of_piece_on(to);
- set_bit(&(byColorBB[us]), from);
- set_bit(&(byTypeBB[piece]), from);
- set_bit(&(byTypeBB[0]), from); // HACK: byTypeBB[0] == occupied squares
+ do_move_bb(&(byColorBB[us]), move_bb);
+ do_move_bb(&(byTypeBB[piece]), move_bb);
+ do_move_bb(&(byTypeBB[0]), move_bb); // HACK: byTypeBB[0] == occupied squares
board[from] = piece_of_color_and_type(us, piece);
- // Clear the destination square
- clear_bit(&(byColorBB[us]), to);
- clear_bit(&(byTypeBB[piece]), to);
- clear_bit(&(byTypeBB[0]), to); // HACK: byTypeBB[0] == occupied squares
-
// If the moving piece was a king, update the king square
if (piece == KING)
kingSquare[us] = from;
{
assert(st->capture != KING);
- // Replace the captured piece
+ // Restore the captured piece
set_bit(&(byColorBB[them]), to);
set_bit(&(byTypeBB[st->capture]), to);
set_bit(&(byTypeBB[0]), to);
PieceType promotion;
assert(move_is_ok(m));
- assert(move_promotion(m));
+ assert(move_is_promotion(m));
// When we have arrived here, some work has already been done by
// Position::undo_move. In particular, the side to move has been switched,
assert(piece_on(from) == EMPTY);
// Remove promoted piece
- promotion = move_promotion(m);
+ promotion = move_promotion_piece(m);
assert(piece_on(to)==piece_of_color_and_type(us, promotion));
assert(promotion >= KNIGHT && promotion <= QUEEN);
clear_bit(&(byColorBB[us]), to);
assert(piece_on(from) == EMPTY);
assert(piece_on(capsq) == EMPTY);
- // Replace captured piece
+ // Restore captured pawn
set_bit(&(byColorBB[them]), capsq);
set_bit(&(byTypeBB[PAWN]), capsq);
set_bit(&(byTypeBB[0]), capsq);
board[capsq] = piece_of_color_and_type(them, PAWN);
- // Remove moving piece from destination square
- clear_bit(&(byColorBB[us]), to);
- clear_bit(&(byTypeBB[PAWN]), to);
- clear_bit(&(byTypeBB[0]), to);
+ // Move capturing pawn back to source square
+ Bitboard move_bb = make_move_bb(to, from);
+ do_move_bb(&(byColorBB[us]), move_bb);
+ do_move_bb(&(byTypeBB[PAWN]), move_bb);
+ do_move_bb(&(byTypeBB[0]), move_bb);
board[to] = EMPTY;
-
- // Replace moving piece at source square
- set_bit(&(byColorBB[us]), from);
- set_bit(&(byTypeBB[PAWN]), from);
- set_bit(&(byTypeBB[0]), from);
board[from] = piece_of_color_and_type(us, PAWN);
// Update piece list
assert(!is_check());
// Back up the information necessary to undo the null move to the supplied
- // StateInfo object. In the case of a null move, the only thing we need to
- // remember is the en passant square.
+ // StateInfo object.
// Note that differently from normal case here backupSt is actually used as
// a backup storage not as a new state to be used.
backupSt.epSquare = st->epSquare;
+ backupSt.key = st->key;
+ backupSt.mgValue = st->mgValue;
+ backupSt.egValue = st->egValue;
backupSt.previous = st->previous;
st->previous = &backupSt;
// Restore information from the our backup StateInfo object
st->epSquare = st->previous->epSquare;
+ st->key = st->previous->key;
+ st->mgValue = st->previous->mgValue;
+ st->egValue = st->previous->egValue;
st->previous = st->previous->previous;
- if (st->epSquare != SQ_NONE)
- st->key ^= zobEp[st->epSquare];
-
// Update the necessary information
sideToMove = opposite_color(sideToMove);
st->rule50--;
gamePly--;
- st->key ^= zobSideToMove;
-
- st->mgValue += (sideToMove == WHITE)? TempoValueMidgame : -TempoValueMidgame;
- st->egValue += (sideToMove == WHITE)? TempoValueEndgame : -TempoValueEndgame;
assert(is_ok());
}
if (pt == KING && stmAttackers)
{
assert(n < 32);
- swapList[n++] = 100;
+ swapList[n++] = QueenValueMidgame*10;
break;
}
} while (stmAttackers);
}
-/// Position::setStartState() copies the content of the argument
+/// Position::saveState() copies the content of the current state
/// inside startState and makes st point to it. This is needed
/// when the st pointee could become stale, as example because
/// the caller is about to going out of scope.
-void Position::setStartState(const StateInfo& s) {
+void Position::saveState() {
- startState = s;
+ startState = *st;
st = &startState;
+ st->previous = NULL; // as a safe guard
}
/// 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) {
+void Position::flipped_copy(const Position& pos) {
assert(pos.is_ok());
projects / stockfish / blobdiff