(*mlist++).move = make_move(to - (d), to); }
namespace {
- enum CastlingSide { KING_SIDE, QUEEN_SIDE };
-
template<CastlingSide Side, bool OnlyChecks>
MoveStack* generate_castle(const Position& pos, MoveStack* mlist, Color us) {
- const CastleRight CR[] = { Side ? WHITE_OOO : WHITE_OO,
- Side ? BLACK_OOO : BLACK_OO };
+ CastleRight cr = CastleRight((Side == KING_SIDE ? WHITE_OO : WHITE_OOO) << us);
- if (pos.castle_impeded(CR[us]) || !pos.can_castle(CR[us]))
+ if (pos.castle_impeded(us, Side) || !pos.can_castle(cr))
return mlist;
// After castling, the rook and king final positions are the same in Chess960
// as they would be in standard chess.
Square kfrom = pos.king_square(us);
- Square rfrom = pos.castle_rook_square(CR[us]);
Square kto = relative_square(us, Side == KING_SIDE ? SQ_G1 : SQ_C1);
+ Square rfrom = pos.castle_rook_square(us, Side);
Bitboard enemies = pos.pieces(~us);
assert(!pos.in_check());
- assert(pos.piece_on(kfrom) == make_piece(us, KING));
- assert(pos.piece_on(rfrom) == make_piece(us, ROOK));
for (Square s = std::min(kfrom, kto), e = std::max(kfrom, kto); s <= e; s++)
if ( s != kfrom // We are not in check
void Position::set_castle_right(Color c, Square rfrom) {
Square kfrom = king_square(c);
- bool kingSide = kfrom < rfrom;
- int cr = (kingSide ? WHITE_OO : WHITE_OOO) << c;
+ CastlingSide cs = kfrom < rfrom ? KING_SIDE : QUEEN_SIDE;
+ int cr = (cs == KING_SIDE ? WHITE_OO : WHITE_OOO) << c;
st->castleRights |= cr;
castleRightsMask[kfrom] |= cr;
castleRightsMask[rfrom] |= cr;
- castleRookSquare[cr] = rfrom;
+ castleRookSquare[c][cs] = rfrom;
- Square kto = relative_square(c, kingSide ? SQ_G1 : SQ_C1);
- Square rto = relative_square(c, kingSide ? SQ_F1 : SQ_D1);
+ 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[cr] |= s;
+ castlePath[c][cs] |= s;
for (Square s = std::min(kfrom, kto); s <= std::max(kfrom, kto); s++)
if (s != kfrom && s != rfrom)
- castlePath[cr] |= s;
+ castlePath[c][cs] |= s;
}
fen << (sideToMove == WHITE ? " w " : " b ");
if (can_castle(WHITE_OO))
- fen << (chess960 ? char(toupper(file_to_char(file_of(castle_rook_square(WHITE_OO))))) : 'K');
+ fen << (chess960 ? char(toupper(file_to_char(file_of(castle_rook_square(WHITE, KING_SIDE))))) : 'K');
if (can_castle(WHITE_OOO))
- fen << (chess960 ? char(toupper(file_to_char(file_of(castle_rook_square(WHITE_OOO))))) : 'Q');
+ fen << (chess960 ? char(toupper(file_to_char(file_of(castle_rook_square(WHITE, QUEEN_SIDE))))) : 'Q');
if (can_castle(BLACK_OO))
- fen << (chess960 ? file_to_char(file_of(castle_rook_square(BLACK_OO))) : 'k');
+ fen << (chess960 ? file_to_char(file_of(castle_rook_square(BLACK, KING_SIDE))) : 'k');
if (can_castle(BLACK_OOO))
- fen << (chess960 ? file_to_char(file_of(castle_rook_square(BLACK_OOO))) : 'q');
+ fen << (chess960 ? file_to_char(file_of(castle_rook_square(BLACK, QUEEN_SIDE))) : 'q');
if (st->castleRights == CASTLES_NONE)
fen << '-';
put_piece(Piece(pos.piece_on(s) ^ 8), ~s);
if (pos.can_castle(WHITE_OO))
- set_castle_right(BLACK, ~pos.castle_rook_square(WHITE_OO));
+ set_castle_right(BLACK, ~pos.castle_rook_square(WHITE, KING_SIDE));
if (pos.can_castle(WHITE_OOO))
- set_castle_right(BLACK, ~pos.castle_rook_square(WHITE_OOO));
+ set_castle_right(BLACK, ~pos.castle_rook_square(WHITE, QUEEN_SIDE));
if (pos.can_castle(BLACK_OO))
- set_castle_right(WHITE, ~pos.castle_rook_square(BLACK_OO));
+ set_castle_right(WHITE, ~pos.castle_rook_square(BLACK, KING_SIDE));
if (pos.can_castle(BLACK_OOO))
- set_castle_right(WHITE, ~pos.castle_rook_square(BLACK_OOO));
+ set_castle_right(WHITE, ~pos.castle_rook_square(BLACK, QUEEN_SIDE));
if (pos.st->epSquare != SQ_NONE)
st->epSquare = ~pos.st->epSquare;
if (failedStep) (*failedStep)++;
if (debugCastleSquares)
- for (CastleRight f = WHITE_OO; f <= BLACK_OOO; f = CastleRight(f << 1))
- {
- if (!can_castle(f))
- continue;
+ for (Color c = WHITE; c <= BLACK; c++)
+ for (CastlingSide s = KING_SIDE; s <= QUEEN_SIDE; s = CastlingSide(s+1))
+ {
+ CastleRight cr = CastleRight((s == KING_SIDE ? WHITE_OO : WHITE_OOO) << c);
- Piece rook = (f & (WHITE_OO | WHITE_OOO) ? W_ROOK : B_ROOK);
+ if (!can_castle(cr))
+ continue;
- if ( piece_on(castleRookSquare[f]) != rook
- || castleRightsMask[castleRookSquare[f]] != f)
- return false;
- }
+ if ( piece_on(castleRookSquare[c][s]) != make_piece(c, ROOK)
+ || castleRightsMask[castleRookSquare[c][s]] != cr)
+ return false;
+ }
if (failedStep) *failedStep = 0;
return true;
// Castling
bool can_castle(CastleRight f) const;
bool can_castle(Color c) const;
- bool castle_impeded(CastleRight f) const;
- Square castle_rook_square(CastleRight f) const;
+ bool castle_impeded(Color c, CastlingSide s) const;
+ Square castle_rook_square(Color c, CastlingSide s) const;
// Checking
bool in_check() const;
int index[64]; // [square]
// Other info
- int castleRightsMask[64]; // [square]
- Square castleRookSquare[16]; // [castleRight]
- Bitboard castlePath[16]; // [castleRight]
+ int castleRightsMask[64]; // [square]
+ Square castleRookSquare[2][2]; // [color][side]
+ Bitboard castlePath[2][2]; // [color][side]
StateInfo startState;
int64_t nodes;
int startPosPly;
return st->castleRights & ((WHITE_OO | WHITE_OOO) << c);
}
-inline bool Position::castle_impeded(CastleRight f) const {
- return byTypeBB[ALL_PIECES] & castlePath[f];
+inline bool Position::castle_impeded(Color c, CastlingSide s) const {
+ return byTypeBB[ALL_PIECES] & castlePath[c][s];
}
-inline Square Position::castle_rook_square(CastleRight f) const {
- return castleRookSquare[f];
+inline Square Position::castle_rook_square(Color c, CastlingSide s) const {
+ return castleRookSquare[c][s];
}
template<PieceType Pt>