PRNG rng(1070372);

for (Piece pc : Pieces)

for (Square s = SQ_A1; s <= SQ_H8; ++s)

Zobrist::psq[pc][s] = rng.rand<Key>();

for (File f = FILE_A; f <= FILE_H; ++f)

Zobrist::enpassant[f] = rng.rand<Key>();

for (int cr = NO_CASTLING; cr <= ANY_CASTLING; ++cr)

Zobrist::castling[cr] = rng.rand<Key>();

Zobrist::side = rng.rand<Key>();

Zobrist::noPawns = rng.rand<Key>();

// Prepare the cuckoo tables

cuckoo.fill(0);

cuckooMove.fill(Move::none());

[[maybe_unused]] 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 ((type_of(pc) != PAWN) && (attacks_bb(type_of(pc), s1, 0) & s2))

{

Move move = 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);

Square kfrom = square<KING>(c);

CastlingRights cr = c & (kfrom < rfrom ? KING_SIDE : QUEEN_SIDE);

st->castlingRights |= cr;

castlingRightsMask[kfrom] |= cr;

castlingRightsMask[rfrom] |= cr;

castlingRookSquare[cr] = rfrom;

Square kto = relative_square(c, cr & KING_SIDE ? SQ_G1 : SQ_C1);

Square rto = relative_square(c, cr & KING_SIDE ? SQ_F1 : SQ_D1);

castlingPath[cr] = (between_bb(rfrom, rto) | between_bb(kfrom, kto)) & ~(kfrom | rfrom);

update_slider_blockers(WHITE);

update_slider_blockers(BLACK);

Square ksq = square<KING>(~sideToMove);

st->checkSquares[PAWN] = pawn_attacks_bb(~sideToMove, ksq);

st->checkSquares[KNIGHT] = attacks_bb<KNIGHT>(ksq);

st->checkSquares[BISHOP] = attacks_bb<BISHOP>(ksq, pieces());

st->checkSquares[ROOK] = attacks_bb<ROOK>(ksq, pieces());

st->checkSquares[QUEEN] = st->checkSquares[BISHOP] | st->checkSquares[ROOK];

st->checkSquares[KING] = 0;

st->key = st->materialKey = 0;

st->pawnKey = Zobrist::noPawns;

st->nonPawnMaterial[WHITE] = st->nonPawnMaterial[BLACK] = VALUE_ZERO;

st->checkersBB = attackers_to(square<KING>(sideToMove)) & pieces(~sideToMove);

set_check_info();

for (Bitboard b = pieces(); b;)

{

Square s = pop_lsb(b);

Piece pc = piece_on(s);

st->key ^= Zobrist::psq[pc][s];

if (type_of(pc) == PAWN)

st->pawnKey ^= Zobrist::psq[pc][s];

else if (type_of(pc) != KING)

st->nonPawnMaterial[color_of(pc)] += PieceValue[pc];

}

if (st->epSquare != SQ_NONE)

st->key ^= Zobrist::enpassant[file_of(st->epSquare)];

if (sideToMove == BLACK)

st->key ^= Zobrist::side;

st->key ^= Zobrist::castling[st->castlingRights];

for (Piece pc : Pieces)

for (int cnt = 0; cnt < pieceCount[pc]; ++cnt)

st->materialKey ^= Zobrist::psq[pc][cnt];

int emptyCnt;

std::ostringstream ss;

for (Rank r = RANK_8; r >= RANK_1; --r)

{

for (File f = FILE_A; f <= FILE_H; ++f)

{

for (emptyCnt = 0; f <= FILE_H && empty(make_square(f, r)); ++f)

++emptyCnt;

if (emptyCnt)

ss << emptyCnt;

if (f <= FILE_H)

ss << PieceToChar[piece_on(make_square(f, r))];

}

if (r > RANK_1)

ss << '/';

}

ss << (sideToMove == WHITE ? " w " : " b ");

if (can_castle(WHITE_OO))

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_OOO))) : 'Q');

if (can_castle(BLACK_OO))

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_OOO))) : 'q');

