}
sideToMove = (fen[i] == 'w' ? WHITE : BLACK);
- // Castling rights:
+ // Castling rights
i++;
if (fen[i] != ' ')
{
i++;
while(strchr("KQkqabcdefghABCDEFGH-", fen[i])) {
- if(fen[i] == '-') {
- i++; break;
+ if (fen[i] == '-')
+ {
+ i++;
+ break;
}
else if(fen[i] == 'K') allow_oo(WHITE);
else if(fen[i] == 'Q') allow_ooo(WHITE);
/// 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.
+/// position attacks a given square.
bool Position::move_attacks_square(Move m, Square s) const {
assert(move_is_ok(m));
assert(square_is_ok(s));
+ bool is_attack;
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);
+ case WP: is_attack = pawn_attacks_square(WHITE, t, s); break;
+ case BP: is_attack = pawn_attacks_square(BLACK, t, s); break;
+ case WN: case BN: is_attack = piece_attacks_square<KNIGHT>(t, s); break;
+ case WB: case BB: is_attack = piece_attacks_square<BISHOP>(t, s); break;
+ case WR: case BR: is_attack = piece_attacks_square<ROOK>(t, s); break;
+ case WQ: case BQ: is_attack = piece_attacks_square<QUEEN>(t, s); break;
+ case WK: case BK: is_attack = piece_attacks_square<KING>(t, s); break;
default: break;
}
- return false;
+
+ if (is_attack)
+ return true;
+
+ // Move the piece and scan for X-ray attacks behind it
+ Bitboard occ = occupied_squares();
+ Color us = color_of_piece_on(f);
+ clear_bit(&occ, f);
+ set_bit(&occ, t);
+ Bitboard xray = ( (rook_attacks_bb(s, occ) & rooks_and_queens())
+ |(bishop_attacks_bb(s, occ) & bishops_and_queens())) & pieces_of_color(us);
+
+ // If we have attacks we need to verify that are caused by our move
+ // and are not already existent ones.
+ return xray && (xray ^ (xray & piece_attacks<QUEEN>(s)));
}
assert(m != MOVE_NONE);
return ( !square_is_empty(move_to(m))
- && (color_of_piece_on(move_to(m)) == opposite_color(side_to_move()))
+ && (color_of_piece_on(move_to(m)) != color_of_piece_on(move_from(m)))
)
|| move_is_ep(m);
}
// u.capture is restored in undo_move()
}
+
+/// Position::update_checkers() is a private method to udpate chekers info
+
template<PieceType Piece>
-inline void Position::update_checkers(Bitboard* pCheckersBB, Square ksq, Square from, Square to, Bitboard dcCandidates) {
+inline void Position::update_checkers(Bitboard* pCheckersBB, Square ksq, Square from,
+ Square to, Bitboard dcCandidates) {
if (Piece != KING && bit_is_set(piece_attacks<Piece>(ksq), to))
set_bit(pCheckersBB, to);
}
}
+
/// Position::do_move() makes a move, and backs up all information necessary
/// to undo the move to an UndoInfo object. The move is assumed to be legal.
/// Pseudo-legal moves should be filtered out before this function is called.
Square ksq = king_square(them);
switch (piece)
{
- case PAWN:
- if (bit_is_set(pawn_attacks(them, ksq), to))
- set_bit(&checkersBB, to);
-
- if (bit_is_set(dcCandidates, from))
- checkersBB |= ( (piece_attacks<ROOK>(ksq) & rooks_and_queens(us))
- |(piece_attacks<BISHOP>(ksq) & bishops_and_queens(us)));
- break;
-
- case KNIGHT:
- update_checkers<KNIGHT>(&checkersBB, ksq, from, to, dcCandidates);
- break;
-
- case BISHOP:
- update_checkers<BISHOP>(&checkersBB, ksq, from, to, dcCandidates);
- break;
-
- case ROOK:
- update_checkers<ROOK>(&checkersBB, ksq, from, to, dcCandidates);
- break;
-
- case QUEEN:
- update_checkers<QUEEN>(&checkersBB, ksq, from, to, dcCandidates);
- break;
-
- case KING:
- update_checkers<KING>(&checkersBB, ksq, from, to, dcCandidates);
- break;
-
- default:
- assert(false);
- break;
+ case PAWN: update_checkers<PAWN>(&checkersBB, ksq, from, to, dcCandidates); break;
+ case KNIGHT: update_checkers<KNIGHT>(&checkersBB, ksq, from, to, dcCandidates); break;
+ case BISHOP: update_checkers<BISHOP>(&checkersBB, ksq, from, to, dcCandidates); break;
+ case ROOK: update_checkers<ROOK>(&checkersBB, ksq, from, to, dcCandidates); break;
+ case QUEEN: update_checkers<QUEEN>(&checkersBB, ksq, from, to, dcCandidates); break;
+ case KING: update_checkers<KING>(&checkersBB, ksq, from, to, dcCandidates); break;
+ default: assert(false); break;
}
}
assert(is_ok());
}
+
/// Position::do_capture_move() is a private method used to update captured
/// piece info. It is called from the main Position::do_move function.
key ^= zobrist[us][ROOK][rfrom] ^ zobrist[us][ROOK][rto];
// Clear en passant square
- if(epSquare != SQ_NONE)
+ if (epSquare != SQ_NONE)
{
key ^= zobEp[epSquare];
epSquare = SQ_NONE;
}
-/// Position::undo_move() unmakes a move. When it returns, the position should
-/// be restored to exactly the same state as before the move was made. It is
+/// Position::undo_move() unmakes a move. When it returns, the position should
+/// be restored to exactly the same state as before the move was made. It is
/// important that Position::undo_move is called with the same move and UndoInfo
/// object as the earlier call to Position::do_move.
/// Position::do_null_move makes() a "null move": It switches the side to move
/// and updates the hash key without executing any move on the board.
-void Position::do_null_move(UndoInfo &u) {
+void Position::do_null_move(UndoInfo& u) {
assert(is_ok());
assert(!is_check());
}
-/// Position::see() is a static exchange evaluator: It tries to estimate the
+/// 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
/// 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 or en passant captures.
+/// move, and one which takes a 'from' and a 'to' square. The function does
+/// not yet understand promotions captures.
int Position::see(Square to) const {
// removed, but possibly an X-ray attacker added behind it.
occ = occupied_squares();
- // Handle enpassant moves
- if (ep_square() == to && type_of_piece_on(from) == PAWN)
+ // Handle en passant moves
+ if (epSquare == to && type_of_piece_on(from) == PAWN)
{
assert(capture == EMPTY);
}
-/// Position::reset_game_ply() simply sets gamePly to 0. It is used from the
+/// Position::reset_game_ply() simply sets gamePly to 0. It is used from the
/// UCI interface code, whenever a non-reversible move is made in a
/// 'position fen <fen> moves m1 m2 ...' command. This makes it possible
/// for the program to handle games of arbitrary length, as long as the GUI
}
-/// Position::compute_pawn_key() computes the hash key of the position. The
+/// Position::compute_pawn_key() computes the hash key of the position. The
/// hash key is usually updated incrementally as moves are made and unmade,
/// the compute_pawn_key() function is only used when a new position is set
/// up, and to verify the correctness of the pawn hash key when running in
/// Position::compute_mg_value() and Position::compute_eg_value() compute the
-/// incremental scores for the middle game and the endgame. These functions
+/// incremental scores for the middle game and the endgame. These functions
/// are used to initialize the incremental scores when a new position is set
/// up, and to verify that the scores are correctly updated by do_move
/// and undo_move when the program is running in debug mode.
/// Position::compute_non_pawn_material() computes the total non-pawn middle
-/// game material score for the given side. Material scores are updated
+/// game material score for the given side. Material scores are updated
/// incrementally during the search, this function is only used while
/// initializing a new Position object.
/// Position::is_draw() tests whether the position is drawn by material,
-/// repetition, or the 50 moves rule. It does not detect stalemates, this
+/// repetition, or the 50 moves rule. It does not detect stalemates, this
/// must be done by the search.
bool Position::is_draw() const {
/// Position::flipped_copy() makes a copy of the input position, but with
-/// the white and black sides reversed. This is only useful for debugging,
+/// the white and black sides reversed. This is only useful for debugging,
/// especially for finding evaluation symmetry bugs.
void Position::flipped_copy(const Position &pos) {
if (type_of_piece_on(s) == KING)
kingCount[color_of_piece_on(s)]++;
- if(kingCount[0] != 1 || kingCount[1] != 1)
+ if (kingCount[0] != 1 || kingCount[1] != 1)
return false;
}
if (failedStep) (*failedStep)++;
if (debugNonPawnMaterial)
{
- if(npMaterial[WHITE] != compute_non_pawn_material(WHITE))
+ if (npMaterial[WHITE] != compute_non_pawn_material(WHITE))
return false;
- if(npMaterial[BLACK] != compute_non_pawn_material(BLACK))
+ if (npMaterial[BLACK] != compute_non_pawn_material(BLACK))
return false;
}
projects / stockfish / blobdiff