#include <fstream>
#include <iostream>
#include <sstream>
+#include <algorithm>
#include "bitcount.h"
#include "movegen.h"
checkSq[BISHOP] = pos.attacks_from<BISHOP>(ksq);
checkSq[ROOK] = pos.attacks_from<ROOK>(ksq);
checkSq[QUEEN] = checkSq[BISHOP] | checkSq[ROOK];
- checkSq[KING] = EmptyBoardBB;
+ checkSq[KING] = 0;
}
/// or the FEN string, we want the new born Position object do not depend
/// on any external data so we detach state pointer from the source one.
-Position::Position(const Position& pos, int th) {
+void Position::copy(const Position& pos, int th) {
memcpy(this, &pos, sizeof(Position));
+ startState = *st;
+ st = &startState;
threadID = th;
nodes = 0;
// Convert from fullmove starting from 1 to ply starting from 0,
// handle also common incorrect FEN with fullmove = 0.
- startPosPly = Max(2 * (startPosPly - 1), 0) + int(sideToMove == BLACK);
+ startPosPly = std::max(2 * (startPosPly - 1), 0) + int(sideToMove == BLACK);
st->key = compute_key();
st->pawnKey = compute_pawn_key();
template Bitboard Position::hidden_checkers<false>() const;
-/// Position::attackers_to() computes a bitboard of all pieces which attacks a
+/// Position::attackers_to() computes a bitboard of all pieces which attack a
/// given square. Slider attacks use occ bitboard as occupancy.
Bitboard Position::attackers_to(Square s, Bitboard occ) const {
assert(square_is_ok(s));
Bitboard occ, xray;
- Square f = move_from(m), t = move_to(m);
+ Square from = move_from(m);
+ Square to = move_to(m);
+ Piece piece = piece_on(from);
- assert(!square_is_empty(f));
+ assert(!square_is_empty(from));
- if (bit_is_set(attacks_from(piece_on(f), t), s))
+ // Update occupancy as if the piece is moving
+ occ = occupied_squares();
+ do_move_bb(&occ, make_move_bb(from, to));
+
+ // The piece moved in 'to' attacks the square 's' ?
+ if (bit_is_set(attacks_from(piece, to, occ), s))
return true;
- // Move the piece and scan for X-ray attacks behind it
- occ = occupied_squares();
- do_move_bb(&occ, make_move_bb(f, t));
- xray = ( (rook_attacks_bb(s, occ) & pieces(ROOK, QUEEN))
- |(bishop_attacks_bb(s, occ) & pieces(BISHOP, QUEEN)))
- & pieces(color_of(piece_on(f)));
+ // Scan for possible X-ray attackers behind the moved piece
+ xray = (rook_attacks_bb(s, occ) & pieces(ROOK, QUEEN, color_of(piece)))
+ |(bishop_attacks_bb(s, occ) & pieces(BISHOP, QUEEN, color_of(piece)));
- // If we have attacks we need to verify that are caused by our move
- // and are not already existent ones.
+ // Verify attackers are triggered by our move and not already existing
return xray && (xray ^ (xray & attacks_from<QUEEN>(s)));
}
assert(&newSt != st);
nodes++;
- Key key = st->key;
+ Key k = st->key;
// Copy some fields of old state to our new StateInfo object except the ones
// which are recalculated from scratch anyway, then switch our state pointer
st = &newSt;
// Update side to move
- key ^= zobSideToMove;
+ k ^= zobSideToMove;
// Increment the 50 moves rule draw counter. Resetting it to zero in the
// case of non-reversible moves is taken care of later.
if (is_castle(m))
{
- st->key = key;
+ st->key = k;
do_castle_move<true>(m);
return;
}
pieceList[them][capture][pieceCount[them][capture]] = SQ_NONE;
// Update hash keys
- key ^= zobrist[them][capture][capsq];
+ k ^= zobrist[them][capture][capsq];
st->materialKey ^= zobrist[them][capture][pieceCount[them][capture]];
// Update incremental scores
}
// Update hash key
- key ^= zobrist[us][pt][from] ^ zobrist[us][pt][to];
+ k ^= zobrist[us][pt][from] ^ zobrist[us][pt][to];
// Reset en passant square
if (st->epSquare != SQ_NONE)
{
- key ^= zobEp[st->epSquare];
+ k ^= zobEp[st->epSquare];
st->epSquare = SQ_NONE;
}
if ( st->castleRights != CASTLES_NONE
&& (castleRightsMask[from] & castleRightsMask[to]) != ALL_CASTLES)
{
- key ^= zobCastle[st->castleRights];
+ k ^= zobCastle[st->castleRights];
st->castleRights &= castleRightsMask[from] & castleRightsMask[to];
- key ^= zobCastle[st->castleRights];
+ k ^= zobCastle[st->castleRights];
}
// Prefetch TT access as soon as we know key is updated
- prefetch((char*)TT.first_entry(key));
+ prefetch((char*)TT.first_entry(k));
// Move the piece
Bitboard move_bb = make_move_bb(from, to);
&& (attacks_from<PAWN>(from + pawn_push(us), us) & pieces(PAWN, them)))
{
st->epSquare = Square((from + to) / 2);
- key ^= zobEp[st->epSquare];
+ k ^= zobEp[st->epSquare];
}
if (is_promotion(m))
pieceList[us][promotion][index[to]] = to;
// Update hash keys
- key ^= zobrist[us][PAWN][to] ^ zobrist[us][promotion][to];
+ k ^= zobrist[us][PAWN][to] ^ zobrist[us][promotion][to];
st->pawnKey ^= zobrist[us][PAWN][to];
st->materialKey ^= zobrist[us][promotion][pieceCount[us][promotion]++]
^ zobrist[us][PAWN][pieceCount[us][PAWN]];
st->capturedType = capture;
// Update the key with the final value
- st->key = key;
+ st->key = k;
// Update checkers bitboard, piece must be already moved
- st->checkersBB = EmptyBoardBB;
+ st->checkersBB = 0;
if (moveIsCheck)
{
// Having built the swap list, we negamax through it to find the best
// achievable score from the point of view of the side to move.
while (--slIndex)
- swapList[slIndex-1] = Min(-swapList[slIndex], swapList[slIndex-1]);
+ swapList[slIndex-1] = std::min(-swapList[slIndex], swapList[slIndex-1]);
return swapList[0];
}
// Draw by repetition?
if (!SkipRepetition)
{
- int i = 4, e = Min(st->rule50, st->pliesFromNull);
+ int i = 4, e = std::min(st->rule50, st->pliesFromNull);
if (i <= e)
{
if (debugBitboards)
{
// The intersection of the white and black pieces must be empty
- if ((pieces(WHITE) & pieces(BLACK)) != EmptyBoardBB)
+ if (!(pieces(WHITE) & pieces(BLACK)))
return false;
// The union of the white and black pieces must be equal to all
projects / stockfish / blobdiff