if (!can_castle(ANY_CASTLING))

ss << '-';

ss << (ep_square() == SQ_NONE ? " - " : " " + UCIEngine::square(ep_square()) + " ")

<< st->rule50 << " " << 1 + (gamePly - (sideToMove == BLACK)) / 2;

return ss.str();

Square ksq = square<KING>(c);

st->blockersForKing[c] = 0;

st->pinners[~c] = 0;

// Snipers are sliders that attack 's' when a piece and other snipers are removed

Bitboard snipers = ((attacks_bb<ROOK>(ksq) & pieces(QUEEN, ROOK))

| (attacks_bb<BISHOP>(ksq) & pieces(QUEEN, BISHOP)))

& pieces(~c);

Bitboard occupancy = pieces() ^ snipers;

while (snipers)

{

Square sniperSq = pop_lsb(snipers);

Bitboard b = between_bb(ksq, sniperSq) & occupancy;

if (b && !more_than_one(b))

{

st->blockersForKing[c] |= b;

if (b & pieces(c))

st->pinners[~c] |= sniperSq;

}

}

return (pawn_attacks_bb(BLACK, s) & pieces(WHITE, PAWN))

| (pawn_attacks_bb(WHITE, s) & pieces(BLACK, PAWN))

| (attacks_bb<KNIGHT>(s) & pieces(KNIGHT))

| (attacks_bb<ROOK>(s, occupied) & pieces(ROOK, QUEEN))

| (attacks_bb<BISHOP>(s, occupied) & pieces(BISHOP, QUEEN))

| (attacks_bb<KING>(s) & pieces(KING));

assert(m.is_ok());

Color us = sideToMove;

Square from = m.from_sq();

Square to = m.to_sq();

assert(color_of(moved_piece(m)) == us);

