namespace {
template<CastlingSide Side, bool Checks, bool Chess960>
- MoveStack* generate_castle(const Position& pos, MoveStack* mlist, Color us) {
+ ExtMove* generate_castle(const Position& pos, ExtMove* mlist, Color us) {
if (pos.castle_impeded(us, Side) || !pos.can_castle(make_castle_right(us, Side)))
return mlist;
template<GenType Type, Square Delta>
- inline MoveStack* generate_promotions(MoveStack* mlist, Bitboard pawnsOn7,
- Bitboard target, const CheckInfo* ci) {
+ inline ExtMove* generate_promotions(ExtMove* mlist, Bitboard pawnsOn7,
+ Bitboard target, const CheckInfo* ci) {
Bitboard b = shift_bb<Delta>(pawnsOn7) & target;
template<Color Us, GenType Type>
- MoveStack* generate_pawn_moves(const Position& pos, MoveStack* mlist,
- Bitboard target, const CheckInfo* ci) {
+ ExtMove* generate_pawn_moves(const Position& pos, ExtMove* mlist,
+ Bitboard target, const CheckInfo* ci) {
// Compute our parametrized parameters at compile time, named according to
// the point of view of white side.
template<PieceType Pt, bool Checks> FORCE_INLINE
- MoveStack* generate_moves(const Position& pos, MoveStack* mlist, Color us,
- Bitboard target, const CheckInfo* ci) {
+ ExtMove* generate_moves(const Position& pos, ExtMove* mlist, Color us,
+ Bitboard target, const CheckInfo* ci) {
assert(Pt != KING && Pt != PAWN);
template<GenType Type> FORCE_INLINE
- MoveStack* generate_all(const Position& pos, MoveStack* mlist, Color us,
- Bitboard target, const CheckInfo* ci = NULL) {
+ ExtMove* generate_all(const Position& pos, ExtMove* mlist, Color us,
+ Bitboard target, const CheckInfo* ci = NULL) {
const bool Checks = Type == QUIET_CHECKS;
/// non-captures. Returns a pointer to the end of the move list.
template<GenType Type>
-MoveStack* generate(const Position& pos, MoveStack* mlist) {
+ExtMove* generate(const Position& pos, ExtMove* mlist) {
assert(Type == CAPTURES || Type == QUIETS || Type == NON_EVASIONS);
assert(!pos.checkers());
}
// Explicit template instantiations
-template MoveStack* generate<CAPTURES>(const Position&, MoveStack*);
-template MoveStack* generate<QUIETS>(const Position&, MoveStack*);
-template MoveStack* generate<NON_EVASIONS>(const Position&, MoveStack*);
+template ExtMove* generate<CAPTURES>(const Position&, ExtMove*);
+template ExtMove* generate<QUIETS>(const Position&, ExtMove*);
+template ExtMove* generate<NON_EVASIONS>(const Position&, ExtMove*);
/// generate<QUIET_CHECKS> generates all pseudo-legal non-captures and knight
/// underpromotions that give check. Returns a pointer to the end of the move list.
template<>
-MoveStack* generate<QUIET_CHECKS>(const Position& pos, MoveStack* mlist) {
+ExtMove* generate<QUIET_CHECKS>(const Position& pos, ExtMove* mlist) {
assert(!pos.checkers());
/// generate<EVASIONS> generates all pseudo-legal check evasions when the side
/// to move is in check. Returns a pointer to the end of the move list.
template<>
-MoveStack* generate<EVASIONS>(const Position& pos, MoveStack* mlist) {
+ExtMove* generate<EVASIONS>(const Position& pos, ExtMove* mlist) {
assert(pos.checkers());
/// generate<LEGAL> generates all the legal moves in the given position
template<>
-MoveStack* generate<LEGAL>(const Position& pos, MoveStack* mlist) {
+ExtMove* generate<LEGAL>(const Position& pos, ExtMove* mlist) {
- MoveStack *end, *cur = mlist;
+ ExtMove *end, *cur = mlist;
Bitboard pinned = pos.pinned_pieces();
Square ksq = pos.king_square(pos.side_to_move());
};
// Our insertion sort, guaranteed to be stable, as is needed
- void insertion_sort(MoveStack* begin, MoveStack* end)
+ void insertion_sort(ExtMove* begin, ExtMove* end)
{
- MoveStack tmp, *p, *q;
+ ExtMove tmp, *p, *q;
for (p = begin + 1; p < end; ++p)
{
// Unary predicate used by std::partition to split positive scores from remaining
// ones so to sort separately the two sets, and with the second sort delayed.
- inline bool has_positive_score(const MoveStack& ms) { return ms.score > 0; }
+ inline bool has_positive_score(const ExtMove& ms) { return ms.score > 0; }
// Picks and moves to the front the best move in the range [begin, end),
// it is faster than sorting all the moves in advance when moves are few, as
// normally are the possible captures.
- inline MoveStack* pick_best(MoveStack* begin, MoveStack* end)
+ inline ExtMove* pick_best(ExtMove* begin, ExtMove* end)
{
std::swap(*begin, *std::max_element(begin, end));
return begin;
// some SEE calls in case we get a cutoff (idea from Pablo Vazquez).
Move m;
- for (MoveStack* it = moves; it != end; ++it)
+ for (ExtMove* it = moves; it != end; ++it)
{
m = it->move;
it->score = PieceValue[MG][pos.piece_on(to_sq(m))]
Move m;
- for (MoveStack* it = moves; it != end; ++it)
+ for (ExtMove* it = moves; it != end; ++it)
{
m = it->move;
it->score = history[pos.piece_moved(m)][to_sq(m)];
Move m;
int seeScore;
- for (MoveStack* it = moves; it != end; ++it)
+ for (ExtMove* it = moves; it != end; ++it)
{
m = it->move;
if ((seeScore = pos.see_sign(m)) < 0)