template<Color, Color, Bitboard, Bitboard, SquareDelta>
MoveStack* generate_pawn_checks(const Position&, Bitboard, Square, MoveStack*);
+ template<Color Us, SquareDelta Direction>
+ inline Bitboard move_pawns(Bitboard p) {
+
+ if (Direction == DELTA_N)
+ return Us == WHITE ? p << 8 : p >> 8;
+ else if (Direction == DELTA_NE)
+ return Us == WHITE ? p << 9 : p >> 7;
+ else if (Direction == DELTA_NW)
+ return Us == WHITE ? p << 7 : p >> 9;
+
+ assert(false);
+ return p;
+ }
+
// Template generate_piece_checks() with specializations
template<PieceType>
MoveStack* generate_piece_checks(const Position&, MoveStack*, Color, Bitboard, Square);
/// generate_checks() generates all pseudo-legal non-capturing, non-promoting
/// checks. It returns the number of generated moves.
-int generate_checks(const Position& pos, MoveStack* mlist) {
+int generate_checks(const Position& pos, MoveStack* mlist, Bitboard dc) {
assert(pos.is_ok());
assert(!pos.is_check());
Color us = pos.side_to_move();
Square ksq = pos.king_square(opposite_color(us));
- Bitboard dc = pos.discovered_check_candidates(us);
MoveStack* mlist_start = mlist;
assert(pos.piece_on(ksq) == piece_of_color_and_type(opposite_color(us), KING));
/// in check. Unlike the other move generation functions, this one generates
/// only legal moves. It returns the number of generated moves.
-int generate_evasions(const Position& pos, MoveStack* mlist) {
+int generate_evasions(const Position& pos, MoveStack* mlist, Bitboard pinned) {
assert(pos.is_ok());
assert(pos.is_check());
if (!(checkers & (checkers - 1))) // Only one bit set?
{
Square checksq = first_1(checkers);
- Bitboard pinned = pos.pinned_pieces(us);
assert(pos.color_of_piece_on(checksq) == them);
Bitboard pinned = pos.pinned_pieces(pos.side_to_move());
if (pos.is_check())
- return generate_evasions(pos, mlist);
+ return generate_evasions(pos, mlist, pinned);
// Generate pseudo-legal moves
int n = generate_captures(pos, mlist);
// Remove illegal moves from the list
for (int i = 0; i < n; i++)
- if (!pos.pl_move_is_legal(mlist[i].move))
+ if (!pos.pl_move_is_legal(mlist[i].move, pinned))
mlist[i--].move = mlist[--n].move;
return n;
/// returned. If not, the function returns false. This function must
/// only be used when the side to move is not in check.
-bool move_is_legal(const Position& pos, const Move m) {
+bool move_is_legal(const Position& pos, const Move m, Bitboard pinned) {
assert(pos.is_ok());
assert(!pos.is_check());
assert(move_is_ok(m));
+ assert(pinned == pos.pinned_pieces(pos.side_to_move()));
Color us = pos.side_to_move();
Color them = opposite_color(us);
Square from = move_from(m);
Piece pc = pos.piece_on(from);
- Bitboard pinned = pos.pinned_pieces(us);
// If the from square is not occupied by a piece belonging to the side to
// move, the move is obviously not legal.
assert(pos.piece_on(to - pawn_push(us)) == piece_of_color_and_type(them, PAWN));
// The move is pseudo-legal, check if it is also legal
- return pos.pl_move_is_legal(m);
+ return pos.pl_move_is_legal(m, pinned);
}
// Castling moves
return false;
}
// The move is pseudo-legal, check if it is also legal
- return pos.pl_move_is_legal(m);
+ return pos.pl_move_is_legal(m, pinned);
}
// Luckly we can handle all the other pieces in one go
return ( pos.piece_attacks_square(pos.piece_on(from), from, to)
- && pos.pl_move_is_legal(m)
+ && pos.pl_move_is_legal(m, pinned)
&& !move_promotion(m));
}
Bitboard enemyPieces = pos.pieces_of_color(Them);
// Captures in the a1-h8 (a8-h1 for black) direction
- Bitboard b1 = (Us == WHITE ? pawns << 9 : pawns >> 7) & ~FileABB & enemyPieces;
+ Bitboard b1 = move_pawns<Us, DELTA_NE>(pawns) & ~FileABB & enemyPieces;
// Capturing promotions
Bitboard b2 = b1 & TRank8BB;
}
// Captures in the h1-a8 (h8-a1 for black) direction
- b1 = (Us == WHITE ? pawns << 7 : pawns >> 9) & ~FileHBB & enemyPieces;
+ b1 = move_pawns<Us, DELTA_NW>(pawns) & ~FileHBB & enemyPieces;
// Capturing promotions
b2 = b1 & TRank8BB;
}
// Non-capturing promotions
- b1 = (Us == WHITE ? pawns << 8 : pawns >> 8) & pos.empty_squares() & TRank8BB;
+ b1 = move_pawns<Us, DELTA_N>(pawns) & pos.empty_squares() & TRank8BB;
while (b1)
{
to = pop_1st_bit(&b1);
Square to;
// Underpromotion captures in the a1-h8 (a8-h1 for black) direction
- b1 = (Us == WHITE ? pawns << 9 : pawns >> 7) & ~FileABB & enemyPieces & TRank8BB;
+ b1 = move_pawns<Us, DELTA_NE>(pawns) & ~FileABB & enemyPieces & TRank8BB;
while (b1)
{
to = pop_1st_bit(&b1);
}
// Underpromotion captures in the h1-a8 (h8-a1 for black) direction
- b1 = (Us == WHITE ? pawns << 7 : pawns >> 9) & ~FileHBB & enemyPieces & TRank8BB;
+ b1 = move_pawns<Us, DELTA_NW>(pawns) & ~FileHBB & enemyPieces & TRank8BB;
while (b1)
{
to = pop_1st_bit(&b1);
}
// Single pawn pushes
- b1 = (Us == WHITE ? pawns << 8 : pawns >> 8) & emptySquares;
+ b1 = move_pawns<Us, DELTA_N>(pawns) & emptySquares;
b2 = b1 & TRank8BB;
while (b2)
{
}
// Double pawn pushes
- b2 = (Us == WHITE ? (b1 & TRank3BB) << 8 : (b1 & TRank3BB) >> 8) & emptySquares;
+ b2 = move_pawns<Us, DELTA_N>(b1 & TRank3BB) & emptySquares;
while (b2)
{
to = pop_1st_bit(&b2);
b1 = pos.pawns(Us) & ~file_bb(ksq);
// Discovered checks, single pawn pushes, no promotions
- b2 = b3 = (Us == WHITE ? (b1 & dc) << 8 : (b1 & dc) >> 8) & empty & ~TRank8BB;
+ b2 = b3 = move_pawns<Us, DELTA_N>(b1 & dc) & empty & ~TRank8BB;
while (b3)
{
Square to = pop_1st_bit(&b3);
}
// Discovered checks, double pawn pushes
- b3 = (Us == WHITE ? (b2 & TRank3BB) << 8 : (b2 & TRank3BB) >> 8) & empty;
+ b3 = move_pawns<Us, DELTA_N>(b2 & TRank3BB) & empty;
while (b3)
{
Square to = pop_1st_bit(&b3);
b1 = pos.pawns(Us) & neighboring_files_bb(ksq) & ~dc;
// Direct checks, single pawn pushes
- b2 = (Us == WHITE ? b1 << 8 : b1 >> 8) & empty;
+ b2 = move_pawns<Us, DELTA_N>(b1) & empty;
b3 = b2 & pos.pawn_attacks(Them, ksq);
while (b3)
{
}
// Direct checks, double pawn pushes
- b3 = (Us == WHITE ? (b2 & TRank3BB) << 8 : (b2 & TRank3BB) >> 8)
- & empty
- & pos.pawn_attacks(Them, ksq);
+ b3 = move_pawns<Us, DELTA_N>(b2 & TRank3BB) & empty & pos.pawn_attacks(Them, ksq);
while (b3)
{
Square to = pop_1st_bit(&b3);
Bitboard blockSquares, MoveStack* mlist) {
Square to;
- // Find non-pinned pawns
- Bitboard b1 = pos.pawns(Us) & ~pinned;
+ // Find non-pinned pawns and push them one square
+ Bitboard b1 = move_pawns<Us, DELTA_N>(pos.pawns(Us) & ~pinned);
- // Single pawn pushes. We don't have to AND with empty squares here,
+ // We don't have to AND with empty squares here,
// because the blocking squares will always be empty.
- Bitboard b2 = (Us == WHITE ? b1 << 8 : b1 >> 8) & blockSquares;
+ Bitboard b2 = b1 & blockSquares;
while (b2)
{
to = pop_1st_bit(&b2);
}
// Double pawn pushes
- b2 = (Us == WHITE ? b1 << 8 : b1 >> 8) & pos.empty_squares() & TRank3BB;
- b2 = (Us == WHITE ? b2 << 8 : b2 >> 8) & blockSquares;
+ b2 = b1 & pos.empty_squares() & TRank3BB;
+ b2 = move_pawns<Us, DELTA_N>(b2) & blockSquares;
while (b2)
{
to = pop_1st_bit(&b2);