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;
+ else
+ 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.
+/// generate_non_capture_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_non_capture_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);
/// 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.
// Proceed according to the type of the moving piece.
if (type_of_piece(pc) == PAWN)
{
+ // Move direction must be compatible with pawn color
+ int direction = to - from;
+ if ((us == WHITE) != (direction > 0))
+ return false;
+
// If the destination square is on the 8/1th rank, the move must
// be a promotion.
if ( ( (square_rank(to) == RANK_8 && us == WHITE)
// Proceed according to the square delta between the source and
// destionation squares.
- switch (to - from)
+ switch (direction)
{
case DELTA_NW:
case DELTA_NE:
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);
return mlist;
Bitboard checkSqs = pos.piece_attacks<Piece>(ksq) & pos.empty_squares();
+ if (!checkSqs)
+ return mlist;
+
while (b)
{
Square from = pop_1st_bit(&b);
+ if ( (Piece == QUEEN && !(QueenPseudoAttacks[from] & checkSqs))
+ || (Piece == ROOK && !(RookPseudoAttacks[from] & checkSqs))
+ || (Piece == BISHOP && !(BishopPseudoAttacks[from] & checkSqs)))
+ continue;
+
Bitboard bb = pos.piece_attacks<Piece>(from) & checkSqs;
SERIALIZE_MOVES(bb);
}
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);
projects / stockfish / blobdiff