2008-08-31 23:59:13 -06:00
|
|
|
/*
|
2008-10-19 10:56:28 -06:00
|
|
|
Stockfish, a UCI chess playing engine derived from Glaurung 2.1
|
2009-05-07 06:54:40 -06:00
|
|
|
Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
|
|
|
|
Copyright (C) 2008-2009 Marco Costalba
|
2008-08-31 23:59:13 -06:00
|
|
|
|
2008-10-19 10:56:28 -06:00
|
|
|
Stockfish is free software: you can redistribute it and/or modify
|
2008-08-31 23:59:13 -06:00
|
|
|
it under the terms of the GNU General Public License as published by
|
|
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
|
|
(at your option) any later version.
|
2008-10-20 13:57:13 -06:00
|
|
|
|
2008-10-19 10:56:28 -06:00
|
|
|
Stockfish is distributed in the hope that it will be useful,
|
2008-08-31 23:59:13 -06:00
|
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
GNU General Public License for more details.
|
2008-10-20 13:57:13 -06:00
|
|
|
|
2008-08-31 23:59:13 -06:00
|
|
|
You should have received a copy of the GNU General Public License
|
|
|
|
along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
|
|
////
|
|
|
|
//// Includes
|
|
|
|
////
|
|
|
|
|
|
|
|
#include <cassert>
|
|
|
|
|
2009-05-21 10:08:34 -06:00
|
|
|
#include "bitcount.h"
|
2008-08-31 23:59:13 -06:00
|
|
|
#include "movegen.h"
|
|
|
|
|
2008-10-23 02:42:14 -06:00
|
|
|
// Simple macro to wrap a very common while loop, no facny, no flexibility,
|
|
|
|
// hardcoded list name 'mlist' and from square 'from'.
|
|
|
|
#define SERIALIZE_MOVES(b) while (b) (*mlist++).move = make_move(from, pop_1st_bit(&b))
|
2008-08-31 23:59:13 -06:00
|
|
|
|
2009-07-14 02:07:30 -06:00
|
|
|
// Version used for pawns, where the 'from' square is given as a delta from the 'to' square
|
|
|
|
#define SERIALIZE_MOVES_D(b, d) while (b) { to = pop_1st_bit(&b); (*mlist++).move = make_move(to + (d), to); }
|
|
|
|
|
2008-08-31 23:59:13 -06:00
|
|
|
////
|
|
|
|
//// Local definitions
|
|
|
|
////
|
|
|
|
|
|
|
|
namespace {
|
2008-10-18 09:37:49 -06:00
|
|
|
|
2009-02-05 07:06:41 -07:00
|
|
|
enum CastlingSide {
|
2009-02-05 08:08:00 -07:00
|
|
|
KING_SIDE,
|
|
|
|
QUEEN_SIDE
|
2009-02-05 07:06:41 -07:00
|
|
|
};
|
|
|
|
|
2009-02-12 01:28:18 -07:00
|
|
|
enum MoveType {
|
|
|
|
CAPTURE,
|
2009-09-23 03:47:11 -06:00
|
|
|
NON_CAPTURE,
|
|
|
|
CHECK,
|
|
|
|
EVASION
|
2009-02-12 01:28:18 -07:00
|
|
|
};
|
2009-02-10 09:31:07 -07:00
|
|
|
|
2009-02-10 09:53:19 -07:00
|
|
|
// Functions
|
2009-02-05 08:08:00 -07:00
|
|
|
bool castling_is_check(const Position&, CastlingSide);
|
|
|
|
|
2009-02-10 09:44:55 -07:00
|
|
|
// Helper templates
|
2009-02-05 08:08:00 -07:00
|
|
|
template<CastlingSide Side>
|
2009-09-21 11:07:11 -06:00
|
|
|
MoveStack* generate_castle_moves(const Position&, MoveStack*);
|
2009-02-10 09:31:07 -07:00
|
|
|
|
2009-05-07 07:32:28 -06:00
|
|
|
template<Color Us, SquareDelta Diagonal>
|
2009-09-21 11:07:11 -06:00
|
|
|
MoveStack* generate_pawn_captures_diagonal(MoveStack*, Bitboard, Bitboard, bool);
|
2009-05-07 07:32:28 -06:00
|
|
|
|
2009-09-23 03:47:11 -06:00
|
|
|
template<Color Us, MoveType Type>
|
2009-09-23 04:18:04 -06:00
|
|
|
MoveStack* generate_pawn_moves(const Position&, MoveStack*, Bitboard = EmptyBoardBB,
|
|
|
|
Square = SQ_NONE, Bitboard = EmptyBoardBB);
|
2009-02-10 09:44:55 -07:00
|
|
|
|
2009-04-14 04:36:34 -06:00
|
|
|
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;
|
2009-04-19 13:09:53 -06:00
|
|
|
else
|
|
|
|
return p;
|
2009-04-14 04:36:34 -06:00
|
|
|
}
|
|
|
|
|
2009-02-10 09:44:55 -07:00
|
|
|
// Template generate_piece_checks() with specializations
|
|
|
|
template<PieceType>
|
|
|
|
MoveStack* generate_piece_checks(const Position&, MoveStack*, Color, Bitboard, Square);
|
2008-10-19 09:20:21 -06:00
|
|
|
|
2008-10-21 17:06:12 -06:00
|
|
|
template<>
|
2009-02-10 09:44:55 -07:00
|
|
|
inline MoveStack* generate_piece_checks<PAWN>(const Position& p, MoveStack* m, Color us, Bitboard dc, Square ksq) {
|
|
|
|
|
2009-09-23 04:18:04 -06:00
|
|
|
return (us == WHITE ? generate_pawn_moves<WHITE, CHECK>(p, m, dc, ksq)
|
|
|
|
: generate_pawn_moves<BLACK, CHECK>(p, m, dc, ksq));
|
2008-10-21 17:06:12 -06:00
|
|
|
}
|
2008-10-19 05:43:09 -06:00
|
|
|
|
2009-02-12 01:53:37 -07:00
|
|
|
// Template generate_piece_moves() with specializations and overloads
|
2008-10-19 05:43:09 -06:00
|
|
|
template<PieceType>
|
2009-09-21 11:07:11 -06:00
|
|
|
MoveStack* generate_piece_moves(const Position&, MoveStack*, Color, Bitboard);
|
2009-02-10 09:44:55 -07:00
|
|
|
|
2008-10-20 16:10:27 -06:00
|
|
|
template<>
|
2009-02-12 01:28:18 -07:00
|
|
|
MoveStack* generate_piece_moves<KING>(const Position&, MoveStack*, Color, Bitboard);
|
2008-10-19 05:43:09 -06:00
|
|
|
|
2009-02-12 01:28:18 -07:00
|
|
|
template<PieceType Piece, MoveType Type>
|
2009-02-10 09:31:07 -07:00
|
|
|
inline MoveStack* generate_piece_moves(const Position& p, MoveStack* m, Color us) {
|
|
|
|
|
2009-09-23 04:18:04 -06:00
|
|
|
assert(Piece == PAWN);
|
|
|
|
assert(Type == CAPTURE || Type == NON_CAPTURE);
|
2009-02-10 09:31:07 -07:00
|
|
|
|
2009-09-23 04:18:04 -06:00
|
|
|
return (us == WHITE ? generate_pawn_moves<WHITE, Type>(p, m)
|
|
|
|
: generate_pawn_moves<BLACK, Type>(p, m));
|
2009-02-10 09:31:07 -07:00
|
|
|
}
|
|
|
|
|
2008-10-19 05:43:09 -06:00
|
|
|
template<PieceType>
|
2009-09-21 11:07:11 -06:00
|
|
|
MoveStack* generate_piece_moves(const Position&, MoveStack*, Color, Bitboard, Bitboard);
|
2009-02-10 09:31:07 -07:00
|
|
|
|
2009-02-10 08:58:02 -07:00
|
|
|
template<>
|
2009-02-12 01:28:18 -07:00
|
|
|
inline MoveStack* generate_piece_moves<PAWN>(const Position& p, MoveStack* m,
|
|
|
|
Color us, Bitboard t, Bitboard pnd) {
|
2009-05-07 09:08:55 -06:00
|
|
|
|
2009-09-23 04:18:04 -06:00
|
|
|
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));
|
2009-02-10 09:44:55 -07:00
|
|
|
}
|
2008-08-31 23:59:13 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
////
|
|
|
|
//// Functions
|
|
|
|
////
|
|
|
|
|
|
|
|
|
2009-09-21 11:07:11 -06:00
|
|
|
/// generate_captures() generates all pseudo-legal captures and queen
|
2009-09-20 01:43:25 -06:00
|
|
|
/// promotions. Returns a pointer to the end of the move list.
|
2008-08-31 23:59:13 -06:00
|
|
|
|
2009-08-28 00:57:52 -06:00
|
|
|
MoveStack* generate_captures(const Position& pos, MoveStack* mlist) {
|
2008-08-31 23:59:13 -06:00
|
|
|
|
|
|
|
assert(pos.is_ok());
|
|
|
|
assert(!pos.is_check());
|
|
|
|
|
2008-10-17 07:11:19 -06:00
|
|
|
Color us = pos.side_to_move();
|
|
|
|
Bitboard target = pos.pieces_of_color(opposite_color(us));
|
|
|
|
|
2008-11-24 04:13:08 -07:00
|
|
|
mlist = generate_piece_moves<QUEEN>(pos, mlist, us, target);
|
|
|
|
mlist = generate_piece_moves<ROOK>(pos, mlist, us, target);
|
|
|
|
mlist = generate_piece_moves<BISHOP>(pos, mlist, us, target);
|
|
|
|
mlist = generate_piece_moves<KNIGHT>(pos, mlist, us, target);
|
2009-02-10 09:31:07 -07:00
|
|
|
mlist = generate_piece_moves<PAWN, CAPTURE>(pos, mlist, us);
|
2009-08-28 00:57:52 -06:00
|
|
|
return generate_piece_moves<KING>(pos, mlist, us, target);
|
2008-08-31 23:59:13 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2008-10-20 13:57:13 -06:00
|
|
|
/// generate_noncaptures() generates all pseudo-legal non-captures and
|
2009-09-20 01:43:25 -06:00
|
|
|
/// underpromotions. Returns a pointer to the end of the move list.
|
2008-08-31 23:59:13 -06:00
|
|
|
|
2009-08-28 00:57:52 -06:00
|
|
|
MoveStack* generate_noncaptures(const Position& pos, MoveStack* mlist) {
|
2008-08-31 23:59:13 -06:00
|
|
|
|
|
|
|
assert(pos.is_ok());
|
|
|
|
assert(!pos.is_check());
|
|
|
|
|
2008-10-17 07:11:19 -06:00
|
|
|
Color us = pos.side_to_move();
|
|
|
|
Bitboard target = pos.empty_squares();
|
|
|
|
|
2009-02-10 09:31:07 -07:00
|
|
|
mlist = generate_piece_moves<PAWN, NON_CAPTURE>(pos, mlist, us);
|
2008-10-22 16:18:11 -06:00
|
|
|
mlist = generate_piece_moves<KNIGHT>(pos, mlist, us, target);
|
|
|
|
mlist = generate_piece_moves<BISHOP>(pos, mlist, us, target);
|
|
|
|
mlist = generate_piece_moves<ROOK>(pos, mlist, us, target);
|
|
|
|
mlist = generate_piece_moves<QUEEN>(pos, mlist, us, target);
|
|
|
|
mlist = generate_piece_moves<KING>(pos, mlist, us, target);
|
2009-02-05 08:08:00 -07:00
|
|
|
mlist = generate_castle_moves<KING_SIDE>(pos, mlist);
|
2009-08-28 00:57:52 -06:00
|
|
|
return generate_castle_moves<QUEEN_SIDE>(pos, mlist);
|
2008-08-31 23:59:13 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2009-09-21 11:07:11 -06:00
|
|
|
/// generate_non_capture_checks() generates all pseudo-legal non-captures and
|
|
|
|
/// underpromotions that give check. Returns a pointer to the end of the move list.
|
2008-08-31 23:59:13 -06:00
|
|
|
|
2009-08-28 00:57:52 -06:00
|
|
|
MoveStack* generate_non_capture_checks(const Position& pos, MoveStack* mlist, Bitboard dc) {
|
2008-10-17 07:11:19 -06:00
|
|
|
|
|
|
|
assert(pos.is_ok());
|
|
|
|
assert(!pos.is_check());
|
|
|
|
|
2008-10-18 07:36:58 -06:00
|
|
|
Color us = pos.side_to_move();
|
|
|
|
Square ksq = pos.king_square(opposite_color(us));
|
2008-08-31 23:59:13 -06:00
|
|
|
|
2009-02-17 09:26:15 -07:00
|
|
|
assert(pos.piece_on(ksq) == piece_of_color_and_type(opposite_color(us), KING));
|
2008-08-31 23:59:13 -06:00
|
|
|
|
2008-10-18 07:36:58 -06:00
|
|
|
// Pieces moves
|
2009-02-10 09:44:55 -07:00
|
|
|
mlist = generate_piece_checks<PAWN>(pos, mlist, us, dc, ksq);
|
2009-02-10 08:02:48 -07:00
|
|
|
mlist = generate_piece_checks<KNIGHT>(pos, mlist, us, dc, ksq);
|
|
|
|
mlist = generate_piece_checks<BISHOP>(pos, mlist, us, dc, ksq);
|
|
|
|
mlist = generate_piece_checks<ROOK>(pos, mlist, us, dc, ksq);
|
|
|
|
mlist = generate_piece_checks<QUEEN>(pos, mlist, us, dc, ksq);
|
|
|
|
mlist = generate_piece_checks<KING>(pos, mlist, us, dc, ksq);
|
2008-08-31 23:59:13 -06:00
|
|
|
|
2009-02-05 07:06:41 -07:00
|
|
|
// Castling moves that give check. Very rare but nice to have!
|
|
|
|
if ( pos.can_castle_queenside(us)
|
|
|
|
&& (square_rank(ksq) == square_rank(pos.king_square(us)) || square_file(ksq) == FILE_D)
|
|
|
|
&& castling_is_check(pos, QUEEN_SIDE))
|
2009-02-05 08:08:00 -07:00
|
|
|
mlist = generate_castle_moves<QUEEN_SIDE>(pos, mlist);
|
2009-02-05 07:06:41 -07:00
|
|
|
|
|
|
|
if ( pos.can_castle_kingside(us)
|
|
|
|
&& (square_rank(ksq) == square_rank(pos.king_square(us)) || square_file(ksq) == FILE_F)
|
|
|
|
&& castling_is_check(pos, KING_SIDE))
|
2009-02-05 08:08:00 -07:00
|
|
|
mlist = generate_castle_moves<KING_SIDE>(pos, mlist);
|
2008-10-20 13:57:13 -06:00
|
|
|
|
2009-08-28 00:57:52 -06:00
|
|
|
return mlist;
|
2008-08-31 23:59:13 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/// generate_evasions() generates all check evasions when the side to move is
|
2009-02-11 09:21:03 -07:00
|
|
|
/// in check. Unlike the other move generation functions, this one generates
|
2009-09-20 01:43:25 -06:00
|
|
|
/// only legal moves. Returns a pointer to the end of the move list.
|
2008-08-31 23:59:13 -06:00
|
|
|
|
2009-08-28 00:57:52 -06:00
|
|
|
MoveStack* generate_evasions(const Position& pos, MoveStack* mlist, Bitboard pinned) {
|
2008-10-17 07:11:19 -06:00
|
|
|
|
|
|
|
assert(pos.is_ok());
|
|
|
|
assert(pos.is_check());
|
|
|
|
|
2008-10-22 16:18:11 -06:00
|
|
|
Square from, to;
|
2008-10-19 01:27:24 -06:00
|
|
|
Color us = pos.side_to_move();
|
|
|
|
Color them = opposite_color(us);
|
|
|
|
Square ksq = pos.king_square(us);
|
2009-09-21 00:55:26 -06:00
|
|
|
Bitboard sliderAttacks = EmptyBoardBB;
|
|
|
|
Bitboard checkers = pos.checkers();
|
2008-08-31 23:59:13 -06:00
|
|
|
|
2009-02-17 09:26:15 -07:00
|
|
|
assert(pos.piece_on(ksq) == piece_of_color_and_type(us, KING));
|
2008-10-20 13:57:13 -06:00
|
|
|
|
2009-02-07 05:11:52 -07:00
|
|
|
// The bitboard of occupied pieces without our king
|
2009-02-11 09:21:03 -07:00
|
|
|
Bitboard b_noKing = pos.occupied_squares();
|
|
|
|
clear_bit(&b_noKing, ksq);
|
2008-08-31 23:59:13 -06:00
|
|
|
|
2009-09-21 11:07:11 -06:00
|
|
|
// Find squares attacked by slider checkers, we will remove
|
|
|
|
// them from the king evasions set so to avoid a couple
|
2009-02-11 03:59:27 -07:00
|
|
|
// of cycles in the slow king evasions legality check loop
|
2009-09-20 02:31:48 -06:00
|
|
|
// and to be able to use attackers_to().
|
2009-09-02 03:57:38 -06:00
|
|
|
Bitboard b = checkers & pos.pieces(BISHOP, QUEEN);
|
2009-02-07 05:11:52 -07:00
|
|
|
while (b)
|
|
|
|
{
|
|
|
|
from = pop_1st_bit(&b);
|
2009-09-21 00:55:26 -06:00
|
|
|
sliderAttacks |= bishop_attacks_bb(from, b_noKing);
|
2009-02-07 05:11:52 -07:00
|
|
|
}
|
|
|
|
|
2009-09-02 03:57:38 -06:00
|
|
|
b = checkers & pos.pieces(ROOK, QUEEN);
|
2009-02-07 05:11:52 -07:00
|
|
|
while (b)
|
|
|
|
{
|
|
|
|
from = pop_1st_bit(&b);
|
2009-09-21 00:55:26 -06:00
|
|
|
sliderAttacks |= rook_attacks_bb(from, b_noKing);
|
2009-02-07 05:11:52 -07:00
|
|
|
}
|
|
|
|
|
2009-09-21 11:07:11 -06:00
|
|
|
// Generate evasions for king, capture and non capture moves
|
2009-09-20 03:47:59 -06:00
|
|
|
Bitboard enemy = pos.pieces_of_color(them);
|
2009-09-21 11:07:11 -06:00
|
|
|
Bitboard b1 = pos.attacks_from<KING>(ksq) & ~pos.pieces_of_color(us) & ~sliderAttacks;
|
2008-10-19 01:27:24 -06:00
|
|
|
while (b1)
|
|
|
|
{
|
2009-09-21 11:07:11 -06:00
|
|
|
// Note that we can use attackers_to() only because we have already
|
|
|
|
// removed from b1 the squares attacked by slider checkers.
|
2009-02-07 05:11:52 -07:00
|
|
|
to = pop_1st_bit(&b1);
|
2009-09-20 03:47:59 -06:00
|
|
|
if (!(pos.attackers_to(to) & enemy))
|
2009-02-07 05:11:52 -07:00
|
|
|
(*mlist++).move = make_move(ksq, to);
|
2008-10-19 01:27:24 -06:00
|
|
|
}
|
2008-08-31 23:59:13 -06:00
|
|
|
|
2008-10-19 01:27:24 -06:00
|
|
|
// Generate evasions for other pieces only if not double check. We use a
|
2008-08-31 23:59:13 -06:00
|
|
|
// 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).
|
2008-10-19 01:27:24 -06:00
|
|
|
if (!(checkers & (checkers - 1))) // Only one bit set?
|
|
|
|
{
|
|
|
|
Square checksq = first_1(checkers);
|
2008-08-31 23:59:13 -06:00
|
|
|
|
2008-10-19 01:27:24 -06:00
|
|
|
assert(pos.color_of_piece_on(checksq) == them);
|
2008-08-31 23:59:13 -06:00
|
|
|
|
2008-10-19 01:27:24 -06:00
|
|
|
// Generate captures of the checking piece
|
2008-08-31 23:59:13 -06:00
|
|
|
|
2008-10-19 01:27:24 -06:00
|
|
|
// Pawn captures
|
2009-09-20 07:23:46 -06:00
|
|
|
b1 = pos.attacks_from<PAWN>(checksq, them) & pos.pieces(PAWN, us) & ~pinned;
|
2008-10-19 01:27:24 -06:00
|
|
|
while (b1)
|
|
|
|
{
|
|
|
|
from = pop_1st_bit(&b1);
|
|
|
|
if (relative_rank(us, checksq) == RANK_8)
|
|
|
|
{
|
2008-10-22 16:18:11 -06:00
|
|
|
(*mlist++).move = make_promotion_move(from, checksq, QUEEN);
|
|
|
|
(*mlist++).move = make_promotion_move(from, checksq, ROOK);
|
|
|
|
(*mlist++).move = make_promotion_move(from, checksq, BISHOP);
|
|
|
|
(*mlist++).move = make_promotion_move(from, checksq, KNIGHT);
|
2008-10-19 01:27:24 -06:00
|
|
|
} else
|
2008-10-22 16:18:11 -06:00
|
|
|
(*mlist++).move = make_move(from, checksq);
|
2008-08-31 23:59:13 -06:00
|
|
|
}
|
2008-10-19 01:27:24 -06:00
|
|
|
|
|
|
|
// Pieces captures
|
2009-09-20 07:23:46 -06:00
|
|
|
b1 = ( (pos.attacks_from<KNIGHT>(checksq) & pos.pieces(KNIGHT, us))
|
|
|
|
| (pos.attacks_from<BISHOP>(checksq) & pos.pieces(BISHOP, QUEEN, us))
|
|
|
|
| (pos.attacks_from<ROOK>(checksq) & pos.pieces(ROOK, QUEEN, us)) ) & ~pinned;
|
2008-10-19 01:27:24 -06:00
|
|
|
|
|
|
|
while (b1)
|
|
|
|
{
|
|
|
|
from = pop_1st_bit(&b1);
|
2008-10-22 16:18:11 -06:00
|
|
|
(*mlist++).move = make_move(from, checksq);
|
2008-08-31 23:59:13 -06:00
|
|
|
}
|
2008-10-19 01:27:24 -06:00
|
|
|
|
2009-09-21 00:55:26 -06:00
|
|
|
// Blocking check evasions are possible only if the checking piece is a slider
|
|
|
|
if (sliderAttacks)
|
2008-10-19 01:27:24 -06:00
|
|
|
{
|
|
|
|
Bitboard blockSquares = squares_between(checksq, ksq);
|
|
|
|
|
|
|
|
assert((pos.occupied_squares() & blockSquares) == EmptyBoardBB);
|
|
|
|
|
2009-09-21 00:55:26 -06:00
|
|
|
if (blockSquares)
|
2009-02-11 09:21:03 -07:00
|
|
|
{
|
2009-02-12 01:28:18 -07:00
|
|
|
mlist = generate_piece_moves<PAWN>(pos, mlist, us, blockSquares, pinned);
|
|
|
|
mlist = generate_piece_moves<KNIGHT>(pos, mlist, us, blockSquares, pinned);
|
|
|
|
mlist = generate_piece_moves<BISHOP>(pos, mlist, us, blockSquares, pinned);
|
|
|
|
mlist = generate_piece_moves<ROOK>(pos, mlist, us, blockSquares, pinned);
|
|
|
|
mlist = generate_piece_moves<QUEEN>(pos, mlist, us, blockSquares, pinned);
|
2009-02-11 09:21:03 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Finally, the special case of en passant captures. An en passant
|
|
|
|
// 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
|
|
|
|
// a double pawn push. If, furthermore, the checking piece is a pawn,
|
|
|
|
// an en passant check evasion may be possible.
|
2009-09-02 03:57:38 -06:00
|
|
|
if (pos.ep_square() != SQ_NONE && (checkers & pos.pieces(PAWN, them)))
|
2009-02-11 09:21:03 -07:00
|
|
|
{
|
|
|
|
to = pos.ep_square();
|
2009-09-20 07:23:46 -06:00
|
|
|
b1 = pos.attacks_from<PAWN>(to, them) & pos.pieces(PAWN, us);
|
2009-02-11 09:21:03 -07:00
|
|
|
|
|
|
|
// The checking pawn cannot be a discovered (bishop) check candidate
|
|
|
|
// otherwise we were in check also before last double push move.
|
|
|
|
assert(!bit_is_set(pos.discovered_check_candidates(them), checksq));
|
|
|
|
assert(count_1s(b1) == 1 || count_1s(b1) == 2);
|
|
|
|
|
|
|
|
b1 &= ~pinned;
|
|
|
|
while (b1)
|
|
|
|
{
|
|
|
|
from = pop_1st_bit(&b1);
|
|
|
|
// Move is always legal because checking pawn is not a discovered
|
|
|
|
// check candidate and our capturing pawn has been already tested
|
|
|
|
// against pinned pieces.
|
|
|
|
(*mlist++).move = make_ep_move(from, to);
|
|
|
|
}
|
|
|
|
}
|
2008-08-31 23:59:13 -06:00
|
|
|
}
|
2009-08-28 00:57:52 -06:00
|
|
|
return mlist;
|
2008-08-31 23:59:13 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2009-09-21 11:07:11 -06:00
|
|
|
/// generate_moves() computes a complete list of legal or pseudo-legal moves in
|
2009-09-21 04:54:25 -06:00
|
|
|
/// the current position. This function is not very fast, and should be used
|
2009-09-21 11:07:11 -06:00
|
|
|
/// only in non time-critical paths.
|
2008-08-31 23:59:13 -06:00
|
|
|
|
2009-09-21 04:54:25 -06:00
|
|
|
MoveStack* generate_moves(const Position& pos, MoveStack* mlist, bool pseudoLegal) {
|
2008-10-17 07:11:19 -06:00
|
|
|
|
2008-08-31 23:59:13 -06:00
|
|
|
assert(pos.is_ok());
|
|
|
|
|
2009-03-02 08:20:00 -07:00
|
|
|
Bitboard pinned = pos.pinned_pieces(pos.side_to_move());
|
|
|
|
|
2008-10-17 07:11:19 -06:00
|
|
|
if (pos.is_check())
|
2009-03-02 08:20:00 -07:00
|
|
|
return generate_evasions(pos, mlist, pinned);
|
2008-08-31 23:59:13 -06:00
|
|
|
|
2008-10-22 16:18:11 -06:00
|
|
|
// Generate pseudo-legal moves
|
2009-08-28 00:57:52 -06:00
|
|
|
MoveStack* last = generate_captures(pos, mlist);
|
|
|
|
last = generate_noncaptures(pos, last);
|
2009-09-21 04:54:25 -06:00
|
|
|
if (pseudoLegal)
|
|
|
|
return last;
|
2008-08-31 23:59:13 -06:00
|
|
|
|
2008-10-22 16:18:11 -06:00
|
|
|
// Remove illegal moves from the list
|
2009-08-28 00:57:52 -06:00
|
|
|
for (MoveStack* cur = mlist; cur != last; cur++)
|
|
|
|
if (!pos.pl_move_is_legal(cur->move, pinned))
|
|
|
|
{
|
|
|
|
cur->move = (--last)->move;
|
|
|
|
cur--;
|
|
|
|
}
|
|
|
|
return last;
|
2008-08-31 23:59:13 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2008-10-25 09:39:24 -06:00
|
|
|
/// move_is_legal() takes a position and a (not necessarily pseudo-legal)
|
2009-09-21 04:54:25 -06:00
|
|
|
/// move and tests whether the move is legal. This version is not very fast
|
2009-09-21 11:07:11 -06:00
|
|
|
/// and should be used only in non time-critical paths.
|
2009-09-21 04:54:25 -06:00
|
|
|
|
|
|
|
bool move_is_legal(const Position& pos, const Move m) {
|
|
|
|
|
|
|
|
MoveStack mlist[256];
|
|
|
|
MoveStack* last = generate_moves(pos, mlist, true);
|
|
|
|
for (MoveStack* cur = mlist; cur != last; cur++)
|
|
|
|
if (cur->move == m)
|
|
|
|
return pos.pl_move_is_legal(m);
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2009-09-21 11:07:11 -06:00
|
|
|
/// Fast version of move_is_legal() that takes a position a move and a
|
|
|
|
/// bitboard of pinned pieces as input, and tests whether the move is legal.
|
2009-09-21 04:54:25 -06:00
|
|
|
/// This version must only be used when the side to move is not in check.
|
2008-08-31 23:59:13 -06:00
|
|
|
|
2009-03-02 08:20:00 -07:00
|
|
|
bool move_is_legal(const Position& pos, const Move m, Bitboard pinned) {
|
2008-08-31 23:59:13 -06:00
|
|
|
|
|
|
|
assert(pos.is_ok());
|
|
|
|
assert(!pos.is_check());
|
|
|
|
assert(move_is_ok(m));
|
2009-03-02 08:20:00 -07:00
|
|
|
assert(pinned == pos.pinned_pieces(pos.side_to_move()));
|
2008-08-31 23:59:13 -06:00
|
|
|
|
2009-09-21 04:54:25 -06:00
|
|
|
// Use a slower but simpler function for uncommon cases
|
|
|
|
if (move_is_ep(m) || move_is_castle(m))
|
|
|
|
return move_is_legal(pos, m);
|
|
|
|
|
2008-10-17 07:11:19 -06:00
|
|
|
Color us = pos.side_to_move();
|
2009-09-21 11:07:11 -06:00
|
|
|
Color them = opposite_color(us);
|
2008-10-17 07:11:19 -06:00
|
|
|
Square from = move_from(m);
|
2009-09-21 11:07:11 -06:00
|
|
|
Square to = move_to(m);
|
2008-10-17 07:11:19 -06:00
|
|
|
Piece pc = pos.piece_on(from);
|
2008-08-31 23:59:13 -06:00
|
|
|
|
|
|
|
// If the from square is not occupied by a piece belonging to the side to
|
|
|
|
// move, the move is obviously not legal.
|
2008-10-17 07:11:19 -06:00
|
|
|
if (color_of_piece(pc) != us)
|
2008-10-25 09:39:24 -06:00
|
|
|
return false;
|
2008-08-31 23:59:13 -06:00
|
|
|
|
2008-10-17 07:11:19 -06:00
|
|
|
// The destination square cannot be occupied by a friendly piece
|
|
|
|
if (pos.color_of_piece_on(to) == us)
|
2008-10-25 09:39:24 -06:00
|
|
|
return false;
|
2008-08-31 23:59:13 -06:00
|
|
|
|
2009-09-21 11:07:11 -06:00
|
|
|
// Handle the special case of a pawn move
|
2008-10-17 14:52:36 -06:00
|
|
|
if (type_of_piece(pc) == PAWN)
|
2008-10-20 13:57:13 -06:00
|
|
|
{
|
2009-05-05 05:10:29 -06:00
|
|
|
// Move direction must be compatible with pawn color
|
|
|
|
int direction = to - from;
|
|
|
|
if ((us == WHITE) != (direction > 0))
|
|
|
|
return false;
|
|
|
|
|
2009-09-21 11:07:11 -06:00
|
|
|
// A pawn move is a promotion iff the destination square is
|
|
|
|
// on the 8/1th rank.
|
|
|
|
if (( (square_rank(to) == RANK_8 && us == WHITE)
|
|
|
|
||(square_rank(to) == RANK_1 && us != WHITE)) != bool(move_is_promotion(m)))
|
2008-10-25 09:39:24 -06:00
|
|
|
return false;
|
2008-10-17 07:38:00 -06:00
|
|
|
|
2009-09-21 11:07:11 -06:00
|
|
|
// Proceed according to the square delta between the origin and
|
2009-09-23 02:40:33 -06:00
|
|
|
// destination squares.
|
2009-05-05 05:10:29 -06:00
|
|
|
switch (direction)
|
2008-10-17 07:11:19 -06:00
|
|
|
{
|
2008-10-17 07:38:00 -06:00
|
|
|
case DELTA_NW:
|
|
|
|
case DELTA_NE:
|
|
|
|
case DELTA_SW:
|
|
|
|
case DELTA_SE:
|
|
|
|
// Capture. The destination square must be occupied by an enemy
|
|
|
|
// piece (en passant captures was handled earlier).
|
|
|
|
if (pos.color_of_piece_on(to) != them)
|
2008-10-25 09:39:24 -06:00
|
|
|
return false;
|
2008-10-17 07:38:00 -06:00
|
|
|
break;
|
|
|
|
|
|
|
|
case DELTA_N:
|
|
|
|
case DELTA_S:
|
|
|
|
// Pawn push. The destination square must be empty.
|
|
|
|
if (!pos.square_is_empty(to))
|
2008-10-25 09:39:24 -06:00
|
|
|
return false;
|
2008-10-17 07:38:00 -06:00
|
|
|
break;
|
|
|
|
|
|
|
|
case DELTA_NN:
|
|
|
|
// Double white pawn push. The destination square must be on the fourth
|
|
|
|
// rank, and both the destination square and the square between the
|
|
|
|
// source and destination squares must be empty.
|
|
|
|
if ( square_rank(to) != RANK_4
|
|
|
|
|| !pos.square_is_empty(to)
|
|
|
|
|| !pos.square_is_empty(from + DELTA_N))
|
2008-10-25 09:39:24 -06:00
|
|
|
return false;
|
2008-10-17 07:38:00 -06:00
|
|
|
break;
|
|
|
|
|
|
|
|
case DELTA_SS:
|
|
|
|
// Double black pawn push. The destination square must be on the fifth
|
|
|
|
// rank, and both the destination square and the square between the
|
|
|
|
// source and destination squares must be empty.
|
|
|
|
if ( square_rank(to) != RANK_5
|
|
|
|
|| !pos.square_is_empty(to)
|
|
|
|
|| !pos.square_is_empty(from + DELTA_S))
|
2008-10-25 09:39:24 -06:00
|
|
|
return false;
|
2008-10-17 07:38:00 -06:00
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
2008-10-25 09:39:24 -06:00
|
|
|
return false;
|
2008-08-31 23:59:13 -06:00
|
|
|
}
|
2008-10-25 09:39:24 -06:00
|
|
|
// The move is pseudo-legal, check if it is also legal
|
2009-03-02 08:20:00 -07:00
|
|
|
return pos.pl_move_is_legal(m, pinned);
|
2008-10-17 14:52:36 -06:00
|
|
|
}
|
2008-08-31 23:59:13 -06:00
|
|
|
|
2008-10-17 14:52:36 -06:00
|
|
|
// Luckly we can handle all the other pieces in one go
|
2009-09-20 07:23:46 -06:00
|
|
|
return ( bit_is_set(pos.attacks_from(pc, from), to)
|
2009-03-02 08:20:00 -07:00
|
|
|
&& pos.pl_move_is_legal(m, pinned)
|
2009-06-20 01:31:39 -06:00
|
|
|
&& !move_is_promotion(m));
|
2008-08-31 23:59:13 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
namespace {
|
|
|
|
|
2008-10-19 10:19:16 -06:00
|
|
|
template<PieceType Piece>
|
2008-10-22 16:18:11 -06:00
|
|
|
MoveStack* generate_piece_moves(const Position& pos, MoveStack* mlist, Color us, Bitboard target) {
|
2008-10-20 02:46:31 -06:00
|
|
|
|
2008-10-23 02:42:14 -06:00
|
|
|
Square from;
|
2008-10-20 16:10:27 -06:00
|
|
|
Bitboard b;
|
2008-10-20 02:46:31 -06:00
|
|
|
|
2008-10-23 01:47:00 -06:00
|
|
|
for (int i = 0, e = pos.piece_count(us, Piece); i < e; i++)
|
2008-10-19 10:19:16 -06:00
|
|
|
{
|
2008-10-20 16:10:27 -06:00
|
|
|
from = pos.piece_list(us, Piece, i);
|
2009-09-20 07:23:46 -06:00
|
|
|
b = pos.attacks_from<Piece>(from) & target;
|
2008-10-23 02:42:14 -06:00
|
|
|
SERIALIZE_MOVES(b);
|
2008-10-19 10:19:16 -06:00
|
|
|
}
|
2008-10-22 16:18:11 -06:00
|
|
|
return mlist;
|
2008-10-19 10:19:16 -06:00
|
|
|
}
|
|
|
|
|
2009-09-23 02:40:33 -06:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2008-10-19 10:19:16 -06:00
|
|
|
template<PieceType Piece>
|
2009-02-12 01:28:18 -07:00
|
|
|
MoveStack* generate_piece_moves(const Position& pos, MoveStack* mlist,
|
|
|
|
Color us, Bitboard target, Bitboard pinned) {
|
2009-02-11 04:58:45 -07:00
|
|
|
Square from;
|
|
|
|
Bitboard b;
|
2009-02-10 08:58:02 -07:00
|
|
|
|
2009-02-11 04:58:45 -07:00
|
|
|
for (int i = 0, e = pos.piece_count(us, Piece); i < e; i++)
|
2008-10-19 10:19:16 -06:00
|
|
|
{
|
2009-02-11 04:58:45 -07:00
|
|
|
from = pos.piece_list(us, Piece, i);
|
|
|
|
if (pinned && bit_is_set(pinned, from))
|
|
|
|
continue;
|
|
|
|
|
2009-09-20 07:23:46 -06:00
|
|
|
b = pos.attacks_from<Piece>(from) & target;
|
2009-02-11 04:58:45 -07:00
|
|
|
SERIALIZE_MOVES(b);
|
2008-10-19 10:19:16 -06:00
|
|
|
}
|
2008-10-22 16:18:11 -06:00
|
|
|
return mlist;
|
2008-10-19 10:19:16 -06:00
|
|
|
}
|
|
|
|
|
2009-05-07 07:32:28 -06:00
|
|
|
template<Color Us, SquareDelta Diagonal>
|
2009-07-14 00:53:22 -06:00
|
|
|
MoveStack* generate_pawn_captures_diagonal(MoveStack* mlist, Bitboard pawns, Bitboard enemyPieces, bool promotion) {
|
2009-05-07 07:32:28 -06:00
|
|
|
|
|
|
|
// Calculate our parametrized parameters at compile time
|
|
|
|
const Bitboard TRank8BB = (Us == WHITE ? Rank8BB : Rank1BB);
|
|
|
|
const Bitboard TFileABB = (Diagonal == DELTA_NE ? FileABB : FileHBB);
|
|
|
|
const SquareDelta TDELTA_NE = (Us == WHITE ? DELTA_NE : DELTA_SE);
|
|
|
|
const SquareDelta TDELTA_NW = (Us == WHITE ? DELTA_NW : DELTA_SW);
|
|
|
|
const SquareDelta TTDELTA_NE = (Diagonal == DELTA_NE ? TDELTA_NE : TDELTA_NW);
|
2008-10-18 02:57:27 -06:00
|
|
|
|
2008-10-23 02:42:14 -06:00
|
|
|
Square to;
|
2008-08-31 23:59:13 -06:00
|
|
|
|
2009-05-07 07:32:28 -06:00
|
|
|
// Captures in the a1-h8 (a8-h1 for black) diagonal or in the h1-a8 (h8-a1 for black)
|
|
|
|
Bitboard b1 = move_pawns<Us, Diagonal>(pawns) & ~TFileABB & enemyPieces;
|
2008-08-31 23:59:13 -06:00
|
|
|
|
2008-10-18 02:57:27 -06:00
|
|
|
// Capturing promotions
|
2009-07-14 00:53:22 -06:00
|
|
|
if (promotion)
|
2008-10-18 02:57:27 -06:00
|
|
|
{
|
2009-07-14 00:53:22 -06:00
|
|
|
Bitboard b2 = b1 & TRank8BB;
|
|
|
|
b1 &= ~TRank8BB;
|
|
|
|
while (b2)
|
|
|
|
{
|
|
|
|
to = pop_1st_bit(&b2);
|
|
|
|
(*mlist++).move = make_promotion_move(to - TTDELTA_NE, to, QUEEN);
|
|
|
|
}
|
2008-08-31 23:59:13 -06:00
|
|
|
}
|
|
|
|
|
2008-10-18 02:57:27 -06:00
|
|
|
// Capturing non-promotions
|
2009-07-14 02:07:30 -06:00
|
|
|
SERIALIZE_MOVES_D(b1, -TTDELTA_NE);
|
2009-05-07 07:32:28 -06:00
|
|
|
return mlist;
|
|
|
|
}
|
2008-08-31 23:59:13 -06:00
|
|
|
|
2009-09-23 03:47:11 -06:00
|
|
|
template<Color Us, MoveType Type>
|
2009-09-23 04:18:04 -06:00
|
|
|
MoveStack* generate_pawn_moves(const Position& pos, MoveStack* mlist, Bitboard dcp,
|
|
|
|
Square ksq, Bitboard blockSquares) {
|
2008-08-31 23:59:13 -06:00
|
|
|
|
2009-05-07 07:32:28 -06:00
|
|
|
// Calculate our parametrized parameters at compile time
|
2009-09-21 03:00:33 -06:00
|
|
|
const Color Them = (Us == WHITE ? BLACK : WHITE);
|
2009-05-07 07:32:28 -06:00
|
|
|
const Bitboard TRank8BB = (Us == WHITE ? Rank8BB : Rank1BB);
|
2009-07-14 00:53:22 -06:00
|
|
|
const Bitboard TRank7BB = (Us == WHITE ? Rank7BB : Rank2BB);
|
2009-05-07 07:32:28 -06:00
|
|
|
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);
|
|
|
|
|
2009-09-21 03:00:33 -06:00
|
|
|
Bitboard b1, b2, dcPawns1, dcPawns2;
|
2008-10-23 02:42:14 -06:00
|
|
|
Square to;
|
2009-09-23 03:47:11 -06:00
|
|
|
Bitboard pawns = (Type != EVASION ? pos.pieces(PAWN, Us) : pos.pieces(PAWN, Us) & ~dcp);
|
2009-05-07 07:32:28 -06:00
|
|
|
Bitboard emptySquares = pos.empty_squares();
|
2009-09-23 04:18:04 -06:00
|
|
|
bool possiblePromotion = (pawns & TRank7BB);
|
|
|
|
|
|
|
|
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);
|
|
|
|
}
|
2008-08-31 23:59:13 -06:00
|
|
|
|
2009-09-23 04:18:04 -06:00
|
|
|
if (possiblePromotion)
|
2008-10-18 10:39:13 -06:00
|
|
|
{
|
2009-09-21 03:00:33 -06:00
|
|
|
// When generating checks consider under-promotion moves (both captures
|
2009-09-23 03:47:11 -06:00
|
|
|
// 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);
|
2008-08-31 23:59:13 -06:00
|
|
|
|
2009-09-23 04:18:04 -06:00
|
|
|
if (Type != EVASION && Type != CAPTURE)
|
2009-07-14 00:53:22 -06:00
|
|
|
{
|
2009-09-23 03:47:11 -06:00
|
|
|
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);
|
|
|
|
}
|
2009-07-14 00:53:22 -06:00
|
|
|
}
|
|
|
|
|
2009-09-23 04:18:04 -06:00
|
|
|
// Underpromotion pawn pushes. Also promotion for evasions and captures.
|
2009-09-23 03:47:11 -06:00
|
|
|
b1 = move_pawns<Us, DELTA_N>(pp) & TRank8BB;
|
|
|
|
b1 &= (Type == EVASION ? blockSquares : emptySquares);
|
|
|
|
|
2009-07-14 00:53:22 -06:00
|
|
|
while (b1)
|
|
|
|
{
|
|
|
|
to = pop_1st_bit(&b1);
|
2009-09-23 04:18:04 -06:00
|
|
|
if (Type == EVASION || Type == CAPTURE)
|
2009-09-23 03:47:11 -06:00
|
|
|
(*mlist++).move = make_promotion_move(to - TDELTA_N, to, QUEEN);
|
|
|
|
|
2009-09-23 04:18:04 -06:00
|
|
|
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);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (Type == CAPTURE)
|
|
|
|
{
|
|
|
|
// 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);
|
|
|
|
|
|
|
|
while (b1)
|
|
|
|
{
|
|
|
|
to = pop_1st_bit(&b1);
|
|
|
|
(*mlist++).move = make_ep_move(to, pos.ep_square());
|
|
|
|
}
|
2009-07-14 00:53:22 -06:00
|
|
|
}
|
2009-09-23 04:18:04 -06:00
|
|
|
return mlist;
|
2008-08-31 23:59:13 -06:00
|
|
|
}
|
|
|
|
|
2009-09-21 03:00:33 -06:00
|
|
|
dcPawns1 = dcPawns2 = EmptyBoardBB;
|
2009-09-23 03:47:11 -06:00
|
|
|
if (Type == CHECK && (pawns & dcp))
|
2008-10-18 07:36:58 -06:00
|
|
|
{
|
2009-02-10 04:28:47 -07:00
|
|
|
// 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.
|
2009-09-23 03:47:11 -06:00
|
|
|
dcPawns1 = move_pawns<Us, DELTA_N>(pawns & dcp & ~file_bb(ksq)) & emptySquares & ~TRank8BB;
|
2009-09-21 03:00:33 -06:00
|
|
|
dcPawns2 = move_pawns<Us, DELTA_N>(dcPawns1 & TRank3BB) & emptySquares;
|
2008-10-18 07:36:58 -06:00
|
|
|
}
|
|
|
|
|
2009-09-21 03:00:33 -06:00
|
|
|
// Single pawn pushes
|
|
|
|
b1 = move_pawns<Us, DELTA_N>(pawns) & emptySquares & ~TRank8BB;
|
2009-09-23 03:47:11 -06:00
|
|
|
b2 = (Type == CHECK ? (b1 & pos.attacks_from<PAWN>(ksq, Them)) | dcPawns1 :
|
|
|
|
(Type == EVASION ? b1 & blockSquares : b1));
|
2009-09-21 03:00:33 -06:00
|
|
|
SERIALIZE_MOVES_D(b2, -TDELTA_N);
|
2008-10-18 07:36:58 -06:00
|
|
|
|
2009-09-21 03:00:33 -06:00
|
|
|
// Double pawn pushes
|
|
|
|
b1 = move_pawns<Us, DELTA_N>(b1 & TRank3BB) & emptySquares;
|
2009-09-23 03:47:11 -06:00
|
|
|
b2 = (Type == CHECK ? (b1 & pos.attacks_from<PAWN>(ksq, Them)) | dcPawns2 :
|
|
|
|
(Type == EVASION ? b1 & blockSquares : b1));
|
2009-09-21 03:00:33 -06:00
|
|
|
SERIALIZE_MOVES_D(b2, -TDELTA_N -TDELTA_N);
|
2008-10-22 16:18:11 -06:00
|
|
|
return mlist;
|
2008-10-18 07:36:58 -06:00
|
|
|
}
|
2008-10-19 01:49:26 -06:00
|
|
|
|
2008-10-20 02:22:29 -06:00
|
|
|
template<PieceType Piece>
|
2009-02-10 08:02:48 -07:00
|
|
|
MoveStack* generate_piece_checks(const Position& pos, MoveStack* mlist, Color us,
|
|
|
|
Bitboard dc, Square ksq) {
|
|
|
|
|
2009-09-02 03:57:38 -06:00
|
|
|
Bitboard target = pos.pieces(Piece, us);
|
2009-02-10 08:02:48 -07:00
|
|
|
|
2009-09-23 02:40:33 -06:00
|
|
|
// Discovered non-capture checks
|
2008-10-20 02:22:29 -06:00
|
|
|
Bitboard b = target & dc;
|
2009-09-23 02:40:33 -06:00
|
|
|
|
|
|
|
assert(Piece != QUEEN || !b);
|
|
|
|
|
2008-10-20 02:22:29 -06:00
|
|
|
while (b)
|
|
|
|
{
|
|
|
|
Square from = pop_1st_bit(&b);
|
2009-09-20 07:23:46 -06:00
|
|
|
Bitboard bb = pos.attacks_from<Piece>(from) & pos.empty_squares();
|
2009-02-10 03:03:45 -07:00
|
|
|
if (Piece == KING)
|
|
|
|
bb &= ~QueenPseudoAttacks[ksq];
|
|
|
|
|
2008-10-23 02:42:14 -06:00
|
|
|
SERIALIZE_MOVES(bb);
|
2008-10-20 02:22:29 -06:00
|
|
|
}
|
2009-02-10 03:03:45 -07:00
|
|
|
|
2009-09-23 02:40:33 -06:00
|
|
|
// Direct non-capture checks
|
2008-10-20 02:22:29 -06:00
|
|
|
b = target & ~dc;
|
2009-09-21 01:47:47 -06:00
|
|
|
Bitboard checkSqs = pos.attacks_from<Piece>(ksq) & pos.empty_squares();
|
|
|
|
if (Piece == KING || !checkSqs)
|
|
|
|
return mlist;
|
|
|
|
|
|
|
|
while (b)
|
2008-10-20 02:22:29 -06:00
|
|
|
{
|
2009-09-21 01:47:47 -06:00
|
|
|
Square from = pop_1st_bit(&b);
|
|
|
|
if ( (Piece == QUEEN && !(QueenPseudoAttacks[from] & checkSqs))
|
|
|
|
|| (Piece == ROOK && !(RookPseudoAttacks[from] & checkSqs))
|
|
|
|
|| (Piece == BISHOP && !(BishopPseudoAttacks[from] & checkSqs)))
|
|
|
|
continue;
|
2009-04-19 13:09:53 -06:00
|
|
|
|
2009-09-21 01:47:47 -06:00
|
|
|
Bitboard bb = pos.attacks_from<Piece>(from) & checkSqs;
|
|
|
|
SERIALIZE_MOVES(bb);
|
2008-10-20 02:22:29 -06:00
|
|
|
}
|
2008-10-22 16:18:11 -06:00
|
|
|
return mlist;
|
2008-10-20 02:22:29 -06:00
|
|
|
}
|
|
|
|
|
2009-02-05 08:08:00 -07:00
|
|
|
template<CastlingSide Side>
|
|
|
|
MoveStack* generate_castle_moves(const Position& pos, MoveStack* mlist) {
|
2008-10-19 09:54:18 -06:00
|
|
|
|
2008-10-20 02:46:31 -06:00
|
|
|
Color us = pos.side_to_move();
|
2008-10-19 09:54:18 -06:00
|
|
|
|
2009-02-05 08:08:00 -07:00
|
|
|
if ( (Side == KING_SIDE && pos.can_castle_kingside(us))
|
|
|
|
||(Side == QUEEN_SIDE && pos.can_castle_queenside(us)))
|
2008-10-19 09:54:18 -06:00
|
|
|
{
|
|
|
|
Color them = opposite_color(us);
|
2008-10-20 13:57:13 -06:00
|
|
|
Square ksq = pos.king_square(us);
|
2008-10-19 09:54:18 -06:00
|
|
|
|
2009-02-17 09:26:15 -07:00
|
|
|
assert(pos.piece_on(ksq) == piece_of_color_and_type(us, KING));
|
2008-10-19 09:54:18 -06:00
|
|
|
|
2009-02-05 08:08:00 -07:00
|
|
|
Square rsq = (Side == KING_SIDE ? pos.initial_kr_square(us) : pos.initial_qr_square(us));
|
|
|
|
Square s1 = relative_square(us, Side == KING_SIDE ? SQ_G1 : SQ_C1);
|
|
|
|
Square s2 = relative_square(us, Side == KING_SIDE ? SQ_F1 : SQ_D1);
|
2009-02-05 07:06:41 -07:00
|
|
|
Square s;
|
|
|
|
bool illegal = false;
|
2008-10-19 09:54:18 -06:00
|
|
|
|
2009-02-17 09:26:15 -07:00
|
|
|
assert(pos.piece_on(rsq) == piece_of_color_and_type(us, ROOK));
|
2008-10-19 09:54:18 -06:00
|
|
|
|
2009-02-05 08:08:00 -07:00
|
|
|
// It is a bit complicated to correctly handle Chess960
|
|
|
|
for (s = Min(ksq, s1); s <= Max(ksq, s1); s++)
|
2009-02-05 07:06:41 -07:00
|
|
|
if ( (s != ksq && s != rsq && pos.square_is_occupied(s))
|
2009-09-20 03:47:59 -06:00
|
|
|
||(pos.attackers_to(s) & pos.pieces_of_color(them)))
|
2009-02-05 07:06:41 -07:00
|
|
|
illegal = true;
|
2008-10-19 09:54:18 -06:00
|
|
|
|
2009-02-05 08:08:00 -07:00
|
|
|
for (s = Min(rsq, s2); s <= Max(rsq, s2); s++)
|
2009-02-05 07:06:41 -07:00
|
|
|
if (s != ksq && s != rsq && pos.square_is_occupied(s))
|
|
|
|
illegal = true;
|
2008-10-19 09:54:18 -06:00
|
|
|
|
2009-02-05 08:08:00 -07:00
|
|
|
if ( Side == QUEEN_SIDE
|
|
|
|
&& square_file(rsq) == FILE_B
|
2009-02-17 02:54:47 -07:00
|
|
|
&& ( pos.piece_on(relative_square(us, SQ_A1)) == piece_of_color_and_type(them, ROOK)
|
|
|
|
|| pos.piece_on(relative_square(us, SQ_A1)) == piece_of_color_and_type(them, QUEEN)))
|
2009-02-05 08:08:00 -07:00
|
|
|
illegal = true;
|
|
|
|
|
2009-02-05 07:06:41 -07:00
|
|
|
if (!illegal)
|
|
|
|
(*mlist++).move = make_castle_move(ksq, rsq);
|
|
|
|
}
|
2008-10-22 16:18:11 -06:00
|
|
|
return mlist;
|
2008-10-19 09:54:18 -06:00
|
|
|
}
|
2008-10-22 16:18:11 -06:00
|
|
|
|
2009-02-05 07:06:41 -07:00
|
|
|
bool castling_is_check(const Position& pos, CastlingSide side) {
|
|
|
|
|
|
|
|
// After castling opponent king is attacked by the castled rook?
|
|
|
|
File rookFile = (side == QUEEN_SIDE ? FILE_D : FILE_F);
|
|
|
|
Color us = pos.side_to_move();
|
|
|
|
Square ksq = pos.king_square(us);
|
2009-02-06 08:40:30 -07:00
|
|
|
Bitboard occ = pos.occupied_squares();
|
2009-02-05 07:06:41 -07:00
|
|
|
|
|
|
|
clear_bit(&occ, ksq); // Remove our king from the board
|
|
|
|
Square rsq = make_square(rookFile, square_rank(ksq));
|
2009-02-06 08:40:30 -07:00
|
|
|
return bit_is_set(rook_attacks_bb(rsq, occ), pos.king_square(opposite_color(us)));
|
2009-02-05 07:06:41 -07:00
|
|
|
}
|
2008-08-31 23:59:13 -06:00
|
|
|
}
|