assert(piece_on(square<KING>(us)) == make_piece(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 after

// the move is made.

if (m.type_of() == EN_PASSANT)

{

Square ksq = square<KING>(us);

Square capsq = to - pawn_push(us);

Bitboard occupied = (pieces() ^ from ^ capsq) | to;

assert(to == ep_square());

assert(moved_piece(m) == make_piece(us, PAWN));

assert(piece_on(capsq) == make_piece(~us, PAWN));

assert(piece_on(to) == NO_PIECE);

return !(attacks_bb<ROOK>(ksq, occupied) & pieces(~us, QUEEN, ROOK))

&& !(attacks_bb<BISHOP>(ksq, occupied) & pieces(~us, QUEEN, BISHOP));

}

// Castling moves generation does not check if the castling path is clear of

// enemy attacks, it is delayed at a later time: now!

if (m.type_of() == 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 if the Rook blocks some checks.

// For instance an enemy queen in SQ_A1 when castling rook is in SQ_B1.

return !chess960 || !(blockers_for_king(us) & m.to_sq());

}

// 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 !(attackers_to(to, pieces() ^ from) & 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, square<KING>(us));

Color us = sideToMove;

Square from = m.from_sq();

Square to = m.to_sq();

Piece pc = moved_piece(m);

// Use a slower but simpler function for uncommon cases

// yet we skip the legality check of MoveList<LEGAL>().

if (m.type_of() != NORMAL)

return checkers() ? MoveList<EVASIONS>(*this).contains(m)

: MoveList<NON_EVASIONS>(*this).contains(m);

// Is not a promotion, so the promotion piece must be empty

assert(m.promotion_type() - KNIGHT == NO_PIECE_TYPE);

// If the 'from' square is not occupied by a piece belonging to the side to

// move, the move is obviously not legal.

if (pc == NO_PIECE || color_of(pc) != us)

return false;

// The destination square cannot be occupied by a friendly piece

if (pieces(us) & to)

return false;

// Handle the special case of a pawn move

if (type_of(pc) == PAWN)

{

// We have already handled promotion moves, so destination cannot be on the 8th/1st rank

if ((Rank8BB | Rank1BB) & to)

return false;

if (!(pawn_attacks_bb(us, from) & pieces(~us) & to) // Not a capture

&& !((from + pawn_push(us) == to) && empty(to)) // Not a single push

&& !((from + 2 * pawn_push(us) == to) // Not a double push

&& (relative_rank(us, from) == RANK_2) && empty(to) && empty(to - pawn_push(us))))

return false;

}

else if (!(attacks_bb(type_of(pc), from, pieces()) & to))

return false;

// Evasions generator already takes care to avoid some kind of illegal moves

// and legal() relies on this. We therefore have to take care that the same

// kind of moves are filtered out here.

if (checkers())

{

if (type_of(pc) != KING)

{

// Double check? In this case, a king move is required

if (more_than_one(checkers()))

return false;

// Our move must be a blocking interposition or a capture of the checking piece

if (!(between_bb(square<KING>(us), lsb(checkers())) & to))

return false;

}

// In case of king moves under check we have to remove the king so as to catch

// invalid moves like b1a1 when opposite queen is on c1.

else if (attackers_to(to, pieces() ^ from) & pieces(~us))

return false;

}

return true;

assert(m.is_ok());

assert(color_of(moved_piece(m)) == sideToMove);

Square from = m.from_sq();

Square to = m.to_sq();

// Is there a direct check?

if (check_squares(type_of(piece_on(from))) & to)

return true;

// Is there a discovered check?

if (blockers_for_king(~sideToMove) & from)

return !aligned(from, to, square<KING>(~sideToMove)) || m.type_of() == CASTLING;

switch (m.type_of())

{

case NORMAL :

return false;

case PROMOTION :

return attacks_bb(m.promotion_type(), to, pieces() ^ from) & square<KING>(~sideToMove);

// En passant capture with check? We have already handled the case of direct

// checks and ordinary discovered check, so the only case we need to handle

// is the unusual case of a discovered check through the captured pawn.

case EN_PASSANT : {

Square capsq = make_square(file_of(to), rank_of(from));

Bitboard b = (pieces() ^ from ^ capsq) | to;

return (attacks_bb<ROOK>(square<KING>(~sideToMove), b) & pieces(sideToMove, QUEEN, ROOK))

| (attacks_bb<BISHOP>(square<KING>(~sideToMove), b)

& pieces(sideToMove, QUEEN, BISHOP));

}

default : //CASTLING

{

// Castling is encoded as 'king captures the rook'

Square rto = relative_square(sideToMove, to > from ? SQ_F1 : SQ_D1);

return check_squares(ROOK) & rto;

}

}

assert(m.is_ok());

assert(&newSt != st);

Key k = st->key ^ Zobrist::side;

// Copy some fields of the old state to our new StateInfo object except the

// ones which are going to be recalculated from scratch anyway and then switch

// our state pointer to point to the new (ready to be updated) state.

std::memcpy(&newSt, st, offsetof(StateInfo, key));

newSt.previous = st;

st = &newSt;

// Increment ply counters. In particular, rule50 will be reset to zero later on

// in case of a capture or a pawn move.

++gamePly;

++st->rule50;

++st->pliesFromNull;

// Used by NNUE

st->accumulatorBig.computed[WHITE] = st->accumulatorBig.computed[BLACK] =

st->accumulatorSmall.computed[WHITE] = st->accumulatorSmall.computed[BLACK] = false;

auto& dp = st->dirtyPiece;

dp.dirty_num = 1;

Color us = sideToMove;

Color them = ~us;

Square from = m.from_sq();

Square to = m.to_sq();

Piece pc = piece_on(from);

Piece captured = m.type_of() == EN_PASSANT ? make_piece(them, PAWN) : piece_on(to);

assert(color_of(pc) == us);

assert(captured == NO_PIECE || color_of(captured) == (m.type_of() != CASTLING ? them : us));

assert(type_of(captured) != KING);

if (m.type_of() == CASTLING)

{

assert(pc == make_piece(us, KING));

assert(captured == make_piece(us, ROOK));

Square rfrom, rto;

do_castling<true>(us, from, to, rfrom, rto);

k ^= Zobrist::psq[captured][rfrom] ^ Zobrist::psq[captured][rto];

captured = NO_PIECE;

}

if (captured)

{

Square capsq = to;

// If the captured piece is a pawn, update pawn hash key, otherwise

// update non-pawn material.

if (type_of(captured) == PAWN)

{

if (m.type_of() == EN_PASSANT)

{

capsq -= pawn_push(us);

assert(pc == make_piece(us, PAWN));

assert(to == st->epSquare);

assert(relative_rank(us, to) == RANK_6);

assert(piece_on(to) == NO_PIECE);

assert(piece_on(capsq) == make_piece(them, PAWN));

}

st->pawnKey ^= Zobrist::psq[captured][capsq];

}

else

st->nonPawnMaterial[them] -= PieceValue[captured];

dp.dirty_num = 2; // 1 piece moved, 1 piece captured

dp.piece[1] = captured;

dp.from[1] = capsq;

dp.to[1] = SQ_NONE;

// Update board and piece lists

remove_piece(capsq);

k ^= Zobrist::psq[captured][capsq];

st->materialKey ^= Zobrist::psq[captured][pieceCount[captured]];

// Reset rule 50 counter

st->rule50 = 0;

}

// Update hash key

k ^= Zobrist::psq[pc][from] ^ Zobrist::psq[pc][to];

// Reset en passant square

if (st->epSquare != SQ_NONE)

{

k ^= Zobrist::enpassant[file_of(st->epSquare)];

st->epSquare = SQ_NONE;

}

// Update castling rights if needed

if (st->castlingRights && (castlingRightsMask[from] | castlingRightsMask[to]))

{

k ^= Zobrist::castling[st->castlingRights];

st->castlingRights &= ~(castlingRightsMask[from] | castlingRightsMask[to]);

k ^= Zobrist::castling[st->castlingRights];

}

// Move the piece. The tricky Chess960 castling is handled earlier

if (m.type_of() != CASTLING)

{

dp.piece[0] = pc;

dp.from[0] = from;

dp.to[0] = to;

move_piece(from, to);

}

// If the moving piece is a pawn do some special extra work

if (type_of(pc) == PAWN)

{

// Set en passant square if the moved pawn can be captured

if ((int(to) ^ int(from)) == 16

&& (pawn_attacks_bb(us, to - pawn_push(us)) & pieces(them, PAWN)))

{

st->epSquare = to - pawn_push(us);

k ^= Zobrist::enpassant[file_of(st->epSquare)];

}

else if (m.type_of() == PROMOTION)

{

Piece promotion = make_piece(us, m.promotion_type());

assert(relative_rank(us, to) == RANK_8);

assert(type_of(promotion) >= KNIGHT && type_of(promotion) <= QUEEN);

remove_piece(to);

put_piece(promotion, to);

// Promoting pawn to SQ_NONE, promoted piece from SQ_NONE

dp.to[0] = SQ_NONE;

dp.piece[dp.dirty_num] = promotion;

dp.from[dp.dirty_num] = SQ_NONE;

dp.to[dp.dirty_num] = to;

dp.dirty_num++;

// Update hash keys

k ^= Zobrist::psq[pc][to] ^ Zobrist::psq[promotion][to];

st->pawnKey ^= Zobrist::psq[pc][to];

st->materialKey ^=

Zobrist::psq[promotion][pieceCount[promotion] - 1] ^ Zobrist::psq[pc][pieceCount[pc]];

// Update material

st->nonPawnMaterial[us] += PieceValue[promotion];

}

// Update pawn hash key

st->pawnKey ^= Zobrist::psq[pc][from] ^ Zobrist::psq[pc][to];

// Reset rule 50 draw counter

st->rule50 = 0;

}

// Set capture piece

st->capturedPiece = captured;

// Update the key with the final value

st->key = k;

// Calculate checkers bitboard (if move gives check)

st->checkersBB = givesCheck ? attackers_to(square<KING>(them)) & pieces(us) : 0;

sideToMove = ~sideToMove;

// Update king attacks used for fast check detection

set_check_info();

// Calculate the repetition info. It is the ply distance from the previous

// occurrence of the same position, negative in the 3-fold case, or zero

// if the position was not repeated.

st->repetition = 0;

int end = std::min(st->rule50, st->pliesFromNull);

if (end >= 4)

{

StateInfo* stp = st->previous->previous;

for (int i = 4; i <= end; i += 2)

{

stp = stp->previous->previous;

if (stp->key == st->key)

{

st->repetition = stp->repetition ? -i : i;

break;

}

}

}

assert(pos_is_ok());

assert(m.is_ok());

sideToMove = ~sideToMove;

Color us = sideToMove;

Square from = m.from_sq();

Square to = m.to_sq();

Piece pc = piece_on(to);

assert(empty(from) || m.type_of() == CASTLING);

assert(type_of(st->capturedPiece) != KING);

if (m.type_of() == PROMOTION)

{

assert(relative_rank(us, to) == RANK_8);

assert(type_of(pc) == m.promotion_type());

assert(type_of(pc) >= KNIGHT && type_of(pc) <= QUEEN);

remove_piece(to);

pc = make_piece(us, PAWN);

put_piece(pc, to);

}

if (m.type_of() == CASTLING)

{

Square rfrom, rto;

do_castling<false>(us, from, to, rfrom, rto);

}

else

{

move_piece(to, from); // Put the piece back at the source square

if (st->capturedPiece)

{

Square capsq = to;

if (m.type_of() == EN_PASSANT)

{

capsq -= pawn_push(us);

assert(type_of(pc) == PAWN);

assert(to == st->previous->epSquare);

assert(relative_rank(us, to) == RANK_6);

assert(piece_on(capsq) == NO_PIECE);

assert(st->capturedPiece == make_piece(~us, PAWN));

}

put_piece(st->capturedPiece, capsq); // Restore the captured piece

}

}

// Finally point our state pointer back to the previous state

st = st->previous;

--gamePly;

assert(pos_is_ok());

bool kingSide = to > from;

rfrom = to; // Castling is encoded as "king captures friendly rook"

rto = relative_square(us, kingSide ? SQ_F1 : SQ_D1);

to = relative_square(us, kingSide ? SQ_G1 : SQ_C1);

if (Do)

{

auto& dp = st->dirtyPiece;

dp.piece[0] = make_piece(us, KING);

dp.from[0] = from;

dp.to[0] = to;

dp.piece[1] = make_piece(us, ROOK);

dp.from[1] = rfrom;

dp.to[1] = rto;

dp.dirty_num = 2;

}

// Remove both pieces first since squares could overlap in Chess960

remove_piece(Do ? from : to);

remove_piece(Do ? rfrom : rto);

board[Do ? from : to] = board[Do ? rfrom : rto] =

NO_PIECE; // remove_piece does not do this for us

put_piece(make_piece(us, KING), Do ? to : from);

put_piece(make_piece(us, ROOK), Do ? rto : rfrom);

assert(!checkers());

assert(&newSt != st);

std::memcpy(&newSt, st, offsetof(StateInfo, accumulatorBig));

newSt.previous = st;

st = &newSt;

st->dirtyPiece.dirty_num = 0;

st->dirtyPiece.piece[0] = NO_PIECE; // Avoid checks in UpdateAccumulator()

st->accumulatorBig.computed[WHITE] = st->accumulatorBig.computed[BLACK] =

st->accumulatorSmall.computed[WHITE] = st->accumulatorSmall.computed[BLACK] = false;

if (st->epSquare != SQ_NONE)

{

st->key ^= Zobrist::enpassant[file_of(st->epSquare)];

st->epSquare = SQ_NONE;

}

st->key ^= Zobrist::side;

++st->rule50;

prefetch(tt.first_entry(key()));

st->pliesFromNull = 0;

sideToMove = ~sideToMove;

set_check_info();

st->repetition = 0;

assert(pos_is_ok());

assert(!checkers());

st = st->previous;