#include <cassert>
#include <cstring>
#include <iomanip>
-#include <iostream>
#include <sstream>
#include "bitcount.h"
#include "tt.h"
using std::string;
-using std::cout;
-using std::endl;
static const string PieceToChar(" PNBRQK pnbrqk");
Key psq[COLOR_NB][PIECE_TYPE_NB][SQUARE_NB];
Key enpassant[FILE_NB];
- Key castle[CASTLE_RIGHT_NB];
+ Key castling[CASTLING_FLAG_NB];
Key side;
Key exclusion;
}
namespace {
-// min_attacker() is an helper function used by see() to locate the least
+// min_attacker() is a helper function used by see() to locate the least
// valuable attacker for the side to move, remove the attacker we just found
// from the bitboards and scan for new X-ray attacks behind it.
template<> FORCE_INLINE
PieceType min_attacker<KING>(const Bitboard*, const Square&, const Bitboard&, Bitboard&, Bitboard&) {
- return KING; // No need to update bitboards, it is the last cycle
+ return KING; // No need to update bitboards: it is the last cycle
}
} // namespace
/// Position::init() initializes at startup the various arrays used to compute
/// hash keys and the piece square tables. The latter is a two-step operation:
-/// First, the white halves of the tables are copied from PSQT[] tables. Second,
-/// the black halves of the tables are initialized by flipping and changing the
-/// sign of the white scores.
+/// Firstly, the white halves of the tables are copied from PSQT[] tables.
+/// Secondly, the black halves of the tables are initialized by flipping and
+/// changing the sign of the white scores.
void Position::init() {
for (File f = FILE_A; f <= FILE_H; ++f)
Zobrist::enpassant[f] = rk.rand<Key>();
- for (int cr = CASTLES_NONE; cr <= ALL_CASTLES; ++cr)
+ for (int cf = NO_CASTLING; cf <= ANY_CASTLING; ++cf)
{
- Bitboard b = cr;
+ Bitboard b = cf;
while (b)
{
- Key k = Zobrist::castle[1ULL << pop_lsb(&b)];
- Zobrist::castle[cr] ^= k ? k : rk.rand<Key>();
+ Key k = Zobrist::castling[1ULL << pop_lsb(&b)];
+ Zobrist::castling[cf] ^= k ? k : rk.rand<Key>();
}
}
/// Position::operator=() creates a copy of 'pos'. We want the new born Position
-/// object do not depend on any external data so we detach state pointer from
+/// object to not depend on any external data so we detach state pointer from
/// the source one.
Position& Position::operator=(const Position& pos) {
A FEN string contains six fields separated by a space. The fields are:
1) Piece placement (from white's perspective). Each rank is described, starting
- with rank 8 and ending with rank 1; within each rank, the contents of each
+ with rank 8 and ending with rank 1. Within each rank, the contents of each
square are described from file A through file H. Following the Standard
Algebraic Notation (SAN), each piece is identified by a single letter taken
from the standard English names. White pieces are designated using upper-case
- letters ("PNBRQK") while Black take lowercase ("pnbrqk"). Blank squares are
+ letters ("PNBRQK") whilst Black uses lowercase ("pnbrqk"). Blank squares are
noted using digits 1 through 8 (the number of blank squares), and "/"
separates ranks.
*/
char col, row, token;
- size_t p;
+ size_t idx;
Square sq = SQ_A8;
std::istringstream ss(fenStr);
else if (token == '/')
sq -= Square(16);
- else if ((p = PieceToChar.find(token)) != string::npos)
+ else if ((idx = PieceToChar.find(token)) != string::npos)
{
- put_piece(sq, color_of(Piece(p)), type_of(Piece(p)));
+ put_piece(sq, color_of(Piece(idx)), type_of(Piece(idx)));
++sq;
}
}
else
continue;
- set_castle_right(c, rsq);
+ set_castling_flag(c, rsq);
}
// 4. En passant square. Ignore if no pawn capture is possible
}
-/// Position::set_castle_right() is an helper function used to set castling
-/// rights given the corresponding color and the rook starting square.
+/// Position::set_castling_flag() is a helper function used to set castling
+/// flags given the corresponding color and the rook starting square.
-void Position::set_castle_right(Color c, Square rfrom) {
+void Position::set_castling_flag(Color c, Square rfrom) {
Square kfrom = king_square(c);
CastlingSide cs = kfrom < rfrom ? KING_SIDE : QUEEN_SIDE;
- CastleRight cr = make_castle_right(c, cs);
+ CastlingFlag cf = make_castling_flag(c, cs);
- st->castleRights |= cr;
- castleRightsMask[kfrom] |= cr;
- castleRightsMask[rfrom] |= cr;
- castleRookSquare[c][cs] = rfrom;
+ st->castlingFlags |= cf;
+ castlingFlagsMask[kfrom] |= cf;
+ castlingFlagsMask[rfrom] |= cf;
+ castlingRookSquare[c][cs] = rfrom;
Square kto = relative_square(c, cs == KING_SIDE ? SQ_G1 : SQ_C1);
Square rto = relative_square(c, cs == KING_SIDE ? SQ_F1 : SQ_D1);
for (Square s = std::min(rfrom, rto); s <= std::max(rfrom, rto); ++s)
if (s != kfrom && s != rfrom)
- castlePath[c][cs] |= s;
+ castlingPath[c][cs] |= s;
for (Square s = std::min(kfrom, kto); s <= std::max(kfrom, kto); ++s)
if (s != kfrom && s != rfrom)
- castlePath[c][cs] |= s;
+ castlingPath[c][cs] |= s;
}
-/// Position::fen() returns a FEN representation of the position. In case
-/// of Chess960 the Shredder-FEN notation is used. Mainly a debugging function.
+/// Position::fen() returns a FEN representation of the position. In case of
+/// Chess960 the Shredder-FEN notation is used. This is mainly a debugging function.
const string Position::fen() const {
+ int emptyCnt;
std::ostringstream ss;
for (Rank rank = RANK_8; rank >= RANK_1; --rank)
{
for (File file = FILE_A; file <= FILE_H; ++file)
{
- Square sq = file | rank;
-
- if (empty(sq))
- {
- int emptyCnt = 1;
-
- for ( ; file < FILE_H && empty(++sq); ++file)
- ++emptyCnt;
+ for (emptyCnt = 0; file <= FILE_H && empty(file | rank); ++file)
+ ++emptyCnt;
+ if (emptyCnt)
ss << emptyCnt;
- }
- else
- ss << PieceToChar[piece_on(sq)];
+
+ if (file <= FILE_H)
+ ss << PieceToChar[piece_on(file | rank)];
}
if (rank > RANK_1)
ss << (sideToMove == WHITE ? " w " : " b ");
if (can_castle(WHITE_OO))
- ss << (chess960 ? file_to_char(file_of(castle_rook_square(WHITE, KING_SIDE)), false) : 'K');
+ ss << (chess960 ? file_to_char(file_of(castling_rook_square(WHITE, KING_SIDE)), false) : 'K');
if (can_castle(WHITE_OOO))
- ss << (chess960 ? file_to_char(file_of(castle_rook_square(WHITE, QUEEN_SIDE)), false) : 'Q');
+ ss << (chess960 ? file_to_char(file_of(castling_rook_square(WHITE, QUEEN_SIDE)), false) : 'Q');
if (can_castle(BLACK_OO))
- ss << (chess960 ? file_to_char(file_of(castle_rook_square(BLACK, KING_SIDE)), true) : 'k');
+ ss << (chess960 ? file_to_char(file_of(castling_rook_square(BLACK, KING_SIDE)), true) : 'k');
if (can_castle(BLACK_OOO))
- ss << (chess960 ? file_to_char(file_of(castle_rook_square(BLACK, QUEEN_SIDE)), true) : 'q');
+ ss << (chess960 ? file_to_char(file_of(castling_rook_square(BLACK, QUEEN_SIDE)), true) : 'q');
- if (st->castleRights == CASTLES_NONE)
+ if (!can_castle(WHITE) && !can_castle(BLACK))
ss << '-';
ss << (ep_square() == SQ_NONE ? " - " : " " + square_to_string(ep_square()) + " ")
- << st->rule50 << " " << 1 + (gamePly - int(sideToMove == BLACK)) / 2;
+ << st->rule50 << " " << 1 + (gamePly - int(sideToMove == BLACK)) / 2;
return ss.str();
}
}
-/// Position:hidden_checkers() returns a bitboard of all pinned / discovery check
-/// pieces, according to the call parameters. Pinned pieces protect our king,
-/// discovery check pieces attack the enemy king.
+/// Position:hidden_checkers() returns a bitboard of all pinned / discovered check
+/// pieces, according to the call parameters. Pinned pieces protect our king and
+/// discovered check pieces attack the enemy king.
-Bitboard Position::hidden_checkers(Square ksq, Color c, Color toMove) const {
+Bitboard Position::hidden_checkers(Color c, Color kingColor) const {
Bitboard b, pinners, result = 0;
+ Square ksq = king_square(kingColor);
- // Pinners are sliders that give check when pinned piece is removed
+ // Pinners are sliders that give check when a pinned piece is removed
pinners = ( (pieces( ROOK, QUEEN) & PseudoAttacks[ROOK ][ksq])
- | (pieces(BISHOP, QUEEN) & PseudoAttacks[BISHOP][ksq])) & pieces(c);
+ | (pieces(BISHOP, QUEEN) & PseudoAttacks[BISHOP][ksq])) & pieces(~kingColor);
while (pinners)
{
b = between_bb(ksq, pop_lsb(&pinners)) & pieces();
if (!more_than_one(b))
- result |= b & pieces(toMove);
+ result |= b & pieces(c);
}
return result;
}
/// Position::attackers_to() computes a bitboard of all pieces which attack a
-/// given square. Slider attacks use occ bitboard as occupancy.
+/// given square. Slider attacks use the occ bitboard to indicate occupancy.
Bitboard Position::attackers_to(Square s, Bitboard occ) const {
}
-/// Position::attacks_from() computes a bitboard of all attacks of a given piece
-/// put in a given square. Slider attacks use occ bitboard as occupancy.
-
-Bitboard Position::attacks_from(Piece p, Square s, Bitboard occ) {
-
- assert(is_ok(s));
-
- switch (type_of(p))
- {
- case BISHOP: return attacks_bb<BISHOP>(s, occ);
- case ROOK : return attacks_bb<ROOK>(s, occ);
- case QUEEN : return attacks_bb<BISHOP>(s, occ) | attacks_bb<ROOK>(s, occ);
- default : return StepAttacksBB[p][s];
- }
-}
-
-
/// Position::legal() tests whether a pseudo-legal move is legal
bool Position::legal(Move m, Bitboard pinned) const {
// square is attacked by the opponent. Castling moves are checked
// for legality during move generation.
if (type_of(piece_on(from)) == KING)
- return type_of(m) == CASTLE || !(attackers_to(to_sq(m)) & pieces(~us));
+ return type_of(m) == CASTLING || !(attackers_to(to_sq(m)) & pieces(~us));
// 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 !pinned
|| !(pinned & from)
- || squares_aligned(from, to_sq(m), king_square(us));
+ || aligned(from, to_sq(m), king_square(us));
}
if (promotion_type(m) - 2 != NO_PIECE_TYPE)
return false;
- // If the from square is not occupied by a piece belonging to the side to
+ // If the 'from' square is not occupied by a piece belonging to the side to
// move, the move is obviously not legal.
if (pc == NO_PIECE || color_of(pc) != us)
return false;
return false;
// We have already handled promotion moves, so destination
- // cannot be on the 8/1th rank.
+ // cannot be on the 8th/1st rank.
if (rank_of(to) == RANK_8 || rank_of(to) == RANK_1)
return false;
return false;
// Evasions generator already takes care to avoid some kind of illegal moves
- // and pl_move_is_legal() relies on this. So we have to take care that the
- // same kind of moves are filtered out here.
+ // and pl_move_is_legal() relies on this. We therefore have to take care that
+ // the same kind of moves are filtered out here.
if (checkers())
{
if (type_of(pc) != KING)
if (!((between_bb(lsb(checkers()), king_square(us)) | checkers()) & to))
return false;
}
- // In case of king moves under check we have to remove king so to catch
- // as invalid moves like b1a1 when opposite queen is on c1.
+ // In case of king moves under check we have to remove king so as to catch
+ // invalid moves like b1a1 when opposite queen is on c1.
else if (attackers_to(to, pieces() ^ from) & pieces(~us))
return false;
}
Square to = to_sq(m);
PieceType pt = type_of(piece_on(from));
- // Direct check ?
+ // Is there a direct check?
if (ci.checkSq[pt] & to)
return true;
- // Discovery check ?
- if (unlikely(ci.dcCandidates) && (ci.dcCandidates & from))
- {
- // For pawn and king moves we need to verify also direction
- if ( (pt != PAWN && pt != KING)
- || !squares_aligned(from, to, king_square(~sideToMove)))
- return true;
- }
+ // Is there a discovered check?
+ if ( unlikely(ci.dcCandidates)
+ && (ci.dcCandidates & from)
+ && !aligned(from, to, king_square(~sideToMove)))
+ return true;
- // Can we skip the ugly special cases ?
+ // Can we skip the ugly special cases?
if (type_of(m) == NORMAL)
return false;
switch (type_of(m))
{
case PROMOTION:
- return attacks_from(Piece(promotion_type(m)), to, pieces() ^ from) & ksq;
+ return attacks_bb(Piece(promotion_type(m)), to, pieces() ^ from) & ksq;
- // En passant capture with check ? We have already handled the case
- // of direct checks and ordinary discovered check, the only case we
+ // En passant capture with check? We have already handled the case
+ // of direct checks and ordinary discovered check, so the only case we
// need to handle is the unusual case of a discovered check through
// the captured pawn.
case ENPASSANT:
return (attacks_bb< ROOK>(ksq, b) & pieces(us, QUEEN, ROOK))
| (attacks_bb<BISHOP>(ksq, b) & pieces(us, QUEEN, BISHOP));
}
- case CASTLE:
+ case CASTLING:
{
Square kfrom = from;
- Square rfrom = to; // 'King captures the rook' notation
+ Square rfrom = to; // Castling is encoded as 'King captures the rook'
Square kto = relative_square(us, rfrom > kfrom ? SQ_G1 : SQ_C1);
Square rto = relative_square(us, rfrom > kfrom ? SQ_F1 : SQ_D1);
++nodes;
Key k = st->key;
- // Copy some fields of old state to our new StateInfo object except the ones
- // which are going to be recalculated from scratch anyway, then switch our state
- // pointer to point to the new, ready to be updated, state.
+ // Copy some fields of the old state to our new StateInfo object except the
+ // ones which are going to be recalculated from scratch anyway and then switch
+ // our state pointer to point to the new (ready to be updated) state.
std::memcpy(&newSt, st, StateCopySize64 * sizeof(uint64_t));
newSt.previous = st;
// Update side to move
k ^= Zobrist::side;
- // Increment ply counters.In particular rule50 will be later reset it to zero
+ // Increment ply counters. In particular, rule50 will be reset to zero later on
// in case of a capture or a pawn move.
++gamePly;
++st->rule50;
PieceType captured = type_of(m) == ENPASSANT ? PAWN : type_of(piece_on(to));
assert(color_of(pc) == us);
- assert(piece_on(to) == NO_PIECE || color_of(piece_on(to)) == them || type_of(m) == CASTLE);
+ assert(piece_on(to) == NO_PIECE || color_of(piece_on(to)) == them || type_of(m) == CASTLING);
assert(captured != KING);
- if (type_of(m) == CASTLE)
+ if (type_of(m) == CASTLING)
{
assert(pc == make_piece(us, KING));
bool kingSide = to > from;
- Square rfrom = to; // Castle is encoded as "king captures friendly rook"
+ Square rfrom = to; // Castling is encoded as "king captures friendly rook"
Square rto = relative_square(us, kingSide ? SQ_F1 : SQ_D1);
to = relative_square(us, kingSide ? SQ_G1 : SQ_C1);
captured = NO_PIECE_TYPE;
- do_castle(from, to, rfrom, rto);
+ do_castling(from, to, rfrom, rto);
st->psq += psq[us][ROOK][rto] - psq[us][ROOK][rfrom];
k ^= Zobrist::psq[us][ROOK][rfrom] ^ Zobrist::psq[us][ROOK][rto];
st->epSquare = SQ_NONE;
}
- // Update castle rights if needed
- if (st->castleRights && (castleRightsMask[from] | castleRightsMask[to]))
+ // Update castling flags if needed
+ if (st->castlingFlags && (castlingFlagsMask[from] | castlingFlagsMask[to]))
{
- int cr = castleRightsMask[from] | castleRightsMask[to];
- k ^= Zobrist::castle[st->castleRights & cr];
- st->castleRights &= ~cr;
+ int cf = castlingFlagsMask[from] | castlingFlagsMask[to];
+ k ^= Zobrist::castling[st->castlingFlags & cf];
+ st->castlingFlags &= ~cf;
}
// Prefetch TT access as soon as we know the new hash key
prefetch((char*)TT.first_entry(k));
- // Move the piece. The tricky Chess960 castle is handled earlier
- if (type_of(m) != CASTLE)
+ // Move the piece. The tricky Chess960 castling is handled earlier
+ if (type_of(m) != CASTLING)
move_piece(from, to, us, pt);
// If the moving piece is a pawn do some special extra work
if (pt == PAWN)
{
- // Set en-passant square, only if moved pawn can be captured
+ // Set en-passant square if the moved pawn can be captured
if ( (int(to) ^ int(from)) == 16
&& (attacks_from<PAWN>(from + pawn_push(us), us) & pieces(them, PAWN)))
{
// Update the key with the final value
st->key = k;
- // Update checkers bitboard, piece must be already moved
+ // Update checkers bitboard: piece must be already moved
st->checkersBB = 0;
if (moveIsCheck)
if (ci.checkSq[pt] & to)
st->checkersBB |= to;
- // Discovery checks
+ // Discovered checks
if (ci.dcCandidates && (ci.dcCandidates & from))
{
if (pt != ROOK)
PieceType pt = type_of(piece_on(to));
PieceType captured = st->capturedType;
- assert(empty(from) || type_of(m) == CASTLE);
+ assert(empty(from) || type_of(m) == CASTLING);
assert(captured != KING);
if (type_of(m) == PROMOTION)
pt = PAWN;
}
- if (type_of(m) == CASTLE)
+ if (type_of(m) == CASTLING)
{
bool kingSide = to > from;
- Square rfrom = to; // Castle is encoded as "king captures friendly rook"
+ Square rfrom = to; // Castling is encoded as "king captures friendly rook"
Square rto = relative_square(us, kingSide ? SQ_F1 : SQ_D1);
to = relative_square(us, kingSide ? SQ_G1 : SQ_C1);
captured = NO_PIECE_TYPE;
pt = KING;
- do_castle(to, from, rto, rfrom);
+ do_castling(to, from, rto, rfrom);
}
else
move_piece(to, from, us, pt); // Put the piece back at the source square
}
-/// Position::do_castle() is a helper used to do/undo a castling move. This
+/// Position::do_castling() is a helper used to do/undo a castling move. This
/// is a bit tricky, especially in Chess960.
-void Position::do_castle(Square kfrom, Square kto, Square rfrom, Square rto) {
+void Position::do_castling(Square kfrom, Square kto, Square rfrom, Square rto) {
// Remove both pieces first since squares could overlap in Chess960
remove_piece(kfrom, sideToMove, KING);
stm = color_of(piece_on(from));
occupied = pieces() ^ from;
- // Castle moves are implemented as king capturing the rook so cannot be
+ // Castling moves are implemented as king capturing the rook so cannot be
// handled correctly. Simply return 0 that is always the correct value
// unless in the rare case the rook ends up under attack.
- if (type_of(m) == CASTLE)
+ if (type_of(m) == CASTLING)
return 0;
if (type_of(m) == ENPASSANT)
} while (stmAttackers);
// If we are doing asymmetric SEE evaluation and the same side does the first
- // and the last capture, he loses a tempo and gain must be at least worth
+ // and the last capture, it loses a tempo and gain must be at least worth
// 'asymmThreshold', otherwise we replace the score with a very low value,
// before negamaxing.
if (asymmThreshold)
/// Position::compute_key() computes the hash key of the position. The hash
-/// key is usually updated incrementally as moves are made and unmade, the
+/// key is usually updated incrementally as moves are made and unmade. The
/// compute_key() function is only used when a new position is set up, and
/// to verify the correctness of the hash key when running in debug mode.
Key Position::compute_key() const {
- Key k = Zobrist::castle[st->castleRights];
+ Key k = Zobrist::castling[st->castlingFlags];
for (Bitboard b = pieces(); b; )
{
/// 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
+/// 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
/// debug mode.
/// Position::compute_material_key() computes the hash key of the position.
-/// The hash key is usually updated incrementally as moves are made and unmade,
-/// the compute_material_key() function is only used when a new position is set
+/// The hash key is usually updated incrementally as moves are made and unmade.
+/// The compute_material_key() function is only used when a new position is set
/// up, and to verify the correctness of the material hash key when running in
/// debug mode.
}
-/// Position::compute_psq_score() computes the 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
+/// Position::compute_psq_score() computes the incremental scores for the middlegame
+/// 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.
Score Position::compute_psq_score() const {
}
-/// Position::compute_non_pawn_material() computes the total non-pawn middle
-/// game material value for the given side. Material values are updated
-/// incrementally during the search, this function is only used while
-/// initializing a new Position object.
+/// Position::compute_non_pawn_material() computes the total non-pawn middlegame
+/// material value for the given side. Material values are updated incrementally
+/// during the search. This function is only used when initializing a new Position
+/// object.
Value Position::compute_non_pawn_material(Color c) const {
}
-/// Position::is_draw() tests whether the position is drawn by material,
-/// repetition, or the 50 moves rule. It does not detect stalemates, this
-/// must be done by the search.
+/// Position::is_draw() tests whether the position is drawn by material, 50 moves
+/// rule or repetition. It does not detect stalemates.
+
bool Position::is_draw() const {
- // Draw by material?
if ( !pieces(PAWN)
&& (non_pawn_material(WHITE) + non_pawn_material(BLACK) <= BishopValueMg))
return true;
- // Draw by the 50 moves rule?
if (st->rule50 > 99 && (!checkers() || MoveList<LEGAL>(*this).size()))
return true;
- int i = 4, e = std::min(st->rule50, st->pliesFromNull);
-
- if (i <= e)
+ StateInfo* stp = st;
+ for (int i = 2, e = std::min(st->rule50, st->pliesFromNull); i <= e; i += 2)
{
- StateInfo* stp = st->previous->previous;
-
- do {
- stp = stp->previous->previous;
-
- if (stp->key == st->key)
- return true; // Draw after first repetition
-
- i += 2;
+ stp = stp->previous->previous;
- } while (i <= e);
+ if (stp->key == st->key)
+ return true; // Draw at first repetition
}
return false;
/// Position::flip() flips position with the white and black sides reversed. This
-/// is only useful for debugging especially for finding evaluation symmetry bugs.
+/// is only useful for debugging e.g. for finding evaluation symmetry bugs.
static char toggle_case(char c) {
return char(islower(c) ? toupper(c) : tolower(c));
}
-/// Position::pos_is_ok() performs some consitency checks for the position object.
+/// Position::pos_is_ok() performs some consistency checks for the position object.
/// This is meant to be helpful when debugging.
bool Position::pos_is_ok(int* failedStep) const {
const bool debugNonPawnMaterial = all || false;
const bool debugPieceCounts = all || false;
const bool debugPieceList = all || false;
- const bool debugCastleSquares = all || false;
+ const bool debugCastlingSquares = all || false;
*step = 1;
|| index[pieceList[c][pt][i]] != i)
return false;
- if ((*step)++, debugCastleSquares)
+ if ((*step)++, debugCastlingSquares)
for (Color c = WHITE; c <= BLACK; ++c)
for (CastlingSide s = KING_SIDE; s <= QUEEN_SIDE; s = CastlingSide(s + 1))
{
- CastleRight cr = make_castle_right(c, s);
+ CastlingFlag cf = make_castling_flag(c, s);
- if (!can_castle(cr))
+ if (!can_castle(cf))
continue;
- if ( (castleRightsMask[king_square(c)] & cr) != cr
- || piece_on(castleRookSquare[c][s]) != make_piece(c, ROOK)
- || castleRightsMask[castleRookSquare[c][s]] != cr)
+ if ( (castlingFlagsMask[king_square(c)] & cf) != cf
+ || piece_on(castlingRookSquare[c][s]) != make_piece(c, ROOK)
+ || castlingFlagsMask[castlingRookSquare[c][s]] != cf)
return false;
}