mirror of
https://github.com/sockspls/badfish
synced 2025-04-29 16:23:09 +00:00
Space inflate generate_evasions()
Signed-off-by: Marco Costalba <mcostalba@gmail.com>
This commit is contained in:
parent
72289fcfab
commit
987ff3b4b6
1 changed files with 216 additions and 199 deletions
415
src/movegen.cpp
415
src/movegen.cpp
|
@ -48,20 +48,19 @@ namespace {
|
||||||
typedef Bitboard (*Shift_fn)(Bitboard b);
|
typedef Bitboard (*Shift_fn)(Bitboard b);
|
||||||
Shift_fn forward, forward_left, forward_right;
|
Shift_fn forward, forward_left, forward_right;
|
||||||
};
|
};
|
||||||
const PawnOffsets WhitePawnOffsets = { Rank3BB, Rank8BB, DELTA_N, DELTA_NE, DELTA_NW, WHITE,
|
|
||||||
BLACK, &forward_white, forward_left_white, forward_right_white };
|
|
||||||
|
|
||||||
const PawnOffsets BlackPawnOffsets = { Rank6BB, Rank1BB, DELTA_S, DELTA_SE, DELTA_SW, BLACK,
|
const PawnOffsets WhitePawnOffsets = { Rank3BB, Rank8BB, DELTA_N, DELTA_NE, DELTA_NW, WHITE, BLACK,
|
||||||
WHITE, &forward_black, &forward_left_black, &forward_right_black };
|
&forward_white, forward_left_white, forward_right_white };
|
||||||
|
|
||||||
|
const PawnOffsets BlackPawnOffsets = { Rank6BB, Rank1BB, DELTA_S, DELTA_SE, DELTA_SW, BLACK, WHITE,
|
||||||
|
&forward_black, &forward_left_black, &forward_right_black };
|
||||||
|
|
||||||
int generate_pawn_captures(const PawnOffsets&, const Position&, MoveStack*);
|
int generate_pawn_captures(const PawnOffsets&, const Position&, MoveStack*);
|
||||||
int generate_pawn_noncaptures(const PawnOffsets&, const Position&, MoveStack*);
|
int generate_pawn_noncaptures(const PawnOffsets&, const Position&, MoveStack*);
|
||||||
int generate_pawn_checks(const PawnOffsets&, const Position&, Bitboard dc, Square ksq, MoveStack*, int n);
|
int generate_pawn_checks(const PawnOffsets&, const Position&, Bitboard dc, Square ksq, MoveStack*, int n);
|
||||||
|
int generate_piece_checks(PieceType pce, const Position& pos, Bitboard target, Bitboard dc, Square ksq, MoveStack* mlist, int n);
|
||||||
int generate_piece_moves(PieceType, const Position&, MoveStack*, Color side, Bitboard t);
|
int generate_piece_moves(PieceType, const Position&, MoveStack*, Color side, Bitboard t);
|
||||||
int generate_castle_moves(const Position&, MoveStack*, Color us);
|
int generate_castle_moves(const Position&, MoveStack*, Color us);
|
||||||
|
|
||||||
int generate_piece_checks(PieceType pce, const Position& pos, Bitboard target,
|
|
||||||
Bitboard dc, Square ksq, MoveStack* mlist, int n);
|
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
||||||
|
@ -182,235 +181,253 @@ int generate_checks(const Position& pos, MoveStack* mlist, Bitboard dc) {
|
||||||
/// only legal moves. It returns the number of generated moves. This
|
/// only legal moves. It returns the number of generated moves. This
|
||||||
/// function is very ugly, and needs cleaning up some time later. FIXME
|
/// function is very ugly, and needs cleaning up some time later. FIXME
|
||||||
|
|
||||||
int generate_evasions(const Position &pos, MoveStack *mlist) {
|
int generate_evasions(const Position& pos, MoveStack* mlist) {
|
||||||
|
|
||||||
assert(pos.is_ok());
|
assert(pos.is_ok());
|
||||||
assert(pos.is_check());
|
assert(pos.is_check());
|
||||||
|
|
||||||
Color us, them;
|
Color us = pos.side_to_move();
|
||||||
Bitboard checkers = pos.checkers();
|
Color them = opposite_color(us);
|
||||||
Bitboard pinned, b1, b2;
|
Square ksq = pos.king_square(us);
|
||||||
Square ksq, from, to;
|
Square from, to;
|
||||||
int n = 0;
|
int n = 0;
|
||||||
|
|
||||||
us = pos.side_to_move();
|
|
||||||
them = opposite_color(us);
|
|
||||||
|
|
||||||
ksq = pos.king_square(us);
|
|
||||||
assert(pos.piece_on(ksq) == king_of_color(us));
|
assert(pos.piece_on(ksq) == king_of_color(us));
|
||||||
|
|
||||||
// Generate evasions for king:
|
// Generate evasions for king
|
||||||
b1 = pos.king_attacks(ksq) & ~pos.pieces_of_color(us);
|
Bitboard b1 = pos.king_attacks(ksq) & ~pos.pieces_of_color(us);
|
||||||
b2 = pos.occupied_squares();
|
Bitboard b2 = pos.occupied_squares();
|
||||||
clear_bit(&b2, ksq);
|
clear_bit(&b2, ksq);
|
||||||
while(b1) {
|
|
||||||
to = pop_1st_bit(&b1);
|
|
||||||
|
|
||||||
// Make sure to is not attacked by the other side. This is a bit ugly,
|
while (b1)
|
||||||
// because we can't use Position::square_is_attacked. Instead we use
|
{
|
||||||
|
Square to = pop_1st_bit(&b1);
|
||||||
|
|
||||||
|
// Make sure to is not attacked by the other side. This is a bit ugly,
|
||||||
|
// because we can't use Position::square_is_attacked. Instead we use
|
||||||
// the low-level bishop_attacks_bb and rook_attacks_bb with the bitboard
|
// the low-level bishop_attacks_bb and rook_attacks_bb with the bitboard
|
||||||
// b2 (the occupied squares with the king removed) in order to test whether
|
// b2 (the occupied squares with the king removed) in order to test whether
|
||||||
// the king will remain in check on the destination square.
|
// the king will remain in check on the destination square.
|
||||||
if(((pos.pawn_attacks(us, to) & pos.pawns(them)) == EmptyBoardBB) &&
|
if (!( (bishop_attacks_bb(to, b2) & pos.bishops_and_queens(them))
|
||||||
((pos.knight_attacks(to) & pos.knights(them)) == EmptyBoardBB) &&
|
|| (rook_attacks_bb(to, b2) & pos.rooks_and_queens(them))
|
||||||
((pos.king_attacks(to) & pos.kings(them)) == EmptyBoardBB) &&
|
|| (pos.knight_attacks(to) & pos.knights(them))
|
||||||
((bishop_attacks_bb(to, b2) & pos.bishops_and_queens(them))
|
|| (pos.pawn_attacks(us, to) & pos.pawns(them))
|
||||||
== EmptyBoardBB) &&
|
|| (pos.king_attacks(to) & pos.kings(them))))
|
||||||
((rook_attacks_bb(to, b2) & pos.rooks_and_queens(them)) == EmptyBoardBB))
|
|
||||||
mlist[n++].move = make_move(ksq, to);
|
mlist[n++].move = make_move(ksq, to);
|
||||||
}
|
}
|
||||||
|
|
||||||
|
// Generate evasions for other pieces only if not double check. We use a
|
||||||
// Generate evasions for other pieces only if not double check. We use a
|
|
||||||
// simple bit twiddling hack here rather than calling count_1s in order to
|
// simple bit twiddling hack here rather than calling count_1s in order to
|
||||||
// save some time (we know that pos.checkers() has at most two nonzero bits).
|
// save some time (we know that pos.checkers() has at most two nonzero bits).
|
||||||
if(!(checkers & (checkers - 1))) {
|
Bitboard checkers = pos.checkers();
|
||||||
Square checksq = first_1(checkers);
|
|
||||||
assert(pos.color_of_piece_on(checksq) == them);
|
|
||||||
|
|
||||||
// Find pinned pieces:
|
if (!(checkers & (checkers - 1))) // Only one bit set?
|
||||||
pinned = pos.pinned_pieces(us);
|
{
|
||||||
|
Square checksq = first_1(checkers);
|
||||||
|
|
||||||
// Generate captures of the checking piece:
|
assert(pos.color_of_piece_on(checksq) == them);
|
||||||
|
|
||||||
// Pawn captures:
|
// Find pinned pieces
|
||||||
b1 = pos.pawn_attacks(them, checksq) & pos.pawns(us) & ~pinned;
|
Bitboard not_pinned = ~pos.pinned_pieces(us);
|
||||||
while(b1) {
|
|
||||||
from = pop_1st_bit(&b1);
|
// Generate captures of the checking piece
|
||||||
if(relative_rank(us, checksq) == RANK_8) {
|
|
||||||
mlist[n++].move = make_promotion_move(from, checksq, QUEEN);
|
// Pawn captures
|
||||||
mlist[n++].move = make_promotion_move(from, checksq, ROOK);
|
b1 = pos.pawn_attacks(them, checksq) & pos.pawns(us) & not_pinned;
|
||||||
mlist[n++].move = make_promotion_move(from, checksq, BISHOP);
|
while (b1)
|
||||||
mlist[n++].move = make_promotion_move(from, checksq, KNIGHT);
|
{
|
||||||
|
from = pop_1st_bit(&b1);
|
||||||
|
if (relative_rank(us, checksq) == RANK_8)
|
||||||
|
{
|
||||||
|
mlist[n++].move = make_promotion_move(from, checksq, QUEEN);
|
||||||
|
mlist[n++].move = make_promotion_move(from, checksq, ROOK);
|
||||||
|
mlist[n++].move = make_promotion_move(from, checksq, BISHOP);
|
||||||
|
mlist[n++].move = make_promotion_move(from, checksq, KNIGHT);
|
||||||
|
} else
|
||||||
|
mlist[n++].move = make_move(from, checksq);
|
||||||
}
|
}
|
||||||
else
|
|
||||||
mlist[n++].move = make_move(from, checksq);
|
|
||||||
}
|
|
||||||
|
|
||||||
// Knight captures:
|
// Pieces captures
|
||||||
b1 = pos.knight_attacks(checksq) & pos.knights(us) & ~pinned;
|
b1 = pos.knight_attacks(checksq) & pos.knights(us)
|
||||||
while(b1) {
|
& pos.bishop_attacks(checksq) & pos.bishops_and_queens(us)
|
||||||
from = pop_1st_bit(&b1);
|
& pos.rook_attacks(checksq) & pos.rooks_and_queens(us)
|
||||||
mlist[n++].move = make_move(from, checksq);
|
& not_pinned;
|
||||||
}
|
|
||||||
|
|
||||||
// Bishop and queen captures:
|
while (b1)
|
||||||
b1 = pos.bishop_attacks(checksq) & pos.bishops_and_queens(us)
|
{
|
||||||
& ~pinned;
|
from = pop_1st_bit(&b1);
|
||||||
while(b1) {
|
mlist[n++].move = make_move(from, checksq);
|
||||||
from = pop_1st_bit(&b1);
|
}
|
||||||
mlist[n++].move = make_move(from, checksq);
|
|
||||||
}
|
|
||||||
|
|
||||||
// Rook and queen captures:
|
// Blocking check evasions are possible only if the checking piece is
|
||||||
b1 = pos.rook_attacks(checksq) & pos.rooks_and_queens(us)
|
// a slider
|
||||||
& ~pinned;
|
if (checkers & pos.sliders())
|
||||||
while(b1) {
|
{
|
||||||
from = pop_1st_bit(&b1);
|
Bitboard blockSquares = squares_between(checksq, ksq);
|
||||||
mlist[n++].move = make_move(from, checksq);
|
|
||||||
}
|
|
||||||
|
|
||||||
// Blocking check evasions are possible only if the checking piece is
|
assert((pos.occupied_squares() & blockSquares) == EmptyBoardBB);
|
||||||
// a slider:
|
|
||||||
if(checkers & pos.sliders()) {
|
|
||||||
Bitboard blockSquares = squares_between(checksq, ksq);
|
|
||||||
assert((pos.occupied_squares() & blockSquares) == EmptyBoardBB);
|
|
||||||
|
|
||||||
// Pawn moves. Because a blocking evasion can never be a capture, we
|
// Pawn moves. Because a blocking evasion can never be a capture, we
|
||||||
// only generate pawn pushes. As so often, the code for pawns is a bit
|
// only generate pawn pushes. As so often, the code for pawns is a bit
|
||||||
// ugly, and uses separate clauses for white and black pawns. :-(
|
// ugly, and uses separate clauses for white and black pawns. :-(
|
||||||
if(us == WHITE) {
|
if (us == WHITE)
|
||||||
// Find non-pinned pawns:
|
{
|
||||||
b1 = pos.pawns(WHITE) & ~pinned;
|
// Find non-pinned pawns
|
||||||
|
b1 = pos.pawns(WHITE) & not_pinned;
|
||||||
|
|
||||||
// Single pawn pushes. We don't have to AND with empty squares here,
|
// Single pawn pushes. We don't have to AND with empty squares here,
|
||||||
// because the blocking squares will always be empty.
|
// because the blocking squares will always be empty.
|
||||||
b2 = (b1 << 8) & blockSquares;
|
b2 = (b1 << 8) & blockSquares;
|
||||||
while(b2) {
|
while(b2)
|
||||||
to = pop_1st_bit(&b2);
|
{
|
||||||
assert(pos.piece_on(to) == EMPTY);
|
to = pop_1st_bit(&b2);
|
||||||
if(square_rank(to) == RANK_8) {
|
|
||||||
mlist[n++].move = make_promotion_move(to - DELTA_N, to, QUEEN);
|
assert(pos.piece_on(to) == EMPTY);
|
||||||
mlist[n++].move = make_promotion_move(to - DELTA_N, to, ROOK);
|
|
||||||
mlist[n++].move = make_promotion_move(to - DELTA_N, to, BISHOP);
|
if (square_rank(to) == RANK_8)
|
||||||
mlist[n++].move = make_promotion_move(to - DELTA_N, to, KNIGHT);
|
{
|
||||||
|
mlist[n++].move = make_promotion_move(to - DELTA_N, to, QUEEN);
|
||||||
|
mlist[n++].move = make_promotion_move(to - DELTA_N, to, ROOK);
|
||||||
|
mlist[n++].move = make_promotion_move(to - DELTA_N, to, BISHOP);
|
||||||
|
mlist[n++].move = make_promotion_move(to - DELTA_N, to, KNIGHT);
|
||||||
|
} else
|
||||||
|
mlist[n++].move = make_move(to - DELTA_N, to);
|
||||||
|
}
|
||||||
|
|
||||||
|
// Double pawn pushes
|
||||||
|
b2 = (((b1 << 8) & pos.empty_squares() & Rank3BB) << 8) & blockSquares;
|
||||||
|
while (b2)
|
||||||
|
{
|
||||||
|
to = pop_1st_bit(&b2);
|
||||||
|
|
||||||
|
assert(pos.piece_on(to) == EMPTY);
|
||||||
|
assert(square_rank(to) == RANK_4);
|
||||||
|
|
||||||
|
mlist[n++].move = make_move(to - DELTA_N - DELTA_N, to);
|
||||||
|
}
|
||||||
|
} else { // (us == BLACK)
|
||||||
|
|
||||||
|
// Find non-pinned pawns
|
||||||
|
b1 = pos.pawns(BLACK) & not_pinned;
|
||||||
|
|
||||||
|
// Single pawn pushes. We don't have to AND with empty squares here,
|
||||||
|
// because the blocking squares will always be empty.
|
||||||
|
b2 = (b1 >> 8) & blockSquares;
|
||||||
|
while (b2)
|
||||||
|
{
|
||||||
|
to = pop_1st_bit(&b2);
|
||||||
|
|
||||||
|
assert(pos.piece_on(to) == EMPTY);
|
||||||
|
|
||||||
|
if (square_rank(to) == RANK_1)
|
||||||
|
{
|
||||||
|
mlist[n++].move = make_promotion_move(to - DELTA_S, to, QUEEN);
|
||||||
|
mlist[n++].move = make_promotion_move(to - DELTA_S, to, ROOK);
|
||||||
|
mlist[n++].move = make_promotion_move(to - DELTA_S, to, BISHOP);
|
||||||
|
mlist[n++].move = make_promotion_move(to - DELTA_S, to, KNIGHT);
|
||||||
|
} else
|
||||||
|
mlist[n++].move = make_move(to - DELTA_S, to);
|
||||||
|
}
|
||||||
|
|
||||||
|
// Double pawn pushes
|
||||||
|
b2 = (((b1 >> 8) & pos.empty_squares() & Rank6BB) >> 8) & blockSquares;
|
||||||
|
while (b2)
|
||||||
|
{
|
||||||
|
to = pop_1st_bit(&b2);
|
||||||
|
|
||||||
|
assert(pos.piece_on(to) == EMPTY);
|
||||||
|
assert(square_rank(to) == RANK_5);
|
||||||
|
|
||||||
|
mlist[n++].move = make_move(to - DELTA_S - DELTA_S, to);
|
||||||
|
}
|
||||||
}
|
}
|
||||||
else
|
|
||||||
mlist[n++].move = make_move(to - DELTA_N, to);
|
|
||||||
}
|
|
||||||
// Double pawn pushes.
|
|
||||||
b2 = (((b1 << 8) & pos.empty_squares() & Rank3BB) << 8) & blockSquares;
|
|
||||||
while(b2) {
|
|
||||||
to = pop_1st_bit(&b2);
|
|
||||||
assert(pos.piece_on(to) == EMPTY);
|
|
||||||
assert(square_rank(to) == RANK_4);
|
|
||||||
mlist[n++].move = make_move(to - DELTA_N - DELTA_N, to);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
else { // (us == BLACK)
|
|
||||||
// Find non-pinned pawns:
|
|
||||||
b1 = pos.pawns(BLACK) & ~pinned;
|
|
||||||
|
|
||||||
// Single pawn pushes. We don't have to AND with empty squares here,
|
// Knight moves
|
||||||
// because the blocking squares will always be empty.
|
b1 = pos.knights(us) & not_pinned;
|
||||||
b2 = (b1 >> 8) & blockSquares;
|
while (b1)
|
||||||
while(b2) {
|
{
|
||||||
to = pop_1st_bit(&b2);
|
from = pop_1st_bit(&b1);
|
||||||
assert(pos.piece_on(to) == EMPTY);
|
b2 = pos.knight_attacks(from) & blockSquares;
|
||||||
if(square_rank(to) == RANK_1) {
|
while (b2)
|
||||||
mlist[n++].move = make_promotion_move(to - DELTA_S, to, QUEEN);
|
{
|
||||||
mlist[n++].move = make_promotion_move(to - DELTA_S, to, ROOK);
|
to = pop_1st_bit(&b2);
|
||||||
mlist[n++].move = make_promotion_move(to - DELTA_S, to, BISHOP);
|
mlist[n++].move = make_move(from, to);
|
||||||
mlist[n++].move = make_promotion_move(to - DELTA_S, to, KNIGHT);
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// Bishop moves
|
||||||
|
b1 = pos.bishops(us) & not_pinned;
|
||||||
|
while (b1)
|
||||||
|
{
|
||||||
|
from = pop_1st_bit(&b1);
|
||||||
|
b2 = pos.bishop_attacks(from) & blockSquares;
|
||||||
|
while (b2)
|
||||||
|
{
|
||||||
|
to = pop_1st_bit(&b2);
|
||||||
|
mlist[n++].move = make_move(from, to);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// Rook moves
|
||||||
|
b1 = pos.rooks(us) & not_pinned;
|
||||||
|
while (b1)
|
||||||
|
{
|
||||||
|
from = pop_1st_bit(&b1);
|
||||||
|
b2 = pos.rook_attacks(from) & blockSquares;
|
||||||
|
while (b2)
|
||||||
|
{
|
||||||
|
to = pop_1st_bit(&b2);
|
||||||
|
mlist[n++].move = make_move(from, to);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// Queen moves
|
||||||
|
b1 = pos.queens(us) & not_pinned;
|
||||||
|
while (b1)
|
||||||
|
{
|
||||||
|
from = pop_1st_bit(&b1);
|
||||||
|
b2 = pos.queen_attacks(from) & blockSquares;
|
||||||
|
while (b2)
|
||||||
|
{
|
||||||
|
to = pop_1st_bit(&b2);
|
||||||
|
mlist[n++].move = make_move(from, to);
|
||||||
|
}
|
||||||
}
|
}
|
||||||
else
|
|
||||||
mlist[n++].move = make_move(to - DELTA_S, to);
|
|
||||||
}
|
|
||||||
// Double pawn pushes.
|
|
||||||
b2 = (((b1 >> 8) & pos.empty_squares() & Rank6BB) >> 8) & blockSquares;
|
|
||||||
while(b2) {
|
|
||||||
to = pop_1st_bit(&b2);
|
|
||||||
assert(pos.piece_on(to) == EMPTY);
|
|
||||||
assert(square_rank(to) == RANK_5);
|
|
||||||
mlist[n++].move = make_move(to - DELTA_S - DELTA_S, to);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// Knight moves
|
|
||||||
b1 = pos.knights(us) & ~pinned;
|
|
||||||
while(b1) {
|
|
||||||
from = pop_1st_bit(&b1);
|
|
||||||
b2 = pos.knight_attacks(from) & blockSquares;
|
|
||||||
while(b2) {
|
|
||||||
to = pop_1st_bit(&b2);
|
|
||||||
mlist[n++].move = make_move(from, to);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// Bishop moves
|
|
||||||
b1 = pos.bishops(us) & ~pinned;
|
|
||||||
while(b1) {
|
|
||||||
from = pop_1st_bit(&b1);
|
|
||||||
b2 = pos.bishop_attacks(from) & blockSquares;
|
|
||||||
while(b2) {
|
|
||||||
to = pop_1st_bit(&b2);
|
|
||||||
mlist[n++].move = make_move(from, to);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// Rook moves
|
|
||||||
b1 = pos.rooks(us) & ~pinned;
|
|
||||||
while(b1) {
|
|
||||||
from = pop_1st_bit(&b1);
|
|
||||||
b2 = pos.rook_attacks(from) & blockSquares;
|
|
||||||
while(b2) {
|
|
||||||
to = pop_1st_bit(&b2);
|
|
||||||
mlist[n++].move = make_move(from, to);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// Queen moves
|
|
||||||
b1 = pos.queens(us) & ~pinned;
|
|
||||||
while(b1) {
|
|
||||||
from = pop_1st_bit(&b1);
|
|
||||||
b2 = pos.queen_attacks(from) & blockSquares;
|
|
||||||
while(b2) {
|
|
||||||
to = pop_1st_bit(&b2);
|
|
||||||
mlist[n++].move = make_move(from, to);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
}
|
||||||
|
|
||||||
// Finally, the ugly special case of en passant captures. An en passant
|
// Finally, the ugly special case of en passant captures. An en passant
|
||||||
// capture can only be a check evasion if the check is not a discovered
|
// capture can only be a check evasion if the check is not a discovered
|
||||||
// check. If pos.ep_square() is set, the last move made must have been
|
// check. If pos.ep_square() is set, the last move made must have been
|
||||||
// a double pawn push. If, furthermore, the checking piece is a pawn,
|
// a double pawn push. If, furthermore, the checking piece is a pawn,
|
||||||
// an en passant check evasion may be possible.
|
// an en passant check evasion may be possible.
|
||||||
if(pos.ep_square() != SQ_NONE && (checkers & pos.pawns(them))) {
|
if (pos.ep_square() != SQ_NONE && (checkers & pos.pawns(them)))
|
||||||
to = pos.ep_square();
|
{
|
||||||
b1 = pos.pawn_attacks(them, to) & pos.pawns(us);
|
to = pos.ep_square();
|
||||||
assert(b1 != EmptyBoardBB);
|
b1 = pos.pawn_attacks(them, to) & pos.pawns(us);
|
||||||
b1 &= ~pinned;
|
|
||||||
while(b1) {
|
|
||||||
from = pop_1st_bit(&b1);
|
|
||||||
|
|
||||||
// Before generating the move, we have to make sure it is legal.
|
assert(b1 != EmptyBoardBB);
|
||||||
// This is somewhat tricky, because the two disappearing pawns may
|
|
||||||
// cause new "discovered checks". We test this by removing the
|
b1 &= not_pinned;
|
||||||
// two relevant bits from the occupied squares bitboard, and using
|
while (b1)
|
||||||
// the low-level bitboard functions for bishop and rook attacks.
|
{
|
||||||
b2 = pos.occupied_squares();
|
from = pop_1st_bit(&b1);
|
||||||
clear_bit(&b2, from);
|
|
||||||
clear_bit(&b2, checksq);
|
// Before generating the move, we have to make sure it is legal.
|
||||||
if(((bishop_attacks_bb(ksq, b2) & pos.bishops_and_queens(them))
|
// This is somewhat tricky, because the two disappearing pawns may
|
||||||
== EmptyBoardBB) &&
|
// cause new "discovered checks". We test this by removing the
|
||||||
((rook_attacks_bb(ksq, b2) & pos.rooks_and_queens(them))
|
// two relevant bits from the occupied squares bitboard, and using
|
||||||
== EmptyBoardBB))
|
// the low-level bitboard functions for bishop and rook attacks.
|
||||||
mlist[n++].move = make_ep_move(from, to);
|
b2 = pos.occupied_squares();
|
||||||
}
|
clear_bit(&b2, from);
|
||||||
|
clear_bit(&b2, checksq);
|
||||||
|
if (!( (bishop_attacks_bb(ksq, b2) & pos.bishops_and_queens(them))
|
||||||
|
||(rook_attacks_bb(ksq, b2) & pos.rooks_and_queens(them))))
|
||||||
|
|
||||||
|
mlist[n++].move = make_ep_move(from, to);
|
||||||
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
return n;
|
return n;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
Loading…
Add table
Reference in a new issue