enum MoveType {
CAPTURE,
- NON_CAPTURE
+ NON_CAPTURE,
+ CHECK,
+ EVASION
};
// Functions
template<CastlingSide Side>
MoveStack* generate_castle_moves(const Position&, MoveStack*);
- template<Color Us>
- MoveStack* generate_pawn_blocking_evasions(const Position&, Bitboard, Bitboard, MoveStack*);
-
- template<Color Us>
- MoveStack* generate_pawn_captures(const Position&, MoveStack*);
-
template<Color Us, SquareDelta Diagonal>
MoveStack* generate_pawn_captures_diagonal(MoveStack*, Bitboard, Bitboard, bool);
- template<Color Us, bool Checks>
- MoveStack* generate_pawn_noncaptures(const Position&, MoveStack*, Bitboard = EmptyBoardBB, Square = SQ_NONE);
+ template<Color Us, MoveType Type>
+ MoveStack* generate_pawn_moves(const Position&, MoveStack*, Bitboard = EmptyBoardBB,
+ Square = SQ_NONE, Bitboard = EmptyBoardBB);
template<Color Us, SquareDelta Direction>
inline Bitboard move_pawns(Bitboard p) {
template<>
inline MoveStack* generate_piece_checks<PAWN>(const Position& p, MoveStack* m, Color us, Bitboard dc, Square ksq) {
- return (us == WHITE ? generate_pawn_noncaptures<WHITE, true>(p, m, dc, ksq)
- : generate_pawn_noncaptures<BLACK, true>(p, m, dc, ksq));
+ return (us == WHITE ? generate_pawn_moves<WHITE, CHECK>(p, m, dc, ksq)
+ : generate_pawn_moves<BLACK, CHECK>(p, m, dc, ksq));
}
// Template generate_piece_moves() with specializations and overloads
template<PieceType Piece, MoveType Type>
inline MoveStack* generate_piece_moves(const Position& p, MoveStack* m, Color us) {
- assert(Piece == PAWN);
+ assert(Piece == PAWN);
+ assert(Type == CAPTURE || Type == NON_CAPTURE);
- if (Type == CAPTURE)
- return (us == WHITE ? generate_pawn_captures<WHITE>(p, m)
- : generate_pawn_captures<BLACK>(p, m));
- else
- return (us == WHITE ? generate_pawn_noncaptures<WHITE, false>(p, m)
- : generate_pawn_noncaptures<BLACK, false>(p, m));
+ return (us == WHITE ? generate_pawn_moves<WHITE, Type>(p, m)
+ : generate_pawn_moves<BLACK, Type>(p, m));
}
template<PieceType>
inline MoveStack* generate_piece_moves<PAWN>(const Position& p, MoveStack* m,
Color us, Bitboard t, Bitboard pnd) {
- return (us == WHITE ? generate_pawn_blocking_evasions<WHITE>(p, pnd, t, m)
- : generate_pawn_blocking_evasions<BLACK>(p, pnd, t, m));
+ return (us == WHITE ? generate_pawn_moves<WHITE, EVASION>(p, m, pnd, SQ_NONE, t)
+ : generate_pawn_moves<BLACK, EVASION>(p, m, pnd, SQ_NONE, t));
}
}
return false;
// Proceed according to the square delta between the origin and
- // destionation squares.
+ // destination squares.
switch (direction)
{
case DELTA_NW:
return mlist;
}
+ template<>
+ MoveStack* generate_piece_moves<KING>(const Position& pos, MoveStack* mlist, Color us, Bitboard target) {
+
+ Bitboard b;
+ Square from = pos.king_square(us);
+
+ b = pos.attacks_from<KING>(from) & target;
+ SERIALIZE_MOVES(b);
+ return mlist;
+ }
+
template<PieceType Piece>
MoveStack* generate_piece_moves(const Position& pos, MoveStack* mlist,
Color us, Bitboard target, Bitboard pinned) {
return mlist;
}
- template<>
- MoveStack* generate_piece_moves<KING>(const Position& pos, MoveStack* mlist, Color us, Bitboard target) {
-
- Bitboard b;
- Square from = pos.king_square(us);
-
- b = pos.attacks_from<KING>(from) & target;
- SERIALIZE_MOVES(b);
- return mlist;
- }
-
template<Color Us, SquareDelta Diagonal>
MoveStack* generate_pawn_captures_diagonal(MoveStack* mlist, Bitboard pawns, Bitboard enemyPieces, bool promotion) {
return mlist;
}
- template<Color Us>
- MoveStack* generate_pawn_captures(const Position& pos, MoveStack* mlist) {
+ template<Color Us, MoveType Type>
+ MoveStack* generate_pawn_moves(const Position& pos, MoveStack* mlist, Bitboard dcp,
+ Square ksq, Bitboard blockSquares) {
// Calculate our parametrized parameters at compile time
const Color Them = (Us == WHITE ? BLACK : WHITE);
const Bitboard TRank8BB = (Us == WHITE ? Rank8BB : Rank1BB);
const Bitboard TRank7BB = (Us == WHITE ? Rank7BB : Rank2BB);
+ const Bitboard TRank3BB = (Us == WHITE ? Rank3BB : Rank6BB);
+ const SquareDelta TDELTA_NE = (Us == WHITE ? DELTA_NE : DELTA_SE);
+ const SquareDelta TDELTA_NW = (Us == WHITE ? DELTA_NW : DELTA_SW);
const SquareDelta TDELTA_N = (Us == WHITE ? DELTA_N : DELTA_S);
+ Bitboard b1, b2, dcPawns1, dcPawns2;
Square to;
- Bitboard pawns = pos.pieces(PAWN, Us);
- Bitboard enemyPieces = pos.pieces_of_color(opposite_color(Us));
+ Bitboard pawns = (Type != EVASION ? pos.pieces(PAWN, Us) : pos.pieces(PAWN, Us) & ~dcp);
+ Bitboard emptySquares = pos.empty_squares();
bool possiblePromotion = (pawns & TRank7BB);
- // Standard captures and capturing promotions in both directions
- mlist = generate_pawn_captures_diagonal<Us, DELTA_NE>(mlist, pawns, enemyPieces, possiblePromotion);
- mlist = generate_pawn_captures_diagonal<Us, DELTA_NW>(mlist, pawns, enemyPieces, possiblePromotion);
+ if (Type == CAPTURE)
+ {
+ // Standard captures and capturing promotions in both directions
+ Bitboard enemyPieces = pos.pieces_of_color(opposite_color(Us));
+ mlist = generate_pawn_captures_diagonal<Us, DELTA_NE>(mlist, pawns, enemyPieces, possiblePromotion);
+ mlist = generate_pawn_captures_diagonal<Us, DELTA_NW>(mlist, pawns, enemyPieces, possiblePromotion);
+ }
- // Non-capturing promotions
if (possiblePromotion)
{
- Bitboard b1 = move_pawns<Us, DELTA_N>(pawns) & pos.empty_squares() & TRank8BB;
- while (b1)
+ // When generating checks consider under-promotion moves (both captures
+ // and non captures) only if can give a discovery check. Note that dcp
+ // is dc bitboard or pinned bitboard when Type == EVASION.
+ Bitboard pp = (Type == CHECK ? pawns & dcp : pawns);
+
+ if (Type != EVASION && Type != CAPTURE)
{
- to = pop_1st_bit(&b1);
- (*mlist++).move = make_promotion_move(to - TDELTA_N, to, QUEEN);
+ Bitboard enemyPieces = pos.pieces_of_color(opposite_color(Us));
+
+ // Underpromotion captures in the a1-h8 (a8-h1 for black) direction
+ b1 = move_pawns<Us, DELTA_NE>(pp) & ~FileABB & enemyPieces & TRank8BB;
+ while (b1)
+ {
+ to = pop_1st_bit(&b1);
+ (*mlist++).move = make_promotion_move(to - TDELTA_NE, to, ROOK);
+ (*mlist++).move = make_promotion_move(to - TDELTA_NE, to, BISHOP);
+ (*mlist++).move = make_promotion_move(to - TDELTA_NE, to, KNIGHT);
+ }
+
+ // Underpromotion captures in the h1-a8 (h8-a1 for black) direction
+ b1 = move_pawns<Us, DELTA_NW>(pp) & ~FileHBB & enemyPieces & TRank8BB;
+ while (b1)
+ {
+ to = pop_1st_bit(&b1);
+ (*mlist++).move = make_promotion_move(to - TDELTA_NW, to, ROOK);
+ (*mlist++).move = make_promotion_move(to - TDELTA_NW, to, BISHOP);
+ (*mlist++).move = make_promotion_move(to - TDELTA_NW, to, KNIGHT);
+ }
}
- }
-
- // En passant captures
- if (pos.ep_square() != SQ_NONE)
- {
- assert(Us != WHITE || square_rank(pos.ep_square()) == RANK_6);
- assert(Us != BLACK || square_rank(pos.ep_square()) == RANK_3);
- Bitboard b1 = pawns & pos.attacks_from<PAWN>(pos.ep_square(), Them);
- assert(b1 != EmptyBoardBB);
+ // Underpromotion pawn pushes. Also promotion for evasions and captures.
+ b1 = move_pawns<Us, DELTA_N>(pp) & TRank8BB;
+ b1 &= (Type == EVASION ? blockSquares : emptySquares);
while (b1)
{
to = pop_1st_bit(&b1);
- (*mlist++).move = make_ep_move(to, pos.ep_square());
+ if (Type == EVASION || Type == CAPTURE)
+ (*mlist++).move = make_promotion_move(to - TDELTA_N, to, QUEEN);
+
+ if (Type != CAPTURE)
+ {
+ (*mlist++).move = make_promotion_move(to - TDELTA_N, to, ROOK);
+ (*mlist++).move = make_promotion_move(to - TDELTA_N, to, BISHOP);
+ (*mlist++).move = make_promotion_move(to - TDELTA_N, to, KNIGHT);
+ }
}
}
- return mlist;
- }
-
- template<Color Us, bool GenerateChecks>
- MoveStack* generate_pawn_noncaptures(const Position& pos, MoveStack* mlist, Bitboard dc, Square ksq) {
- // Calculate our parametrized parameters at compile time
- const Color Them = (Us == WHITE ? BLACK : WHITE);
- const Bitboard TRank8BB = (Us == WHITE ? Rank8BB : Rank1BB);
- const Bitboard TRank7BB = (Us == WHITE ? Rank7BB : Rank2BB);
- const Bitboard TRank3BB = (Us == WHITE ? Rank3BB : Rank6BB);
- const SquareDelta TDELTA_NE = (Us == WHITE ? DELTA_NE : DELTA_SE);
- const SquareDelta TDELTA_NW = (Us == WHITE ? DELTA_NW : DELTA_SW);
- const SquareDelta TDELTA_N = (Us == WHITE ? DELTA_N : DELTA_S);
-
- Bitboard b1, b2, dcPawns1, dcPawns2;
- Square to;
- Bitboard pawns = pos.pieces(PAWN, Us);
- Bitboard emptySquares = pos.empty_squares();
-
- if (pawns & TRank7BB) // There is some promotion candidate ?
+ if (Type == CAPTURE)
{
- // When generating checks consider under-promotion moves (both captures
- // and non captures) only if can give a discovery check.
- Bitboard pp = GenerateChecks ? pawns & dc : pawns;
- Bitboard enemyPieces = pos.pieces_of_color(opposite_color(Us));
-
- // Underpromotion captures in the a1-h8 (a8-h1 for black) direction
- b1 = move_pawns<Us, DELTA_NE>(pp) & ~FileABB & enemyPieces & TRank8BB;
- while (b1)
+ // En passant captures
+ if (pos.ep_square() != SQ_NONE)
{
- to = pop_1st_bit(&b1);
- (*mlist++).move = make_promotion_move(to - TDELTA_NE, to, ROOK);
- (*mlist++).move = make_promotion_move(to - TDELTA_NE, to, BISHOP);
- (*mlist++).move = make_promotion_move(to - TDELTA_NE, to, KNIGHT);
- }
+ assert(Us != WHITE || square_rank(pos.ep_square()) == RANK_6);
+ assert(Us != BLACK || square_rank(pos.ep_square()) == RANK_3);
- // Underpromotion captures in the h1-a8 (h8-a1 for black) direction
- b1 = move_pawns<Us, DELTA_NW>(pp) & ~FileHBB & enemyPieces & TRank8BB;
- while (b1)
- {
- to = pop_1st_bit(&b1);
- (*mlist++).move = make_promotion_move(to - TDELTA_NW, to, ROOK);
- (*mlist++).move = make_promotion_move(to - TDELTA_NW, to, BISHOP);
- (*mlist++).move = make_promotion_move(to - TDELTA_NW, to, KNIGHT);
- }
+ Bitboard b1 = pawns & pos.attacks_from<PAWN>(pos.ep_square(), Them);
+ assert(b1 != EmptyBoardBB);
- // Underpromotion pawn pushes
- b1 = move_pawns<Us, DELTA_N>(pp) & emptySquares & TRank8BB;
- while (b1)
- {
- to = pop_1st_bit(&b1);
- (*mlist++).move = make_promotion_move(to - TDELTA_N, to, ROOK);
- (*mlist++).move = make_promotion_move(to - TDELTA_N, to, BISHOP);
- (*mlist++).move = make_promotion_move(to - TDELTA_N, to, KNIGHT);
+ while (b1)
+ {
+ to = pop_1st_bit(&b1);
+ (*mlist++).move = make_ep_move(to, pos.ep_square());
+ }
}
+ return mlist;
}
dcPawns1 = dcPawns2 = EmptyBoardBB;
- if (GenerateChecks && (dc & pawns))
+ if (Type == CHECK && (pawns & dcp))
{
// Pawn moves which gives discovered check. This is possible only if the
// pawn is not on the same file as the enemy king, because we don't
// generate captures.
- dcPawns1 = move_pawns<Us, DELTA_N>(pawns & dc & ~file_bb(ksq)) & emptySquares & ~TRank8BB;
+ dcPawns1 = move_pawns<Us, DELTA_N>(pawns & dcp & ~file_bb(ksq)) & emptySquares & ~TRank8BB;
dcPawns2 = move_pawns<Us, DELTA_N>(dcPawns1 & TRank3BB) & emptySquares;
}
// Single pawn pushes
b1 = move_pawns<Us, DELTA_N>(pawns) & emptySquares & ~TRank8BB;
- b2 = GenerateChecks ? (b1 & pos.attacks_from<PAWN>(ksq, Them)) | dcPawns1 : b1;
+ b2 = (Type == CHECK ? (b1 & pos.attacks_from<PAWN>(ksq, Them)) | dcPawns1 :
+ (Type == EVASION ? b1 & blockSquares : b1));
SERIALIZE_MOVES_D(b2, -TDELTA_N);
// Double pawn pushes
b1 = move_pawns<Us, DELTA_N>(b1 & TRank3BB) & emptySquares;
- b2 = GenerateChecks ? (b1 & pos.attacks_from<PAWN>(ksq, Them)) | dcPawns2 : b1;
+ b2 = (Type == CHECK ? (b1 & pos.attacks_from<PAWN>(ksq, Them)) | dcPawns2 :
+ (Type == EVASION ? b1 & blockSquares : b1));
SERIALIZE_MOVES_D(b2, -TDELTA_N -TDELTA_N);
return mlist;
}
Bitboard target = pos.pieces(Piece, us);
- // Discovered checks
+ // Discovered non-capture checks
Bitboard b = target & dc;
+
+ assert(Piece != QUEEN || !b);
+
while (b)
{
Square from = pop_1st_bit(&b);
SERIALIZE_MOVES(bb);
}
- // Direct checks
+ // Direct non-capture checks
b = target & ~dc;
Bitboard checkSqs = pos.attacks_from<Piece>(ksq) & pos.empty_squares();
if (Piece == KING || !checkSqs)
return mlist;
}
- template<Color Us>
- MoveStack* generate_pawn_blocking_evasions(const Position& pos, Bitboard pinned,
- Bitboard blockSquares, MoveStack* mlist) {
-
- // Calculate our parametrized parameters at compile time
- const Rank TRANK_8 = (Us == WHITE ? RANK_8 : RANK_1);
- const Bitboard TRank3BB = (Us == WHITE ? Rank3BB : Rank6BB);
- const SquareDelta TDELTA_N = (Us == WHITE ? DELTA_N : DELTA_S);
-
- Square to;
-
- // Find non-pinned pawns and push them one square
- Bitboard b1 = move_pawns<Us, DELTA_N>(pos.pieces(PAWN, Us) & ~pinned);
-
- // We don't have to AND with empty squares here,
- // because the blocking squares will always be empty.
- Bitboard b2 = b1 & blockSquares;
- while (b2)
- {
- to = pop_1st_bit(&b2);
-
- assert(pos.piece_on(to) == EMPTY);
-
- if (square_rank(to) == TRANK_8)
- {
- (*mlist++).move = make_promotion_move(to - TDELTA_N, to, QUEEN);
- (*mlist++).move = make_promotion_move(to - TDELTA_N, to, ROOK);
- (*mlist++).move = make_promotion_move(to - TDELTA_N, to, BISHOP);
- (*mlist++).move = make_promotion_move(to - TDELTA_N, to, KNIGHT);
- } else
- (*mlist++).move = make_move(to - TDELTA_N, to);
- }
-
- // Double pawn pushes
- b2 = b1 & pos.empty_squares() & TRank3BB;
- b2 = move_pawns<Us, DELTA_N>(b2) & blockSquares;
- while (b2)
- {
- to = pop_1st_bit(&b2);
-
- assert(pos.piece_on(to) == EMPTY);
- assert(Us != WHITE || square_rank(to) == RANK_4);
- assert(Us != BLACK || square_rank(to) == RANK_5);
-
- (*mlist++).move = make_move(to - TDELTA_N - TDELTA_N, to);
- }
- return mlist;
- }
-
template<CastlingSide Side>
MoveStack* generate_castle_moves(const Position& pos, MoveStack* mlist) {
projects / stockfish / blobdiff