summary |
shortlog |
log |
commit | commitdiff |
tree
raw |
patch |
inline | side by side (from parent 1:
110644d)
Stack has no meaning here, while ExtMove (extended move),
better clarifies that we have a move + a score.
No functional change.
namespace {
template<CastlingSide Side, bool Checks, bool Chess960>
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;
if (pos.castle_impeded(us, Side) || !pos.can_castle(make_castle_right(us, Side)))
return mlist;
template<GenType Type, Square Delta>
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;
Bitboard b = shift_bb<Delta>(pawnsOn7) & target;
template<Color Us, GenType Type>
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.
// Compute our parametrized parameters at compile time, named according to
// the point of view of white side.
template<PieceType Pt, bool Checks> FORCE_INLINE
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);
assert(Pt != KING && Pt != PAWN);
template<GenType Type> FORCE_INLINE
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;
const bool Checks = Type == QUIET_CHECKS;
/// non-captures. Returns a pointer to the end of the move list.
template<GenType Type>
/// 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());
assert(Type == CAPTURES || Type == QUIETS || Type == NON_EVASIONS);
assert(!pos.checkers());
}
// Explicit template instantiations
}
// 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<>
/// 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) {
/// 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<>
/// 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) {
/// generate<LEGAL> generates all the legal moves in the given position
template<>
/// 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());
Bitboard pinned = pos.pinned_pieces();
Square ksq = pos.king_square(pos.side_to_move());
class Position;
template<GenType>
class Position;
template<GenType>
-MoveStack* generate(const Position& pos, MoveStack* mlist);
+ExtMove* generate(const Position& pos, ExtMove* mlist);
/// The MoveList struct is a simple wrapper around generate(), sometimes comes
/// handy to use this class instead of the low level generate() function.
/// The MoveList struct is a simple wrapper around generate(), sometimes comes
/// handy to use this class instead of the low level generate() function.
Move operator*() const { return cur->move; }
size_t size() const { return last - mlist; }
bool contains(Move m) const {
Move operator*() const { return cur->move; }
size_t size() const { return last - mlist; }
bool contains(Move m) const {
- for (const MoveStack* it(mlist); it != last; ++it) if (it->move == m) return true;
+ for (const ExtMove* it(mlist); it != last; ++it) if (it->move == m) return true;
- MoveStack mlist[MAX_MOVES];
- MoveStack *cur, *last;
+ ExtMove mlist[MAX_MOVES];
+ ExtMove *cur, *last;
};
#endif // !defined(MOVEGEN_H_INCLUDED)
};
#endif // !defined(MOVEGEN_H_INCLUDED)
};
// Our insertion sort, guaranteed to be stable, as is needed
};
// Our insertion sort, guaranteed to be stable, as is needed
- void insertion_sort(MoveStack* begin, MoveStack* end)
+ void insertion_sort(ExtMove* begin, ExtMove* end)
for (p = begin + 1; p < end; ++p)
{
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.
// 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.
// 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;
{
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;
// 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))]
{
m = it->move;
it->score = PieceValue[MG][pos.piece_on(to_sq(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)];
{
m = it->move;
it->score = history[pos.piece_moved(m)][to_sq(m)];
- for (MoveStack* it = moves; it != end; ++it)
+ for (ExtMove* it = moves; it != end; ++it)
{
m = it->move;
if ((seeScore = pos.see_sign(m)) < 0)
{
m = it->move;
if ((seeScore = pos.see_sign(m)) < 0)
Move* countermoves;
Depth depth;
Move ttMove;
Move* countermoves;
Depth depth;
Move ttMove;
Square recaptureSquare;
int captureThreshold, phase;
Square recaptureSquare;
int captureThreshold, phase;
- MoveStack *cur, *end, *endQuiets, *endBadCaptures;
- MoveStack moves[MAX_MOVES];
+ ExtMove *cur, *end, *endQuiets, *endBadCaptures;
+ ExtMove moves[MAX_MOVES];
};
#endif // !defined(MOVEPICK_H_INCLUDED)
};
#endif // !defined(MOVEPICK_H_INCLUDED)
extern Value PieceValue[PHASE_NB][PIECE_NB];
extern Value PieceValue[PHASE_NB][PIECE_NB];
-inline bool operator<(const MoveStack& f, const MoveStack& s) {
+inline bool operator<(const ExtMove& f, const ExtMove& s) {
return f.score < s.score;
}
return f.score < s.score;
}