kate/BadFish
1
0
Fork 0
mirror of https://github.com/sockspls/badfish synced 2025-07-11 19:49:14 +00:00
Code Issues Releases Wiki Activity

Space inflate generate_evasions()

Browse source 
Signed-off-by: Marco Costalba <mcostalba@gmail.com>
This commit is contained in:
Marco Costalba 2008-10-19 08:27:24 +01:00
parent 72289fcfab
commit 987ff3b4b6
1 changed files with 216 additions and 199 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

209
src/movegen.cpp
View file

@ -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);
} }
@ -187,194 +186,210 @@ 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); while (b1)
{
Square to = pop_1st_bit(&b1);
// Make sure to is not attacked by the other side. This is a bit ugly, // 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 // 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();
if (!(checkers & (checkers - 1))) // Only one bit set?
{
Square checksq = first_1(checkers); Square checksq = first_1(checkers);
assert(pos.color_of_piece_on(checksq) == them); assert(pos.color_of_piece_on(checksq) == them);
// Find pinned pieces: // Find pinned pieces
pinned = pos.pinned_pieces(us); Bitboard not_pinned = ~pos.pinned_pieces(us);
// Generate captures of the checking piece: // Generate captures of the checking piece
// Pawn captures: // Pawn captures
b1 = pos.pawn_attacks(them, checksq) & pos.pawns(us) & ~pinned; b1 = pos.pawn_attacks(them, checksq) & pos.pawns(us) & not_pinned;
while(b1) { while (b1)
{
from = pop_1st_bit(&b1); from = pop_1st_bit(&b1);
if(relative_rank(us, checksq) == RANK_8) { if (relative_rank(us, checksq) == RANK_8)
{
mlist[n++].move = make_promotion_move(from, checksq, QUEEN); 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, ROOK);
mlist[n++].move = make_promotion_move(from, checksq, BISHOP); mlist[n++].move = make_promotion_move(from, checksq, BISHOP);
mlist[n++].move = make_promotion_move(from, checksq, KNIGHT); mlist[n++].move = make_promotion_move(from, checksq, KNIGHT);
} } else
else
mlist[n++].move = make_move(from, checksq); 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;
while(b1) {
from = pop_1st_bit(&b1);
mlist[n++].move = make_move(from, checksq);
}
// Rook and queen captures:
b1 = pos.rook_attacks(checksq) & pos.rooks_and_queens(us)
& ~pinned;
while(b1) {
from = pop_1st_bit(&b1); from = pop_1st_bit(&b1);
mlist[n++].move = make_move(from, checksq); mlist[n++].move = make_move(from, checksq);
} }
// Blocking check evasions are possible only if the checking piece is // Blocking check evasions are possible only if the checking piece is
// a slider: // a slider
if(checkers & pos.sliders()) { if (checkers & pos.sliders())
{
Bitboard blockSquares = squares_between(checksq, ksq); Bitboard blockSquares = squares_between(checksq, ksq);
assert((pos.occupied_squares() & blockSquares) == EmptyBoardBB); 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); to = pop_1st_bit(&b2);
assert(pos.piece_on(to) == EMPTY); assert(pos.piece_on(to) == EMPTY);
if(square_rank(to) == RANK_8) {
if (square_rank(to) == RANK_8)
{
mlist[n++].move = make_promotion_move(to - DELTA_N, to, QUEEN); 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, ROOK);
mlist[n++].move = make_promotion_move(to - DELTA_N, to, BISHOP); mlist[n++].move = make_promotion_move(to - DELTA_N, to, BISHOP);
mlist[n++].move = make_promotion_move(to - DELTA_N, to, KNIGHT); mlist[n++].move = make_promotion_move(to - DELTA_N, to, KNIGHT);
} } else
else
mlist[n++].move = make_move(to - DELTA_N, to); mlist[n++].move = make_move(to - DELTA_N, to);
} }
// Double pawn pushes.
// Double pawn pushes
b2 = (((b1 << 8) & pos.empty_squares() & Rank3BB) << 8) & blockSquares; b2 = (((b1 << 8) & pos.empty_squares() & Rank3BB) << 8) & blockSquares;
while(b2) { while (b2)
{
to = pop_1st_bit(&b2); to = pop_1st_bit(&b2);
assert(pos.piece_on(to) == EMPTY); assert(pos.piece_on(to) == EMPTY);
assert(square_rank(to) == RANK_4); assert(square_rank(to) == RANK_4);
mlist[n++].move = make_move(to - DELTA_N - DELTA_N, to); mlist[n++].move = make_move(to - DELTA_N - DELTA_N, to);
} }
} } else { // (us == BLACK)
else { // (us == BLACK)
// Find non-pinned pawns: // Find non-pinned pawns
b1 = pos.pawns(BLACK) & ~pinned; b1 = pos.pawns(BLACK) & 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); to = pop_1st_bit(&b2);
assert(pos.piece_on(to) == EMPTY); assert(pos.piece_on(to) == EMPTY);
if(square_rank(to) == RANK_1) {
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, QUEEN);
mlist[n++].move = make_promotion_move(to - DELTA_S, to, ROOK); 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, BISHOP);
mlist[n++].move = make_promotion_move(to - DELTA_S, to, KNIGHT); mlist[n++].move = make_promotion_move(to - DELTA_S, to, KNIGHT);
} } else
else
mlist[n++].move = make_move(to - DELTA_S, to); mlist[n++].move = make_move(to - DELTA_S, to);
} }
// Double pawn pushes.
// Double pawn pushes
b2 = (((b1 >> 8) & pos.empty_squares() & Rank6BB) >> 8) & blockSquares; b2 = (((b1 >> 8) & pos.empty_squares() & Rank6BB) >> 8) & blockSquares;
while(b2) { while (b2)
{
to = pop_1st_bit(&b2); to = pop_1st_bit(&b2);
assert(pos.piece_on(to) == EMPTY); assert(pos.piece_on(to) == EMPTY);
assert(square_rank(to) == RANK_5); assert(square_rank(to) == RANK_5);
mlist[n++].move = make_move(to - DELTA_S - DELTA_S, to); mlist[n++].move = make_move(to - DELTA_S - DELTA_S, to);
} }
} }
// Knight moves // Knight moves
b1 = pos.knights(us) & ~pinned; b1 = pos.knights(us) & not_pinned;
while(b1) { while (b1)
{
from = pop_1st_bit(&b1); from = pop_1st_bit(&b1);
b2 = pos.knight_attacks(from) & blockSquares; b2 = pos.knight_attacks(from) & blockSquares;
while(b2) { while (b2)
{
to = pop_1st_bit(&b2); to = pop_1st_bit(&b2);
mlist[n++].move = make_move(from, to); mlist[n++].move = make_move(from, to);
} }
} }
// Bishop moves // Bishop moves
b1 = pos.bishops(us) & ~pinned; b1 = pos.bishops(us) & not_pinned;
while(b1) { while (b1)
{
from = pop_1st_bit(&b1); from = pop_1st_bit(&b1);
b2 = pos.bishop_attacks(from) & blockSquares; b2 = pos.bishop_attacks(from) & blockSquares;
while(b2) { while (b2)
{
to = pop_1st_bit(&b2); to = pop_1st_bit(&b2);
mlist[n++].move = make_move(from, to); mlist[n++].move = make_move(from, to);
} }
} }
// Rook moves // Rook moves
b1 = pos.rooks(us) & ~pinned; b1 = pos.rooks(us) & not_pinned;
while(b1) { while (b1)
{
from = pop_1st_bit(&b1); from = pop_1st_bit(&b1);
b2 = pos.rook_attacks(from) & blockSquares; b2 = pos.rook_attacks(from) & blockSquares;
while(b2) { while (b2)
{
to = pop_1st_bit(&b2); to = pop_1st_bit(&b2);
mlist[n++].move = make_move(from, to); mlist[n++].move = make_move(from, to);
} }
} }
// Queen moves // Queen moves
b1 = pos.queens(us) & ~pinned; b1 = pos.queens(us) & not_pinned;
while(b1) { while (b1)
{
from = pop_1st_bit(&b1); from = pop_1st_bit(&b1);
b2 = pos.queen_attacks(from) & blockSquares; b2 = pos.queen_attacks(from) & blockSquares;
while(b2) { while (b2)
{
to = pop_1st_bit(&b2); to = pop_1st_bit(&b2);
mlist[n++].move = make_move(from, to); mlist[n++].move = make_move(from, to);
} }
@ -386,12 +401,16 @@ int generate_evasions(const Position &pos, MoveStack *mlist) {
// 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(); to = pos.ep_square();
b1 = pos.pawn_attacks(them, to) & pos.pawns(us); b1 = pos.pawn_attacks(them, to) & pos.pawns(us);
assert(b1 != EmptyBoardBB); assert(b1 != EmptyBoardBB);
b1 &= ~pinned;
while(b1) { b1 &= not_pinned;
while (b1)
{
from = pop_1st_bit(&b1); from = pop_1st_bit(&b1);
// Before generating the move, we have to make sure it is legal. // Before generating the move, we have to make sure it is legal.
@ -402,15 +421,13 @@ int generate_evasions(const Position &pos, MoveStack *mlist) {
b2 = pos.occupied_squares(); b2 = pos.occupied_squares();
clear_bit(&b2, from); clear_bit(&b2, from);
clear_bit(&b2, checksq); clear_bit(&b2, checksq);
if(((bishop_attacks_bb(ksq, b2) & pos.bishops_and_queens(them)) if (!( (bishop_attacks_bb(ksq, b2) & pos.bishops_and_queens(them))
== EmptyBoardBB) && ||(rook_attacks_bb(ksq, b2) & pos.rooks_and_queens(them))))
((rook_attacks_bb(ksq, b2) & pos.rooks_and_queens(them))
== EmptyBoardBB))
mlist[n++].move = make_ep_move(from, to); mlist[n++].move = make_ep_move(from, to);
} }
} }
} }
return n; return n;
} }