/*
Stockfish, a UCI chess playing engine derived from Glaurung 2.1
Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
- Copyright (C) 2008-2009 Marco Costalba
+ Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
Stockfish is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
//// Variables
////
-int Position::castleRightsMask[64];
-
Key Position::zobrist[2][8][64];
Key Position::zobEp[64];
Key Position::zobCastle[16];
Key Position::zobMaterial[2][8][16];
Key Position::zobSideToMove;
+Key Position::zobExclusion;
Score Position::PieceSquareTable[16][64];
checkSq[KING] = EmptyBoardBB;
}
+
+/// Position c'tors. Here we always create a slower but safer copy of
+/// the original position or the FEN string, we want the new born Position
+/// object do not depend on any external data. Instead if we know what we
+/// are doing and we need speed we can create a position with default
+/// c'tor Position() and then use just fast_copy().
+
+Position::Position() {}
+
Position::Position(const Position& pos) {
- copy(pos);
+
+ memcpy(this, &pos, sizeof(Position));
+ detach(); // Always detach() in copy c'tor to avoid surprises
}
Position::Position(const string& fen) {
+
from_fen(fen);
}
+/// Position::detach() copies the content of the current state and castling
+/// masks inside the position itself. This is needed when the st pointee could
+/// become stale, as example because the caller is about to going out of scope.
+
+void Position::detach() {
+
+ startState = *st;
+ st = &startState;
+ st->previous = NULL; // as a safe guard
+}
+
+
/// Position::from_fen() 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).
}
i++;
- while(strchr("KQkqabcdefghABCDEFGH-", fen[i])) {
- if (fen[i] == '-')
- {
- i++;
- break;
- }
- else if(fen[i] == 'K') allow_oo(WHITE);
- else if(fen[i] == 'Q') allow_ooo(WHITE);
- else if(fen[i] == 'k') allow_oo(BLACK);
- else if(fen[i] == 'q') allow_ooo(BLACK);
- else if(fen[i] >= 'A' && fen[i] <= 'H') {
- File rookFile, kingFile = FILE_NONE;
- for(Square square = SQ_B1; square <= SQ_G1; square++)
- if(piece_on(square) == WK)
- kingFile = square_file(square);
- if(kingFile == FILE_NONE) {
- std::cout << "Error in FEN at character " << i << std::endl;
- return;
- }
- initialKFile = kingFile;
- rookFile = File(fen[i] - 'A') + FILE_A;
- if(rookFile < initialKFile) {
- allow_ooo(WHITE);
- initialQRFile = rookFile;
- }
- else {
- allow_oo(WHITE);
- initialKRFile = rookFile;
+ while (strchr("KQkqabcdefghABCDEFGH-", fen[i])) {
+ if (fen[i] == '-')
+ {
+ i++;
+ break;
}
- }
- else if(fen[i] >= 'a' && fen[i] <= 'h') {
- File rookFile, kingFile = FILE_NONE;
- for(Square square = SQ_B8; square <= SQ_G8; square++)
- if(piece_on(square) == BK)
- kingFile = square_file(square);
- if(kingFile == FILE_NONE) {
- std::cout << "Error in FEN at character " << i << std::endl;
- return;
+ else if (fen[i] == 'K') allow_oo(WHITE);
+ else if (fen[i] == 'Q') allow_ooo(WHITE);
+ else if (fen[i] == 'k') allow_oo(BLACK);
+ else if (fen[i] == 'q') allow_ooo(BLACK);
+ else if (fen[i] >= 'A' && fen[i] <= 'H') {
+ File rookFile, kingFile = FILE_NONE;
+ for (Square square = SQ_B1; square <= SQ_G1; square++)
+ if (piece_on(square) == WK)
+ kingFile = square_file(square);
+ if (kingFile == FILE_NONE) {
+ std::cout << "Error in FEN at character " << i << std::endl;
+ return;
+ }
+ initialKFile = kingFile;
+ rookFile = File(fen[i] - 'A') + FILE_A;
+ if (rookFile < initialKFile) {
+ allow_ooo(WHITE);
+ initialQRFile = rookFile;
+ }
+ else {
+ allow_oo(WHITE);
+ initialKRFile = rookFile;
+ }
}
- initialKFile = kingFile;
- rookFile = File(fen[i] - 'a') + FILE_A;
- if(rookFile < initialKFile) {
- allow_ooo(BLACK);
- initialQRFile = rookFile;
+ else if (fen[i] >= 'a' && fen[i] <= 'h') {
+ File rookFile, kingFile = FILE_NONE;
+ for (Square square = SQ_B8; square <= SQ_G8; square++)
+ if (piece_on(square) == BK)
+ kingFile = square_file(square);
+ if (kingFile == FILE_NONE) {
+ std::cout << "Error in FEN at character " << i << std::endl;
+ return;
+ }
+ initialKFile = kingFile;
+ rookFile = File(fen[i] - 'a') + FILE_A;
+ if (rookFile < initialKFile) {
+ allow_ooo(BLACK);
+ initialQRFile = rookFile;
+ }
+ else {
+ allow_oo(BLACK);
+ initialKRFile = rookFile;
+ }
}
else {
- allow_oo(BLACK);
- initialKRFile = rookFile;
+ std::cout << "Error in FEN at character " << i << std::endl;
+ return;
}
- }
- else {
- std::cout << "Error in FEN at character " << i << std::endl;
- return;
- }
- i++;
+ i++;
}
// Skip blanks
while (fen[i] == ' ')
i++;
- // En passant square
+ // En passant square -- ignore if no capture is possible
if ( i <= fen.length() - 2
&& (fen[i] >= 'a' && fen[i] <= 'h')
&& (fen[i+1] == '3' || fen[i+1] == '6'))
- st->epSquare = square_from_string(fen.substr(i, 2));
+ {
+ Square fenEpSquare = square_from_string(fen.substr(i, 2));
+ Color them = opposite_color(sideToMove);
+ if (attacks_from<PAWN>(fenEpSquare, them) & this->pieces(PAWN, sideToMove))
+ st->epSquare = square_from_string(fen.substr(i, 2));
+ }
// Various initialisation
for (Square sq = SQ_A1; sq <= SQ_H8; sq++)
fen += (sideToMove == WHITE ? "w " : "b ");
if (st->castleRights != NO_CASTLES)
{
- if (can_castle_kingside(WHITE)) fen += 'K';
- if (can_castle_queenside(WHITE)) fen += 'Q';
- if (can_castle_kingside(BLACK)) fen += 'k';
- if (can_castle_queenside(BLACK)) fen += 'q';
+ if (initialKFile == FILE_E && initialQRFile == FILE_A && initialKRFile == FILE_H)
+ {
+ if (can_castle_kingside(WHITE)) fen += 'K';
+ if (can_castle_queenside(WHITE)) fen += 'Q';
+ if (can_castle_kingside(BLACK)) fen += 'k';
+ if (can_castle_queenside(BLACK)) fen += 'q';
+ }
+ else
+ {
+ if (can_castle_kingside(WHITE))
+ fen += char(toupper(file_to_char(initialKRFile)));
+ if (can_castle_queenside(WHITE))
+ fen += char(toupper(file_to_char(initialQRFile)));
+ if (can_castle_kingside(BLACK))
+ fen += file_to_char(initialKRFile);
+ if (can_castle_queenside(BLACK))
+ fen += file_to_char(initialQRFile);
+ }
} else
fen += '-';
std::cout << std::endl;
if (m != MOVE_NONE)
{
+ Position p(*this);
string col = (color_of_piece_on(move_from(m)) == BLACK ? ".." : "");
- std::cout << "Move is: " << col << move_to_san(*this, m) << std::endl;
+ std::cout << "Move is: " << col << move_to_san(p, m) << std::endl;
}
for (Rank rank = RANK_8; rank >= RANK_1; rank--)
{
}
-/// Position::copy() creates a copy of the input position.
-
-void Position::copy(const Position& pos) {
-
- memcpy(this, &pos, sizeof(Position));
- saveState(); // detach and copy state info
-}
-
-
/// Position:hidden_checkers<>() 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 pieces of the given color
/// candidate for a discovery check against the enemy king.
-/// Note that checkersBB bitboard must be already updated.
+/// Bitboard checkersBB must be already updated when looking for pinners.
template<bool FindPinned>
Bitboard Position::hidden_checkers(Color c) const {
- Bitboard pinners, result = EmptyBoardBB;
+ Bitboard result = EmptyBoardBB;
+ Bitboard pinners = pieces_of_color(FindPinned ? opposite_color(c) : c);
// Pinned pieces protect our king, dicovery checks attack
// the enemy king.
Square ksq = king_square(FindPinned ? c : opposite_color(c));
- // Pinners are sliders, not checkers, that give check when
- // candidate pinned is removed.
- pinners = (pieces(ROOK, QUEEN, FindPinned ? opposite_color(c) : c) & RookPseudoAttacks[ksq])
- | (pieces(BISHOP, QUEEN, FindPinned ? opposite_color(c) : c) & BishopPseudoAttacks[ksq]);
+ // Pinners are sliders, not checkers, that give check when candidate pinned is removed
+ pinners &= (pieces(ROOK, QUEEN) & RookPseudoAttacks[ksq]) | (pieces(BISHOP, QUEEN) & BishopPseudoAttacks[ksq]);
if (FindPinned && pinners)
pinners &= ~st->checkersBB;
/// Position:pinned_pieces() returns a bitboard of all pinned (against the
-/// king) pieces for the given color.
+/// king) pieces for the given color. Note that checkersBB bitboard must
+/// be already updated.
Bitboard Position::pinned_pieces(Color c) const {
/// Position:discovered_check_candidates() returns a bitboard containing all
/// pieces for the given side which are candidates for giving a discovered
-/// check.
+/// check. Contrary to pinned_pieces() here there is no need of checkersBB
+/// to be already updated.
Bitboard Position::discovered_check_candidates(Color c) const {
}
-/// Position::update_checkers() udpates chekers info given the move. It is called
-/// in do_move() and is faster then find_checkers().
-
-template<PieceType Piece>
-inline void Position::update_checkers(Bitboard* pCheckersBB, Square ksq, Square from,
- Square to, Bitboard dcCandidates) {
-
- const bool Bishop = (Piece == QUEEN || Piece == BISHOP);
- const bool Rook = (Piece == QUEEN || Piece == ROOK);
- const bool Slider = Bishop || Rook;
-
- assert(*pCheckersBB == EmptyBoardBB);
-
- // Direct checks
- if ( ( !Slider // try to early skip slide piece attacks
- || (Bishop && bit_is_set(BishopPseudoAttacks[ksq], to))
- || (Rook && bit_is_set(RookPseudoAttacks[ksq], to)))
- && bit_is_set(Piece == PAWN ? attacks_from<PAWN>(ksq, opposite_color(sideToMove)) : attacks_from<Piece>(ksq) , to))
- {
- *pCheckersBB = SetMaskBB[to];
- }
- // Discovery checks
- if (Piece != QUEEN && dcCandidates && bit_is_set(dcCandidates, from))
- {
- if (Piece != ROOK)
- (*pCheckersBB) |= (attacks_from<ROOK>(ksq) & pieces(ROOK, QUEEN, side_to_move()));
-
- if (Piece != BISHOP)
- (*pCheckersBB) |= (attacks_from<BISHOP>(ksq) & pieces(BISHOP, QUEEN, side_to_move()));
- }
-}
-
-
/// Position::do_move() makes a move, and saves all information necessary
/// to a StateInfo object. The move is assumed to be legal.
/// Pseudo-legal moves should be filtered out before this function is called.
void Position::do_move(Move m, StateInfo& newSt) {
- do_move(m, newSt, discovered_check_candidates(side_to_move()));
+ CheckInfo ci(*this);
+ do_move(m, newSt, ci, move_is_check(m, ci));
}
-void Position::do_move(Move m, StateInfo& newSt, Bitboard dcCandidates, bool moveCanBeCheck) {
+void Position::do_move(Move m, StateInfo& newSt, const CheckInfo& ci, bool moveIsCheck) {
assert(is_ok());
assert(move_is_ok(m));
Key pawnKey, materialKey;
int castleRights, rule50, pliesFromNull;
Square epSquare;
- Value value;
+ Score value;
Value npMaterial[2];
};
// Update checkers bitboard, piece must be already moved
st->checkersBB = EmptyBoardBB;
- if (moveCanBeCheck)
+ if (moveIsCheck)
{
if (ep | pm)
st->checkersBB = attackers_to(king_square(them)) & pieces_of_color(us);
else
{
- Square ksq = king_square(them);
- switch (pt)
+ // Direct checks
+ if (bit_is_set(ci.checkSq[pt], to))
+ st->checkersBB = SetMaskBB[to];
+
+ // Discovery checks
+ if (ci.dcCandidates && bit_is_set(ci.dcCandidates, from))
{
- case PAWN: update_checkers<PAWN>(&(st->checkersBB), ksq, from, to, dcCandidates); break;
- case KNIGHT: update_checkers<KNIGHT>(&(st->checkersBB), ksq, from, to, dcCandidates); break;
- case BISHOP: update_checkers<BISHOP>(&(st->checkersBB), ksq, from, to, dcCandidates); break;
- case ROOK: update_checkers<ROOK>(&(st->checkersBB), ksq, from, to, dcCandidates); break;
- case QUEEN: update_checkers<QUEEN>(&(st->checkersBB), ksq, from, to, dcCandidates); break;
- case KING: update_checkers<KING>(&(st->checkersBB), ksq, from, to, dcCandidates); break;
- default: assert(false); break;
+ if (pt != ROOK)
+ st->checkersBB |= (attacks_from<ROOK>(ci.ksq) & pieces(ROOK, QUEEN, us));
+
+ if (pt != BISHOP)
+ st->checkersBB |= (attacks_from<BISHOP>(ci.ksq) & pieces(BISHOP, QUEEN, us));
}
}
}
set_bit(&(byColorBB[us]), rto);
set_bit(&(byTypeBB[ROOK]), rto);
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);
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);
clear_bit(&(byTypeBB[KING]), kto);
clear_bit(&(byColorBB[us]), rto);
clear_bit(&(byTypeBB[ROOK]), rto);
clear_bit(&(byTypeBB[0]), rto); // HACK: byTypeBB[0] == occupied squares
-
+
// Put pieces on source squares:
set_bit(&(byColorBB[us]), kfrom);
set_bit(&(byTypeBB[KING]), kfrom);
}
-/// 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::saveState() {
-
- startState = *st;
- st = &startState;
- st->previous = NULL; // as a safe guard
-}
-
-
/// Position::clear() erases the position object to a pristine state, with an
/// empty board, white to move, and no castling rights.
for (Color c = WHITE; c <= BLACK; c++)
{
b = pieces(PAWN, c);
- while(b)
+ while (b)
{
s = pop_1st_bit(&b);
result ^= zobrist[c][PAWN][s];
for (PieceType pt = PAWN; pt <= KING; pt++)
{
b = pieces(pt, c);
- while(b)
+ while (b)
{
s = pop_1st_bit(&b);
assert(piece_on(s) == piece_of_color_and_type(c, pt));
/// Position::is_draw() tests whether the position is drawn by material,
/// repetition, or the 50 moves rule. It does not detect stalemates, this
/// must be done by the search.
+// FIXME: Currently we are not handling 50 move rule correctly when in check
bool Position::is_draw() const {
return true;
// Draw by repetition?
- for (int i = 2; i < Min(Min(gamePly, st->rule50), st->pliesFromNull); i += 2)
+ for (int i = 4; i <= Min(Min(gamePly, st->rule50), st->pliesFromNull); i += 2)
if (history[gamePly - i] == st->key)
return true;
for (int i = 0; i < 16; i++)
zobMaterial[0][KING][i] = zobMaterial[1][KING][i] = Key(0ULL);
+
+ zobExclusion = genrand_int64();
}
static const bool debugNonPawnMaterial = false;
static const bool debugPieceCounts = false;
static const bool debugPieceList = false;
+ static const bool debugCastleSquares = false;
if (failedStep) *failedStep = 1;
if (failedStep) (*failedStep)++;
if (debugPieceList)
{
- for(Color c = WHITE; c <= BLACK; c++)
- for(PieceType pt = PAWN; pt <= KING; pt++)
- for(int i = 0; i < pieceCount[c][pt]; i++)
+ for (Color c = WHITE; c <= BLACK; c++)
+ for (PieceType pt = PAWN; pt <= KING; pt++)
+ for (int i = 0; i < pieceCount[c][pt]; i++)
{
if (piece_on(piece_list(c, pt, i)) != piece_of_color_and_type(c, pt))
return false;
return false;
}
}
+
+ if (failedStep) (*failedStep)++;
+ if (debugCastleSquares) {
+ for (Color c = WHITE; c <= BLACK; c++) {
+ if (can_castle_kingside(c) && piece_on(initial_kr_square(c)) != piece_of_color_and_type(c, ROOK))
+ return false;
+ if (can_castle_queenside(c) && piece_on(initial_qr_square(c)) != piece_of_color_and_type(c, ROOK))
+ return false;
+ }
+ if (castleRightsMask[initial_kr_square(WHITE)] != (ALL_CASTLES ^ WHITE_OO))
+ return false;
+ if (castleRightsMask[initial_qr_square(WHITE)] != (ALL_CASTLES ^ WHITE_OOO))
+ return false;
+ if (castleRightsMask[initial_kr_square(BLACK)] != (ALL_CASTLES ^ BLACK_OO))
+ return false;
+ if (castleRightsMask[initial_qr_square(BLACK)] != (ALL_CASTLES ^ BLACK_OOO))
+ return false;
+ }
+
if (failedStep) *failedStep = 0;
return true;
}
projects / stockfish / blobdiff