Stockfish, a UCI chess playing engine derived from Glaurung 2.1
Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad
- Copyright (C) 2015-2019 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad
+ Copyright (C) 2015-2020 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad
Stockfish is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
template<Color Us, GenType Type>
ExtMove* generate_pawn_moves(const Position& pos, ExtMove* moveList, Bitboard target) {
- // Compute some compile time parameters relative to the white side
- constexpr Color Them = (Us == WHITE ? BLACK : WHITE);
+ constexpr Color Them = ~Us;
constexpr Bitboard TRank7BB = (Us == WHITE ? Rank7BB : Rank2BB);
constexpr Bitboard TRank3BB = (Us == WHITE ? Rank3BB : Rank6BB);
- constexpr Direction Up = (Us == WHITE ? NORTH : SOUTH);
+ constexpr Direction Up = pawn_push(Us);
constexpr Direction UpRight = (Us == WHITE ? NORTH_EAST : SOUTH_WEST);
constexpr Direction UpLeft = (Us == WHITE ? NORTH_WEST : SOUTH_EAST);
template<Color Us, GenType Type>
- ExtMove* generate_all(const Position& pos, ExtMove* moveList, Bitboard target) {
-
- constexpr CastlingRights OO = Us & KING_SIDE;
- constexpr CastlingRights OOO = Us & QUEEN_SIDE;
+ ExtMove* generate_all(const Position& pos, ExtMove* moveList) {
constexpr bool Checks = Type == QUIET_CHECKS; // Reduce template instantations
+ Bitboard target;
+
+ switch (Type)
+ {
+ case CAPTURES:
+ target = pos.pieces(~Us);
+ break;
+ case QUIETS:
+ case QUIET_CHECKS:
+ target = ~pos.pieces();
+ break;
+ case EVASIONS:
+ {
+ Square checksq = lsb(pos.checkers());
+ target = between_bb(pos.square<KING>(Us), checksq) | checksq;
+ break;
+ }
+ case NON_EVASIONS:
+ target = ~pos.pieces(Us);
+ break;
+ default:
+ static_assert(true, "Unsupported type in generate_all()");
+ }
moveList = generate_pawn_moves<Us, Type>(pos, moveList, target);
moveList = generate_moves<KNIGHT, Checks>(pos, moveList, Us, target);
while (b)
*moveList++ = make_move(ksq, pop_lsb(&b));
- if (Type != CAPTURES && pos.can_castle(CastlingRights(OO | OOO)))
- {
- if (!pos.castling_impeded(OO) && pos.can_castle(OO))
- *moveList++ = make<CASTLING>(ksq, pos.castling_rook_square(OO));
-
- if (!pos.castling_impeded(OOO) && pos.can_castle(OOO))
- *moveList++ = make<CASTLING>(ksq, pos.castling_rook_square(OOO));
- }
+ if ((Type != CAPTURES) && pos.can_castle(Us & ANY_CASTLING))
+ for(CastlingRights cr : { Us & KING_SIDE, Us & QUEEN_SIDE } )
+ if (!pos.castling_impeded(cr) && pos.can_castle(cr))
+ *moveList++ = make<CASTLING>(ksq, pos.castling_rook_square(cr));
}
return moveList;
Color us = pos.side_to_move();
- Bitboard target = Type == CAPTURES ? pos.pieces(~us)
- : Type == QUIETS ? ~pos.pieces()
- : Type == NON_EVASIONS ? ~pos.pieces(us) : 0;
-
- return us == WHITE ? generate_all<WHITE, Type>(pos, moveList, target)
- : generate_all<BLACK, Type>(pos, moveList, target);
+ return us == WHITE ? generate_all<WHITE, Type>(pos, moveList)
+ : generate_all<BLACK, Type>(pos, moveList);
}
// Explicit template instantiations
assert(!pos.checkers());
Color us = pos.side_to_move();
- Bitboard dc = pos.blockers_for_king(~us) & pos.pieces(us);
+ Bitboard dc = pos.blockers_for_king(~us) & pos.pieces(us) & ~pos.pieces(PAWN);
while (dc)
{
Square from = pop_lsb(&dc);
PieceType pt = type_of(pos.piece_on(from));
- if (pt == PAWN)
- continue; // Will be generated together with direct checks
-
Bitboard b = pos.attacks_from(pt, from) & ~pos.pieces();
if (pt == KING)
*moveList++ = make_move(from, pop_lsb(&b));
}
- return us == WHITE ? generate_all<WHITE, QUIET_CHECKS>(pos, moveList, ~pos.pieces())
- : generate_all<BLACK, QUIET_CHECKS>(pos, moveList, ~pos.pieces());
+ return us == WHITE ? generate_all<WHITE, QUIET_CHECKS>(pos, moveList)
+ : generate_all<BLACK, QUIET_CHECKS>(pos, moveList);
}
// the king evasions in order to skip known illegal moves, which avoids any
// useless legality checks later on.
while (sliders)
- {
- Square checksq = pop_lsb(&sliders);
- sliderAttacks |= LineBB[checksq][ksq] ^ checksq;
- }
+ sliderAttacks |= LineBB[ksq][pop_lsb(&sliders)] & ~pos.checkers();
// Generate evasions for king, capture and non capture moves
Bitboard b = pos.attacks_from<KING>(ksq) & ~pos.pieces(us) & ~sliderAttacks;
return moveList; // Double check, only a king move can save the day
// Generate blocking evasions or captures of the checking piece
- Square checksq = lsb(pos.checkers());
- Bitboard target = between_bb(checksq, ksq) | checksq;
-
- return us == WHITE ? generate_all<WHITE, EVASIONS>(pos, moveList, target)
- : generate_all<BLACK, EVASIONS>(pos, moveList, target);
+ return us == WHITE ? generate_all<WHITE, EVASIONS>(pos, moveList)
+ : generate_all<BLACK, EVASIONS>(pos, moveList);
}