struct RootMove {
- RootMove() { nodes = cumulativeNodes = ourBeta = theirBeta = 0ULL; }
+ RootMove() { mp_score = 0; nodes = cumulativeNodes = ourBeta = theirBeta = 0ULL; }
// RootMove::operator<() is the comparison function used when
// sorting the moves. A move m1 is considered to be better
// have equal score but m1 has the higher beta cut-off count.
bool operator<(const RootMove& m) const {
- return score != m.score ? score < m.score : theirBeta <= m.theirBeta;
+ return score != m.score ? score < m.score : mp_score <= m.mp_score;
}
Move move;
Value score;
+ int mp_score;
int64_t nodes, cumulativeNodes, ourBeta, theirBeta;
Move pv[PLY_MAX_PLUS_2];
};
public:
RootMoveList(Position& pos, Move searchMoves[]);
+ void set_mp_scores(const Position &pos);
+
int move_count() const { return count; }
Move get_move(int moveNum) const { return moves[moveNum].move; }
Value get_move_score(int moveNum) const { return moves[moveNum].score; }
while (1)
{
// Sort the moves before to (re)search
+ rml.set_mp_scores(pos);
rml.sort();
// Step 10. Loop through all moves in the root move list
// Step 2. Check for aborted search and immediate draw
if (AbortSearch || ThreadsMgr.thread_should_stop(threadID))
- return Value(0);
+ return VALUE_ZERO;
if (pos.is_draw() || ply >= PLY_MAX - 1)
return VALUE_DRAW;
&& tte
&& tte->move()
&& !excludedMove // Do not allow recursive singular extension search
- && is_lower_bound(tte->type())
+ && (tte->type() & VALUE_TYPE_LOWER)
&& tte->depth() >= depth - 3 * ONE_PLY;
// Step 10. Loop through moves
{
futilityValue = futilityBase
+ pos.endgame_value_of_piece_on(move_to(move))
- + (move_is_ep(move) ? PawnValueEndgame : Value(0));
+ + (move_is_ep(move) ? PawnValueEndgame : VALUE_ZERO);
if (futilityValue < alpha)
{
if ( captureOrPromotion
&& pos.type_of_piece_on(move_to(m)) != PAWN
&& ( pos.non_pawn_material(WHITE) + pos.non_pawn_material(BLACK)
- - pos.midgame_value_of_piece_on(move_to(m)) == Value(0))
+ - pos.midgame_value_of_piece_on(move_to(m)) == VALUE_ZERO)
&& !move_is_promotion(m)
&& !move_is_ep(m))
{
|| v >= Max(value_mate_in(PLY_MAX), beta)
|| v < Min(value_mated_in(PLY_MAX), beta))
- && ( (is_lower_bound(tte->type()) && v >= beta)
- || (is_upper_bound(tte->type()) && v < beta));
+ && ( ((tte->type() & VALUE_TYPE_LOWER) && v >= beta)
+ || ((tte->type() & VALUE_TYPE_UPPER) && v < beta));
}
Value v = value_from_tt(tte->value(), ply);
- if ( (is_lower_bound(tte->type()) && v >= defaultEval)
- || (is_upper_bound(tte->type()) && v < defaultEval))
+ if ( ((tte->type() & VALUE_TYPE_LOWER) && v >= defaultEval)
+ || ((tte->type() & VALUE_TYPE_UPPER) && v < defaultEval))
return v;
return defaultEval;
}
+ void RootMoveList::set_mp_scores(const Position &pos)
+ {
+ MovePicker mp = MovePicker(pos, MOVE_NONE, ONE_PLY, H);
+ Move move;
+
+ int moveCount = 0;
+ while ((move = mp.get_next_move()) != MOVE_NONE)
+ {
+ moveCount++;
+ for (int i = 0; i < count; i++)
+ {
+ if (moves[i].move == move)
+ {
+ moves[i].mp_score = 512 - moveCount;
+ break;
+ }
+ }
+ }
+ }
+
// RootMoveList simple methods definitions
void RootMoveList::set_move_nodes(int moveNum, int64_t nodes) {