/*
- Glaurung, a UCI chess playing engine.
- Copyright (C) 2004-2008 Tord Romstad
+ Stockfish, a UCI chess playing engine derived from Glaurung 2.1
+ Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+ Copyright (C) 2008 Marco Costalba
- Glaurung is free software: you can redistribute it and/or modify
+ Stockfish is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
- Glaurung is distributed in the hope that it will be useful,
+ Stockfish is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
Value Position::MgPieceSquareTable[16][64];
Value Position::EgPieceSquareTable[16][64];
-Piece_attacks_fn piece_attacks_fn[7];
////
//// Functions
////
-void init_piece_attacks_fn() {
-
- piece_attacks_fn[KNIGHT] = &Position::knight_attacks;
- piece_attacks_fn[BISHOP] = &Position::bishop_attacks;
- piece_attacks_fn[ROOK] = &Position::rook_attacks;
- piece_attacks_fn[QUEEN] = &Position::queen_attacks;
- piece_attacks_fn[KING] = &Position::king_attacks;
-}
-
/// Constructors
Position::Position(const Position &pos) {
/// Position::copy() creates a copy of the input position.
void Position::copy(const Position &pos) {
+
memcpy(this, &pos, sizeof(Position));
}
/// 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 b1, b2, pinned, pinners, sliders;
- Square ksq = king_square(c), s;
- Color them = opposite_color(c);
-
- pinned = EmptyBoardBB;
- b1 = occupied_squares();
-
- sliders = rooks_and_queens(them) & ~checkers();
- if(sliders & RookPseudoAttacks[ksq]) {
- b2 = rook_attacks(ksq) & pieces_of_color(c);
- pinners = rook_attacks_bb(ksq, b1 ^ b2) & sliders;
- while(pinners) {
- s = pop_1st_bit(&pinners);
- pinned |= (squares_between(s, ksq) & b2);
- }
- }
-
- sliders = bishops_and_queens(them) & ~checkers();
- if(sliders & BishopPseudoAttacks[ksq]) {
- b2 = bishop_attacks(ksq) & pieces_of_color(c);
- pinners = bishop_attacks_bb(ksq, b1 ^ b2) & sliders;
- while(pinners) {
- s = pop_1st_bit(&pinners);
- pinned |= (squares_between(s, ksq) & b2);
- }
- }
- return pinned;
+ Square ksq = king_square(c);
+ return hidden_checks<ROOK, true>(c, ksq) | hidden_checks<BISHOP, true>(c, ksq);
}
+
/// 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 b1, b2, dc, checkers, sliders;
- Square ksq = king_square(opposite_color(c)), s;
-
- dc = EmptyBoardBB;
- b1 = occupied_squares();
-
- sliders = rooks_and_queens(c);
- if(sliders & RookPseudoAttacks[ksq]) {
- b2 = rook_attacks(ksq) & pieces_of_color(c);
- checkers = rook_attacks_bb(ksq, b1 ^ b2) & sliders;
- while(checkers) {
- s = pop_1st_bit(&checkers);
- dc |= (squares_between(s, ksq) & b2);
- }
- }
- sliders = bishops_and_queens(c);
- if(sliders & BishopPseudoAttacks[ksq]) {
- b2 = bishop_attacks(ksq) & pieces_of_color(c);
- checkers = bishop_attacks_bb(ksq, b1 ^ b2) & sliders;
- while(checkers) {
- s = pop_1st_bit(&checkers);
- dc |= (squares_between(s, ksq) & b2);
- }
- }
+ Square ksq = king_square(opposite_color(c));
+ return hidden_checks<ROOK, false>(c, ksq) | hidden_checks<BISHOP, false>(c, ksq);
+}
+
+
+/// 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
+/// that are, indeed, the pieces candidate for a discovery check.
+template<PieceType Piece, bool FindPinned>
+Bitboard Position::hidden_checks(Color c, Square ksq) const {
- return dc;
+ Square s;
+ Bitboard sliders, result = EmptyBoardBB;
+
+ if (Piece == ROOK) // Resolved at compile time
+ sliders = rooks_and_queens(FindPinned ? opposite_color(c) : c) & RookPseudoAttacks[ksq];
+ else
+ sliders = bishops_and_queens(FindPinned ? opposite_color(c) : c) & BishopPseudoAttacks[ksq];
+
+ if (sliders && (!FindPinned || (sliders & ~checkersBB)))
+ {
+ // King blockers are candidate pinned pieces
+ Bitboard candidate_pinned = piece_attacks<Piece>(ksq) & pieces_of_color(c);
+
+ // Pinners are sliders, not checkers, that give check when
+ // candidate pinned are removed.
+ Bitboard pinners = (FindPinned ? sliders & ~checkersBB : sliders);
+
+ if (Piece == ROOK)
+ pinners &= rook_attacks_bb(ksq, occupied_squares() ^ candidate_pinned);
+ else
+ pinners &= bishop_attacks_bb(ksq, occupied_squares() ^ candidate_pinned);
+
+ // Finally for each pinner find the corresponding pinned piece (if same color of king)
+ // or discovery checker (if opposite color) among the candidates.
+ while (pinners)
+ {
+ s = pop_1st_bit(&pinners);
+ result |= (squares_between(s, ksq) & candidate_pinned);
+ }
+ }
+ return result;
}
/// given square.
bool Position::square_is_attacked(Square s, Color c) const {
- return
- (pawn_attacks(opposite_color(c), s) & pawns(c)) ||
- (knight_attacks(s) & knights(c)) ||
- (king_attacks(s) & kings(c)) ||
- (rook_attacks(s) & rooks_and_queens(c)) ||
- (bishop_attacks(s) & bishops_and_queens(c));
+
+ return (pawn_attacks(opposite_color(c), s) & pawns(c))
+ || (piece_attacks<KNIGHT>(s) & knights(c))
+ || (piece_attacks<KING>(s) & kings(c))
+ || (piece_attacks<ROOK>(s) & rooks_and_queens(c))
+ || (piece_attacks<BISHOP>(s) & bishops_and_queens(c));
}
/// attackers for one side.
Bitboard Position::attacks_to(Square s) const {
- return
- (black_pawn_attacks(s) & pawns(WHITE)) |
- (white_pawn_attacks(s) & pawns(BLACK)) |
- (knight_attacks(s) & pieces_of_type(KNIGHT)) |
- (rook_attacks(s) & rooks_and_queens()) |
- (bishop_attacks(s) & bishops_and_queens()) |
- (king_attacks(s) & pieces_of_type(KING));
+
+ return (pawn_attacks(BLACK, s) & pawns(WHITE))
+ | (pawn_attacks(WHITE, s) & pawns(BLACK))
+ | (piece_attacks<KNIGHT>(s) & pieces_of_type(KNIGHT))
+ | (piece_attacks<ROOK>(s) & rooks_and_queens())
+ | (piece_attacks<BISHOP>(s) & bishops_and_queens())
+ | (piece_attacks<KING>(s) & pieces_of_type(KING));
}
Bitboard Position::attacks_to(Square s, Color c) const {
+
return attacks_to(s) & pieces_of_color(c);
}
/// attacks square t.
bool Position::piece_attacks_square(Square f, Square t) const {
+
assert(square_is_ok(f));
assert(square_is_ok(t));
- switch(piece_on(f)) {
- case WP: return white_pawn_attacks_square(f, t);
- case BP: return black_pawn_attacks_square(f, t);
- case WN: case BN: return knight_attacks_square(f, t);
- case WB: case BB: return bishop_attacks_square(f, t);
- case WR: case BR: return rook_attacks_square(f, t);
- case WQ: case BQ: return queen_attacks_square(f, t);
- case WK: case BK: return king_attacks_square(f, t);
- default: return false;
+ switch (piece_on(f))
+ {
+ case WP: return pawn_attacks_square(WHITE, f, t);
+ case BP: return pawn_attacks_square(BLACK, f, t);
+ case WN: case BN: return piece_attacks_square<KNIGHT>(f, t);
+ case WB: case BB: return piece_attacks_square<BISHOP>(f, t);
+ case WR: case BR: return piece_attacks_square<ROOK>(f, t);
+ case WQ: case BQ: return piece_attacks_square<QUEEN>(f, t);
+ case WK: case BK: return piece_attacks_square<KING>(f, t);
+ default: return false;
}
+ return false;
+}
+
+
+/// Position::move_attacks_square() tests whether a move from the current
+/// position attacks a given square. Only attacks by the moving piece are
+/// considered; the function does not handle X-ray attacks.
+
+bool Position::move_attacks_square(Move m, Square s) const {
+ assert(move_is_ok(m));
+ assert(square_is_ok(s));
+
+ Square f = move_from(m), t = move_to(m);
+
+ assert(square_is_occupied(f));
+
+ switch (piece_on(f))
+ {
+ case WP: return pawn_attacks_square(WHITE, t, s);
+ case BP: return pawn_attacks_square(BLACK, t, s);
+ case WN: case BN: return piece_attacks_square<KNIGHT>(t, s);
+ case WB: case BB: return piece_attacks_square<BISHOP>(t, s);
+ case WR: case BR: return piece_attacks_square<ROOK>(t, s);
+ case WQ: case BQ: return piece_attacks_square<QUEEN>(t, s);
+ case WK: case BK: return piece_attacks_square<KING>(t, s);
+ default: assert(false);
+ }
return false;
}
/// played, like in non-bitboard versions of Glaurung.
void Position::find_checkers() {
- checkersBB = attacks_to(king_square(side_to_move()),
- opposite_color(side_to_move()));
+
+ checkersBB = attacks_to(king_square(side_to_move()),opposite_color(side_to_move()));
}
/// Position::move_is_legal() tests whether a pseudo-legal move is legal.
/// There are two versions of this function: One which takes only a
/// move as input, and one which takes a move and a bitboard of pinned
-/// pieces. The latter function is faster, and should always be preferred
+/// pieces. The latter function is faster, and should always be preferred
/// when a pinned piece bitboard has already been computed.
bool Position::move_is_legal(Move m) const {
+
return move_is_legal(m, pinned_pieces(side_to_move()));
}
-
bool Position::move_is_legal(Move m, Bitboard pinned) const {
+
Color us, them;
Square ksq, from;
// If we're in check, all pseudo-legal moves are legal, because our
// check evasion generator only generates true legal moves.
- if(is_check()) return true;
+ if (is_check())
+ return true;
// Castling moves are checked for legality during move generation.
- if(move_is_castle(m)) return true;
+ if (move_is_castle(m))
+ return true;
us = side_to_move();
them = opposite_color(us);
-
from = move_from(m);
ksq = king_square(us);
// 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(move_is_ep(m)) {
- Square to = move_to(m);
- Square capsq = make_square(square_file(to), square_rank(from));
- Bitboard b = occupied_squares();
-
- assert(to == ep_square());
- assert(piece_on(from) == pawn_of_color(us));
- assert(piece_on(capsq) == pawn_of_color(them));
- assert(piece_on(to) == EMPTY);
-
- clear_bit(&b, from); clear_bit(&b, capsq); set_bit(&b, to);
- return
- (!(rook_attacks_bb(ksq, b) & rooks_and_queens(them)) &&
- !(bishop_attacks_bb(ksq, b) & bishops_and_queens(them)));
+ // after the move is made
+ if (move_is_ep(m))
+ {
+ Square to = move_to(m);
+ Square capsq = make_square(square_file(to), square_rank(from));
+ Bitboard b = occupied_squares();
+
+ assert(to == ep_square());
+ assert(piece_on(from) == pawn_of_color(us));
+ assert(piece_on(capsq) == pawn_of_color(them));
+ assert(piece_on(to) == EMPTY);
+
+ clear_bit(&b, from);
+ clear_bit(&b, capsq);
+ set_bit(&b, to);
+
+ return !(rook_attacks_bb(ksq, b) & rooks_and_queens(them))
+ && !(bishop_attacks_bb(ksq, b) & bishops_and_queens(them));
}
// If the moving piece is a king, check whether the destination
// square is attacked by the opponent.
- if(from == ksq) return !(square_is_attacked(move_to(m), them));
+ if (from == ksq)
+ return !(square_is_attacked(move_to(m), them));
// 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.
- if(!bit_is_set(pinned, from)) return true;
- if(direction_between_squares(from, ksq) ==
- direction_between_squares(move_to(m), ksq))
- return true;
+ if ( !bit_is_set(pinned, from)
+ || (direction_between_squares(from, ksq) == direction_between_squares(move_to(m), ksq)))
+ return true;
return false;
}
/// when a discovered check candidates bitboard has already been computed.
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 {
+
Color us, them;
Square ksq, from, to;
assert(is_ok());
assert(move_is_ok(m));
- assert(dcCandidates ==
- discovered_check_candidates(side_to_move()));
+ assert(dcCandidates == discovered_check_candidates(side_to_move()));
us = side_to_move();
them = opposite_color(us);
-
from = move_from(m);
to = move_to(m);
ksq = king_square(them);
+
assert(color_of_piece_on(from) == us);
assert(piece_on(ksq) == king_of_color(them));
- // Proceed according to the type of the moving piece:
- switch(type_of_piece_on(from)) {
+ // Proceed according to the type of the moving piece
+ switch (type_of_piece_on(from))
+ {
case PAWN:
- // Normal check?
- if(bit_is_set(pawn_attacks(them, ksq), to))
- return true;
- // Discovered check?
- else if(bit_is_set(dcCandidates, from) &&
- direction_between_squares(from, ksq) !=
- direction_between_squares(to, ksq))
- return true;
- // Promotion with check?
- else if(move_promotion(m)) {
- Bitboard b = occupied_squares();
- clear_bit(&b, from);
+
+ if (bit_is_set(pawn_attacks(them, ksq), to)) // Normal check?
+ return true;
+
+ if ( bit_is_set(dcCandidates, from) // Discovered check?
+ && (direction_between_squares(from, ksq) != direction_between_squares(to, ksq)))
+ return true;
+
+ if (move_promotion(m)) // Promotion with check?
+ {
+ Bitboard b = occupied_squares();
+ clear_bit(&b, from);
- switch(move_promotion(m)) {
- case KNIGHT:
- return knight_attacks_square(to, ksq);
- case BISHOP:
- return bit_is_set(bishop_attacks_bb(to, b), ksq);
- case ROOK:
- return bit_is_set(rook_attacks_bb(to, b), ksq);
- case QUEEN:
- return bit_is_set(queen_attacks_bb(to, b), ksq);
- default:
- assert(false);
+ switch (move_promotion(m))
+ {
+ case KNIGHT:
+ return bit_is_set(piece_attacks<KNIGHT>(to), ksq);
+ case BISHOP:
+ return bit_is_set(bishop_attacks_bb(to, b), ksq);
+ case ROOK:
+ return bit_is_set(rook_attacks_bb(to, b), ksq);
+ case QUEEN:
+ return bit_is_set(queen_attacks_bb(to, b), ksq);
+ default:
+ assert(false);
+ }
}
- }
- // En passant capture with check? We have already handled the case
- // of direct checks and ordinary discovered check, the only case we
- // need to handle is the unusual case of a discovered check through the
- // captured pawn.
- else if(move_is_ep(m)) {
- Square capsq = make_square(square_file(to), square_rank(from));
- Bitboard b = occupied_squares();
-
- clear_bit(&b, from); clear_bit(&b, capsq); set_bit(&b, to);
- return
- ((rook_attacks_bb(ksq, b) & rooks_and_queens(us)) ||
- (bishop_attacks_bb(ksq, b) & bishops_and_queens(us)));
- }
- return false;
+ // En passant capture with check? We have already handled the case
+ // of direct checks and ordinary discovered check, the only case we
+ // need to handle is the unusual case of a discovered check through the
+ // captured pawn.
+ else if (move_is_ep(m))
+ {
+ Square capsq = make_square(square_file(to), square_rank(from));
+ Bitboard b = occupied_squares();
+ clear_bit(&b, from);
+ clear_bit(&b, capsq);
+ set_bit(&b, to);
+ return (rook_attacks_bb(ksq, b) & rooks_and_queens(us))
+ ||(bishop_attacks_bb(ksq, b) & bishops_and_queens(us));
+ }
+ return false;
- case KNIGHT:
- // Discovered check?
- if(bit_is_set(dcCandidates, from))
- return true;
- // Normal check?
- else
- return bit_is_set(knight_attacks(ksq), to);
+ case KNIGHT:
+ return bit_is_set(dcCandidates, from) // Discovered check?
+ || bit_is_set(piece_attacks<KNIGHT>(ksq), to); // Normal check?
case BISHOP:
- // Discovered check?
- if(bit_is_set(dcCandidates, from))
- return true;
- // Normal check?
- else
- return bit_is_set(bishop_attacks(ksq), to);
+ return bit_is_set(dcCandidates, from) // Discovered check?
+ || bit_is_set(piece_attacks<BISHOP>(ksq), to); // Normal check?
case ROOK:
- // Discovered check?
- if(bit_is_set(dcCandidates, from))
- return true;
- // Normal check?
- else
- return bit_is_set(rook_attacks(ksq), to);
+ return bit_is_set(dcCandidates, from) // Discovered check?
+ || bit_is_set(piece_attacks<ROOK>(ksq), to); // Normal check?
case QUEEN:
- // Discovered checks are impossible!
- assert(!bit_is_set(dcCandidates, from));
- // Normal check?
- return bit_is_set(queen_attacks(ksq), to);
+ // Discovered checks are impossible!
+ assert(!bit_is_set(dcCandidates, from));
+ return bit_is_set(piece_attacks<QUEEN>(ksq), to); // Normal check?
case KING:
- // Discovered check?
- if(bit_is_set(dcCandidates, from) &&
- direction_between_squares(from, ksq) !=
- direction_between_squares(to, ksq))
- return true;
- // Castling with check?
- if(move_is_castle(m)) {
- Square kfrom, kto, rfrom, rto;
- Bitboard b = occupied_squares();
-
- kfrom = from;
- rfrom = to;
- if(rfrom > kfrom) {
- kto = relative_square(us, SQ_G1);
- rto = relative_square(us, SQ_F1);
- }
- else {
- kto = relative_square(us, SQ_C1);
- rto = relative_square(us, SQ_D1);
- }
-
- clear_bit(&b, kfrom); clear_bit(&b, rfrom);
- set_bit(&b, rto); set_bit(&b, kto);
+ // Discovered check?
+ if ( bit_is_set(dcCandidates, from)
+ && (direction_between_squares(from, ksq) != direction_between_squares(to, ksq)))
+ return true;
- return bit_is_set(rook_attacks_bb(rto, b), ksq);
- }
+ // Castling with check?
+ if (move_is_castle(m))
+ {
+ Square kfrom, kto, rfrom, rto;
+ Bitboard b = occupied_squares();
+ kfrom = from;
+ rfrom = to;
- return false;
+ if (rfrom > kfrom)
+ {
+ kto = relative_square(us, SQ_G1);
+ rto = relative_square(us, SQ_F1);
+ } else {
+ kto = relative_square(us, SQ_C1);
+ rto = relative_square(us, SQ_D1);
+ }
+ clear_bit(&b, kfrom);
+ clear_bit(&b, rfrom);
+ set_bit(&b, rto);
+ set_bit(&b, kto);
+ return bit_is_set(rook_attacks_bb(rto, b), ksq);
+ }
+ return false;
default:
- assert(false);
- return false;
+ assert(false);
}
-
assert(false);
return false;
}
/// position is a capture.
bool Position::move_is_capture(Move m) const {
- return
- color_of_piece_on(move_to(m)) == opposite_color(side_to_move())
- || move_is_ep(m);
-}
-
-
-/// Position::move_attacks_square() tests whether a move from the current
-/// position attacks a given square. Only attacks by the moving piece are
-/// considered; the function does not handle X-ray attacks.
-
-bool Position::move_attacks_square(Move m, Square s) const {
- assert(move_is_ok(m));
- assert(square_is_ok(s));
-
- Square f = move_from(m), t = move_to(m);
-
- assert(square_is_occupied(f));
- switch(piece_on(f)) {
- case WP: return white_pawn_attacks_square(t, s);
- case BP: return black_pawn_attacks_square(t, s);
- case WN: case BN: return knight_attacks_square(t, s);
- case WB: case BB: return bishop_attacks_square(t, s);
- case WR: case BR: return rook_attacks_square(t, s);
- case WQ: case BQ: return queen_attacks_square(t, s);
- case WK: case BK: return king_attacks_square(t, s);
- default: assert(false);
- }
-
- return false;
+ return color_of_piece_on(move_to(m)) == opposite_color(side_to_move())
+ || move_is_ep(m);
}
-
/// Position::backup() is called when making a move. All information
/// necessary to restore the position when the move is later unmade
/// is saved to an UndoInfo object. The function Position::restore
}
if(piece == PAWN) {
if(abs(int(to) - int(from)) == 16) {
- if((us == WHITE && (white_pawn_attacks(from + DELTA_N) &
+ if((us == WHITE && (pawn_attacks(WHITE, from + DELTA_N) &
pawns(BLACK))) ||
- (us == BLACK && (black_pawn_attacks(from + DELTA_S) &
+ (us == BLACK && (pawn_attacks(BLACK, from + DELTA_S) &
pawns(WHITE)))) {
epSquare = Square((int(from) + int(to)) / 2);
key ^= zobEp[epSquare];
set_bit(&checkersBB, to);
if(bit_is_set(dcCandidates, from))
checkersBB |=
- ((rook_attacks(ksq) & rooks_and_queens(us)) |
- (bishop_attacks(ksq) & bishops_and_queens(us)));
+ ((piece_attacks<ROOK>(ksq) & rooks_and_queens(us)) |
+ (piece_attacks<BISHOP>(ksq) & bishops_and_queens(us)));
break;
case KNIGHT:
- if(bit_is_set(knight_attacks(ksq), to))
+ if(bit_is_set(piece_attacks<KNIGHT>(ksq), to))
set_bit(&checkersBB, to);
if(bit_is_set(dcCandidates, from))
checkersBB |=
- ((rook_attacks(ksq) & rooks_and_queens(us)) |
- (bishop_attacks(ksq) & bishops_and_queens(us)));
+ ((piece_attacks<ROOK>(ksq) & rooks_and_queens(us)) |
+ (piece_attacks<BISHOP>(ksq) & bishops_and_queens(us)));
break;
case BISHOP:
- if(bit_is_set(bishop_attacks(ksq), to))
+ if(bit_is_set(piece_attacks<BISHOP>(ksq), to))
set_bit(&checkersBB, to);
if(bit_is_set(dcCandidates, from))
checkersBB |=
- (rook_attacks(ksq) & rooks_and_queens(us));
+ (piece_attacks<ROOK>(ksq) & rooks_and_queens(us));
break;
case ROOK:
- if(bit_is_set(rook_attacks(ksq), to))
+ if(bit_is_set(piece_attacks<ROOK>(ksq), to))
set_bit(&checkersBB, to);
if(bit_is_set(dcCandidates, from))
checkersBB |=
- (bishop_attacks(ksq) & bishops_and_queens(us));
+ (piece_attacks<BISHOP>(ksq) & bishops_and_queens(us));
break;
case QUEEN:
- if(bit_is_set(queen_attacks(ksq), to))
+ if(bit_is_set(piece_attacks<QUEEN>(ksq), to))
set_bit(&checkersBB, to);
break;
case KING:
if(bit_is_set(dcCandidates, from))
checkersBB |=
- ((rook_attacks(ksq) & rooks_and_queens(us)) |
- (bishop_attacks(ksq) & bishops_and_queens(us)));
+ ((piece_attacks<ROOK>(ksq) & rooks_and_queens(us)) |
+ (piece_attacks<BISHOP>(ksq) & bishops_and_queens(us)));
break;
default:
attackers =
(rook_attacks_bb(to, occ) & rooks_and_queens()) |
(bishop_attacks_bb(to, occ) & bishops_and_queens()) |
- (knight_attacks(to) & knights()) |
- (king_attacks(to) & kings()) |
- (white_pawn_attacks(to) & pawns(BLACK)) |
- (black_pawn_attacks(to) & pawns(WHITE));
+ (piece_attacks<KNIGHT>(to) & knights()) |
+ (piece_attacks<KING>(to) & kings()) |
+ (pawn_attacks(WHITE, to) & pawns(BLACK)) |
+ (pawn_attacks(BLACK, to) & pawns(WHITE));
attackers &= occ;
// If the opponent has no attackers, we are finished:
/// Position::is_ok() performs some consitency checks for the position object.
/// This is meant to be helpful when debugging.
-bool Position::is_ok() const {
+bool Position::is_ok(int* failedStep) const {
// What features of the position should be verified?
static const bool debugBitboards = false;
static const bool debugPieceCounts = false;
static const bool debugPieceList = false;
+ if (failedStep) *failedStep = 1;
+
// Side to move OK?
if(!color_is_ok(side_to_move()))
return false;
// Are the king squares in the position correct?
+ if (failedStep) (*failedStep)++;
if(piece_on(king_square(WHITE)) != WK)
return false;
+
+ if (failedStep) (*failedStep)++;
if(piece_on(king_square(BLACK)) != BK)
return false;
// Castle files OK?
+ if (failedStep) (*failedStep)++;
if(!file_is_ok(initialKRFile))
return false;
if(!file_is_ok(initialQRFile))
return false;
// Do both sides have exactly one king?
+ if (failedStep) (*failedStep)++;
if(debugKingCount) {
int kingCount[2] = {0, 0};
for(Square s = SQ_A1; s <= SQ_H8; s++)
}
// Can the side to move capture the opponent's king?
+ if (failedStep) (*failedStep)++;
if(debugKingCapture) {
Color us = side_to_move();
Color them = opposite_color(us);
}
// Is there more than 2 checkers?
+ if (failedStep) (*failedStep)++;
if(debugCheckerCount && count_1s(checkersBB) > 2)
return false;
// Bitboards OK?
+ if (failedStep) (*failedStep)++;
if(debugBitboards) {
// The intersection of the white and black pieces must be empty:
if((pieces_of_color(WHITE) & pieces_of_color(BLACK))
}
// En passant square OK?
+ if (failedStep) (*failedStep)++;
if(ep_square() != SQ_NONE) {
// The en passant square must be on rank 6, from the point of view of the
// side to move.
}
// Hash key OK?
+ if (failedStep) (*failedStep)++;
if(debugKey && key != compute_key())
return false;
// Pawn hash key OK?
+ if (failedStep) (*failedStep)++;
if(debugPawnKey && pawnKey != compute_pawn_key())
return false;
// Material hash key OK?
+ if (failedStep) (*failedStep)++;
if(debugMaterialKey && materialKey != compute_material_key())
return false;
// Incremental eval OK?
+ if (failedStep) (*failedStep)++;
if(debugIncrementalEval) {
if(mgValue != compute_mg_value())
return false;
}
// Non-pawn material OK?
+ if (failedStep) (*failedStep)++;
if(debugNonPawnMaterial) {
if(npMaterial[WHITE] != compute_non_pawn_material(WHITE))
return false;
}
// Piece counts OK?
+ if (failedStep) (*failedStep)++;
if(debugPieceCounts)
for(Color c = WHITE; c <= BLACK; c++)
for(PieceType pt = PAWN; pt <= KING; pt++)
if(pieceCount[c][pt] != count_1s(pieces_of_color_and_type(c, pt)))
return false;
+ if (failedStep) (*failedStep)++;
if(debugPieceList) {
for(Color c = WHITE; c <= BLACK; c++)
for(PieceType pt = PAWN; pt <= KING; pt++)
return false;
}
}
-
+ if (failedStep) *failedStep = 0;
return true;
}
projects / stockfish / blobdiff