fen += (char)skip + '0';
skip = 0;
}
- fen += pieceLetters[piece_on(sq)];
+ fen += pieceLetters[piece_on(sq)];
}
if (skip > 0)
fen += (char)skip + '0';
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
// 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
+ // Pinners are sliders, not checkers, that give check when
// candidate pinned are removed.
Bitboard pinners = (FindPinned ? sliders & ~checkersBB : sliders);
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;
}
switch (type_of_piece_on(from))
{
case PAWN:
-
+
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();
}
return false;
- case KNIGHT:
+ case KNIGHT:
return bit_is_set(dcCandidates, from) // Discovered check?
|| bit_is_set(piece_attacks<KNIGHT>(ksq), to); // Normal check?
case QUEEN:
// Discovered checks are impossible!
- assert(!bit_is_set(dcCandidates, from));
+ assert(!bit_is_set(dcCandidates, from));
return bit_is_set(piece_attacks<QUEEN>(ksq), to); // Normal check?
case KING:
// Position::undo_move. In particular, the side to move has been switched,
// so the code below is correct.
Color us = side_to_move();
- Color them = opposite_color(us);
// Find source squares for king and rook
Square kfrom = move_from(m);
/// Position::do_move, is used to put back the captured piece (if any).
void Position::undo_promotion_move(Move m, const UndoInfo &u) {
-
+
Color us, them;
Square from, to;
PieceType capture, promotion;
| (pawn_attacks(WHITE, to) & pawns(BLACK))
| (pawn_attacks(BLACK, to) & pawns(WHITE));
- attackers &= occ; // Re-add removed piece
-
// If the opponent has no attackers, we are finished
if ((attackers & pieces_of_color(them)) == EmptyBoardBB)
return seeValues[capture];
+ attackers &= occ; // Remove the moving piece
+
// The destination square is defended, which makes things rather more
// difficult to compute. We proceed by building up a "swap list" containing
// the material gain or loss at each stop in a sequence of captures to the
- // destianation square, where the sides alternately capture, and always
+ // destination square, where the sides alternately capture, and always
// capture with the least valuable piece. After each capture, we look for
// new X-ray attacks from behind the capturing piece.
int lastCapturingPieceValue = seeValues[piece];
{
if (mgValue != compute_mg_value())
return false;
-
+
if (egValue != compute_eg_value())
return false;
}