- struct PawnParams {
- Bitboard Rank3BB, Rank8BB;
- Rank RANK_8;
- SquareDelta DELTA_N, DELTA_NE, DELTA_NW;
- Color us, them;
- };
- const PawnParams WhitePawnParams = { Rank3BB, Rank8BB, RANK_8, DELTA_N, DELTA_NE, DELTA_NW, WHITE, BLACK };
- const PawnParams BlackPawnParams = { Rank6BB, Rank1BB, RANK_1, DELTA_S, DELTA_SE, DELTA_SW, BLACK, WHITE };
-
- int generate_castle_moves(const Position&, MoveStack*, Color);
-
- template<Color>
- int generate_pawn_captures(const Position&, MoveStack*);
-
- template<Color>
- int generate_pawn_noncaptures(const Position&, MoveStack*);
-
- template<Color>
- int generate_pawn_checks(const Position&, Bitboard, Square, MoveStack*, int);
-
- template<Color>
- int generate_pawn_blocking_evasions(const Position&, Bitboard, Bitboard, MoveStack*, int);
-
- template<PieceType>
- int generate_piece_moves(const Position&, MoveStack*, Color, Bitboard);
-
- template<PieceType>
- int generate_piece_checks(const Position&, Bitboard, Bitboard, Square, MoveStack*, int);
-
- template<PieceType>
- int generate_piece_blocking_evasions(const Position&, Bitboard, Bitboard, MoveStack*, int);
-
-
- /// Templates with specializations are defined here to avoid lookup issues
-
- template<PieceType Piece>
- int generate_piece_checks(const Position& pos, Bitboard target, Bitboard dc,
- Square ksq, MoveStack* mlist, int n) {
- // Discovered checks
- Bitboard b = target & dc;
- while (b)
- {
- Square from = pop_1st_bit(&b);
- Bitboard bb = pos.piece_attacks<Piece>(from) & pos.empty_squares();
- while (bb)
- {
- Square to = pop_1st_bit(&bb);
- mlist[n++].move = make_move(from, to);
- }
- }
- // Direct checks
- b = target & ~dc;
- Bitboard checkSqs = pos.piece_attacks<Piece>(ksq) & pos.empty_squares();
- while (b)
- {
- Square from = pop_1st_bit(&b);
- Bitboard bb = pos.piece_attacks<Piece>(from) & checkSqs;
- while (bb)
- {
- Square to = pop_1st_bit(&bb);
- mlist[n++].move = make_move(from, to);
- }
- }
- return n;
- }
-
-
- template<> // Special case the King
- int generate_piece_checks<KING>(const Position& pos, Bitboard, Bitboard dc,
- Square ksq, MoveStack* mlist, int n) {
- if (bit_is_set(dc, ksq))
+ enum CastlingSide { KING_SIDE, QUEEN_SIDE };
+
+ template<CastlingSide Side, bool OnlyChecks>
+ MoveStack* generate_castle_moves(const Position& pos, MoveStack* mlist, Color us) {
+
+ const CastleRight CR[] = { Side ? WHITE_OOO : WHITE_OO,
+ Side ? BLACK_OOO : BLACK_OO };
+
+ if (!pos.can_castle(CR[us]))
+ 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 rto = relative_square(us, Side == KING_SIDE ? SQ_F1 : SQ_D1);
+ 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));
+
+ // Unimpeded rule: All the squares between the king's initial and final squares
+ // (including the final square), and all the squares between the rook's initial
+ // and final squares (including the final square), must be vacant except for
+ // the king and castling rook.
+ for (Square s = std::min(rfrom, rto), e = std::max(rfrom, rto); s <= e; s++)
+ if (s != kfrom && s != rfrom && !pos.square_is_empty(s))
+ return mlist;
+
+ for (Square s = std::min(kfrom, kto), e = std::max(kfrom, kto); s <= e; s++)
+ if ( (s != kfrom && s != rfrom && !pos.square_is_empty(s))
+ ||(pos.attackers_to(s) & enemies))
+ return mlist;
+
+ // Because we generate only legal castling moves we need to verify that
+ // when moving the castling rook we do not discover some hidden checker.
+ // For instance an enemy queen in SQ_A1 when castling rook is in SQ_B1.
+ if (pos.is_chess960())