castleRightsMask[make_square(initialQRFile, RANK_8)] ^= BLACK_OOO;
find_checkers();
- find_pinned();
st->key = compute_key();
st->pawnKey = compute_pawn_key();
}
+/// Position:pinned_pieces() returns a bitboard of all pinned (against the
+/// king) pieces for the given color.
+Bitboard Position::pinned_pieces(Color c) const {
+
+ Bitboard p;
+ Square ksq = king_square(c);
+ return hidden_checks<ROOK, true>(c, ksq, p) | hidden_checks<BISHOP, true>(c, ksq, p);
+}
+
+
+/// Position:discovered_check_candidates() returns a bitboard containing all
+/// pieces for the given side which are candidates for giving a discovered
+/// check. The code is almost the same as the function for finding pinned
+/// pieces.
+
+Bitboard Position::discovered_check_candidates(Color c) const {
+
+ Bitboard p;
+ Square ksq = king_square(opposite_color(c));
+ return hidden_checks<ROOK, false>(c, ksq, p) | hidden_checks<BISHOP, false>(c, ksq, p);
+}
+
+
/// Position:hidden_checks<>() 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 pinned pieces of opposite color
}
-/// Position:find_pinned() computes the pinned, pinners and dcCandidates
-/// bitboards for both colors. Bitboard checkersBB must be already updated.
-
-void Position::find_pinned() {
+/// Position::pl_move_is_legal() tests whether a pseudo-legal move is legal
- Bitboard p1, p2;
- Square ksq;
+bool Position::pl_move_is_legal(Move m) const {
- for (Color c = WHITE; c <= BLACK; c++)
- {
- ksq = king_square(c);
- st->pinned[c] = hidden_checks<ROOK, true>(c, ksq, p1) | hidden_checks<BISHOP, true>(c, ksq, p2);
- st->pinners[c] = p1 | p2;
- ksq = king_square(opposite_color(c));
- st->dcCandidates[c] = hidden_checks<ROOK, false>(c, ksq, p1) | hidden_checks<BISHOP, false>(c, ksq, p2);
- }
+ return pl_move_is_legal(m, pinned_pieces(side_to_move()));
}
-
-/// Position::pl_move_is_legal() tests whether a pseudo-legal move is legal
-
-bool Position::pl_move_is_legal(Move m) const {
+bool Position::pl_move_is_legal(Move m, Bitboard pinned) const {
assert(is_ok());
assert(move_is_ok(m));
+ assert(pinned == pinned_pieces(side_to_move()));
// If we're in check, all pseudo-legal moves are legal, because our
// check evasion generator only generates true legal moves.
// 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 ( !bit_is_set(pinned_pieces(us), from)
+ return ( !bit_is_set(pinned, from)
|| (direction_between_squares(from, ksq) == direction_between_squares(move_to(m), ksq)));
}
bool Position::move_is_check(Move m) const {
+ Bitboard dc = discovered_check_candidates(side_to_move());
+ return move_is_check(m, dc);
+}
+
+bool Position::move_is_check(Move m, Bitboard dcCandidates) const {
+
assert(is_ok());
assert(move_is_ok(m));
+ assert(dcCandidates == discovered_check_candidates(side_to_move()));
Color us = side_to_move();
Color them = opposite_color(us);
Square from = move_from(m);
Square to = move_to(m);
Square ksq = king_square(them);
- Bitboard dcCandidates = discovered_check_candidates(us);
assert(color_of_piece_on(from) == us);
assert(piece_on(ksq) == piece_of_color_and_type(them, KING));
}
-/// Position::update_checkers() is a private method to udpate chekers info
+/// 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,
}
-/// Position::init_new_state() copies from the current state the fields
-/// that will be updated incrementally, skips the fields, like bitboards
-/// that will be recalculated form scratch anyway.
-
-void Position::init_new_state(StateInfo& newSt) {
-
- newSt.key = st->key;
- newSt.pawnKey = st->pawnKey;
- newSt.materialKey = st->materialKey;
- newSt.castleRights = st->castleRights;
- newSt.rule50 = st->rule50;
- newSt.epSquare = st->epSquare;
- newSt.mgValue = st->mgValue;
- newSt.egValue = st->egValue;
- newSt.capture = NO_PIECE_TYPE;
- newSt.previous = st;
-}
-
-
/// 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()));
+}
+
+void Position::do_move(Move m, StateInfo& newSt, Bitboard dcCandidates) {
+
assert(is_ok());
assert(move_is_ok(m));
- // Get now the current (before to move) dc candidates that we will use
- // in update_checkers().
- Bitboard oldDcCandidates = discovered_check_candidates(side_to_move());
-
// Copy some fields of old state to our new StateInfo object (except the
// captured piece, which is taken care of later) and switch state pointer
// to point to the new, ready to be updated, state.
- init_new_state(newSt);
+ newSt = *st;
+ newSt.capture = NO_PIECE_TYPE;
+ newSt.previous = st;
st = &newSt;
// Save the current key to the history[] array, in order to be able to
Square ksq = king_square(them);
switch (piece)
{
- case PAWN: update_checkers<PAWN>(&st->checkersBB, ksq, from, to, oldDcCandidates); break;
- case KNIGHT: update_checkers<KNIGHT>(&st->checkersBB, ksq, from, to, oldDcCandidates); break;
- case BISHOP: update_checkers<BISHOP>(&st->checkersBB, ksq, from, to, oldDcCandidates); break;
- case ROOK: update_checkers<ROOK>(&st->checkersBB, ksq, from, to, oldDcCandidates); break;
- case QUEEN: update_checkers<QUEEN>(&st->checkersBB, ksq, from, to, oldDcCandidates); break;
- case KING: update_checkers<KING>(&st->checkersBB, ksq, from, to, oldDcCandidates); break;
+ 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;
}
}
// Finish
- find_pinned();
st->key ^= zobSideToMove;
sideToMove = opposite_color(sideToMove);
gamePly++;
/// Position::see() is a static exchange evaluator: It tries to estimate the
-/// material gain or loss resulting from a move. There are three versions of
+/// material gain or loss resulting from a move. There are three versions of
/// this function: One which takes a destination square as input, one takes a
/// move, and one which takes a 'from' and a 'to' square. The function does
/// not yet understand promotions captures.
swapList[0] = seeValues[capture];
do {
- // Locate the least valuable attacker for the side to move. The loop
+ // Locate the least valuable attacker for the side to move. The loop
// below looks like it is potentially infinite, but it isn't. We know
// that the side to move still has at least one attacker left.
for (pt = PAWN; !(attackers & pieces_of_color_and_type(c, pt)); pt++)
}
+/// Position::setStartState() copies the content of the argument
+/// 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) {
+
+ startState = s;
+ st = &startState;
+}
+
+
/// Position::clear() erases the position object to a pristine state, with an
/// empty board, white to move, and no castling rights.
projects / stockfish / blobdiff