Stockfish, a UCI chess playing engine derived from Glaurung 2.1
Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad
- Copyright (C) 2015-2018 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad
+ Copyright (C) 2015-2019 Marco Costalba, Joona Kiiski, Gary Linscott, 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
using std::string;
-namespace PSQT {
- extern Score psq[PIECE_NB][SQUARE_NB];
-}
-
namespace Zobrist {
Key psq[PIECE_NB][SQUARE_NB];
}
+// Marcel van Kervinck's cuckoo algorithm for fast detection of "upcoming repetition"
+// situations. Description of the algorithm in the following paper:
+// https://marcelk.net/2013-04-06/paper/upcoming-rep-v2.pdf
+
+// First and second hash functions for indexing the cuckoo tables
+inline int H1(Key h) { return h & 0x1fff; }
+inline int H2(Key h) { return (h >> 16) & 0x1fff; }
+
+// Cuckoo tables with Zobrist hashes of valid reversible moves, and the moves themselves
+Key cuckoo[8192];
+Move cuckooMove[8192];
+
+
/// Position::init() initializes at startup the various arrays used to compute
/// hash keys.
Zobrist::side = rng.rand<Key>();
Zobrist::noPawns = rng.rand<Key>();
+
+ // Prepare the cuckoo tables
+ std::memset(cuckoo, 0, sizeof(cuckoo));
+ std::memset(cuckooMove, 0, sizeof(cuckooMove));
+ int count = 0;
+ for (Piece pc : Pieces)
+ for (Square s1 = SQ_A1; s1 <= SQ_H8; ++s1)
+ for (Square s2 = Square(s1 + 1); s2 <= SQ_H8; ++s2)
+ if (PseudoAttacks[type_of(pc)][s1] & s2)
+ {
+ Move move = make_move(s1, s2);
+ Key key = Zobrist::psq[pc][s1] ^ Zobrist::psq[pc][s2] ^ Zobrist::side;
+ int i = H1(key);
+ while (true)
+ {
+ std::swap(cuckoo[i], key);
+ std::swap(cuckooMove[i], move);
+ if (move == MOVE_NONE) // Arrived at empty slot?
+ break;
+ i = (i == H1(key)) ? H2(key) : H1(key); // Push victim to alternative slot
+ }
+ count++;
+ }
+ assert(count == 3668);
}
si->key = si->materialKey = 0;
si->pawnKey = Zobrist::noPawns;
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);
Square s = pop_lsb(&b);
Piece pc = piece_on(s);
si->key ^= Zobrist::psq[pc][s];
- si->psq += PSQT::psq[pc][s];
}
if (si->epSquare != SQ_NONE)
ss << (sideToMove == WHITE ? " w " : " b ");
if (can_castle(WHITE_OO))
- ss << (chess960 ? char('A' + file_of(castling_rook_square(WHITE | KING_SIDE))) : 'K');
+ ss << (chess960 ? char('A' + file_of(castling_rook_square(WHITE_OO ))) : 'K');
if (can_castle(WHITE_OOO))
- ss << (chess960 ? char('A' + file_of(castling_rook_square(WHITE | QUEEN_SIDE))) : 'Q');
+ ss << (chess960 ? char('A' + file_of(castling_rook_square(WHITE_OOO))) : 'Q');
if (can_castle(BLACK_OO))
- ss << (chess960 ? char('a' + file_of(castling_rook_square(BLACK | KING_SIDE))) : 'k');
+ ss << (chess960 ? char('a' + file_of(castling_rook_square(BLACK_OO ))) : 'k');
if (can_castle(BLACK_OOO))
- ss << (chess960 ? char('a' + file_of(castling_rook_square(BLACK | QUEEN_SIDE))) : 'q');
+ ss << (chess960 ? char('a' + file_of(castling_rook_square(BLACK_OOO))) : 'q');
- if (!can_castle(WHITE) && !can_castle(BLACK))
+ if (!can_castle(ANY_CASTLING))
ss << '-';
ss << (ep_square() == SQ_NONE ? " - " : " " + UCI::square(ep_square()) + " ")
Color us = sideToMove;
Square from = from_sq(m);
+ Square to = to_sq(m);
assert(color_of(moved_piece(m)) == us);
assert(piece_on(square<KING>(us)) == make_piece(us, KING));
if (type_of(m) == ENPASSANT)
{
Square ksq = square<KING>(us);
- Square to = to_sq(m);
Square capsq = to - pawn_push(us);
Bitboard occupied = (pieces() ^ from ^ capsq) | to;
&& !(attacks_bb<BISHOP>(ksq, occupied) & pieces(~us, QUEEN, BISHOP));
}
- // If the moving piece is a king, check whether the destination
- // square is attacked by the opponent. Castling moves are checked
- // for legality during move generation.
+ // Castling moves generation does not check if the castling path is clear of
+ // enemy attacks, it is delayed at a later time: now!
+ if (type_of(m) == CASTLING)
+ {
+ // After castling, the rook and king final positions are the same in
+ // Chess960 as they would be in standard chess.
+ to = relative_square(us, to > from ? SQ_G1 : SQ_C1);
+ Direction step = to > from ? WEST : EAST;
+
+ for (Square s = to; s != from; s += step)
+ if (attackers_to(s) & pieces(~us))
+ return false;
+
+ // In case of Chess960, verify that when moving the castling rook we do
+ // not discover some hidden checker.
+ // For instance an enemy queen in SQ_A1 when castling rook is in SQ_B1.
+ return !chess960
+ || !(attacks_bb<ROOK>(to, pieces() ^ to_sq(m)) & pieces(~us, ROOK, QUEEN));
+ }
+
+ // If the moving piece is a king, check whether the destination square is
+ // attacked by the opponent.
if (type_of(piece_on(from)) == KING)
- return type_of(m) == CASTLING || !(attackers_to(to_sq(m)) & pieces(~us));
+ return !(attackers_to(to) & 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 !(blockers_for_king(us) & from)
- || aligned(from, to_sq(m), square<KING>(us));
+ || aligned(from, to, square<KING>(us));
}
Square rfrom, rto;
do_castling<true>(us, from, to, rfrom, rto);
- st->psq += PSQT::psq[captured][rto] - PSQT::psq[captured][rfrom];
k ^= Zobrist::psq[captured][rfrom] ^ Zobrist::psq[captured][rto];
captured = NO_PIECE;
}
st->materialKey ^= Zobrist::psq[captured][pieceCount[captured]];
prefetch(thisThread->materialTable[st->materialKey]);
- // Update incremental scores
- st->psq -= PSQT::psq[captured][capsq];
-
// Reset rule 50 counter
st->rule50 = 0;
}
st->materialKey ^= Zobrist::psq[promotion][pieceCount[promotion]-1]
^ Zobrist::psq[pc][pieceCount[pc]];
- // Update incremental score
- st->psq += PSQT::psq[promotion][to] - PSQT::psq[pc][to];
-
// Update material
st->nonPawnMaterial[us] += PieceValue[MG][promotion];
}
st->rule50 = 0;
}
- // Update incremental scores
- st->psq += PSQT::psq[pc][to] - PSQT::psq[pc][from];
-
// Set capture piece
st->capturedPiece = captured;
StateInfo* stc = st;
while (true)
{
- int i = 4, e = std::min(stc->rule50, stc->pliesFromNull);
+ int i = 4, end = std::min(stc->rule50, stc->pliesFromNull);
- if (e < i)
+ if (end < i)
return false;
- StateInfo* stp = st->previous->previous;
+ StateInfo* stp = stc->previous->previous;
do {
stp = stp->previous->previous;
return true;
i += 2;
- } while (i <= e);
+ } while (i <= end);
stc = stc->previous;
}
}
+/// Position::has_game_cycle() tests if the position has a move which draws by repetition,
+/// or an earlier position has a move that directly reaches the current position.
+
+bool Position::has_game_cycle(int ply) const {
+
+ int j;
+
+ int end = std::min(st->rule50, st->pliesFromNull);
+
+ if (end < 3)
+ return false;
+
+ Key originalKey = st->key;
+ StateInfo* stp = st->previous;
+
+ for (int i = 3; i <= end; i += 2)
+ {
+ stp = stp->previous->previous;
+
+ Key moveKey = originalKey ^ stp->key;
+ if ( (j = H1(moveKey), cuckoo[j] == moveKey)
+ || (j = H2(moveKey), cuckoo[j] == moveKey))
+ {
+ Move move = cuckooMove[j];
+ Square s1 = from_sq(move);
+ Square s2 = to_sq(move);
+
+ if (!(between_bb(s1, s2) & pieces()))
+ {
+ // In the cuckoo table, both moves Rc1c5 and Rc5c1 are stored in the same
+ // location. We select the legal one by reversing the move variable if necessary.
+ if (empty(s1))
+ move = make_move(s2, s1);
+
+ if (ply > i)
+ return true;
+
+ // For repetitions before or at the root, require one more
+ StateInfo* next_stp = stp;
+ for (int k = i + 2; k <= end; k += 2)
+ {
+ next_stp = next_stp->previous->previous;
+ if (next_stp->key == stp->key)
+ return true;
+ }
+ }
+ }
+ }
+ return false;
+}
+
+
/// Position::flip() flips position with the white and black sides reversed. This
/// is only useful for debugging e.g. for finding evaluation symmetry bugs.