namespace {
- /// Types
+ // Maximum number of allowed moves per position
+ const int MOVES_MAX = 256;
+
+ // Types
enum NodeType { NonPV, PV };
// Set to true to force running with one thread.
int active_threads() const { return ActiveThreads; }
void set_active_threads(int newActiveThreads) { ActiveThreads = newActiveThreads; }
void incrementNodeCounter(int threadID) { threads[threadID].nodes++; }
- void incrementBetaCounter(Color us, Depth d, int threadID) { threads[threadID].betaCutOffs[us] += unsigned(d); }
void resetNodeCounters();
- void resetBetaCounters();
int64_t nodes_searched() const;
- void get_beta_counters(Color us, int64_t& our, int64_t& their) const;
bool available_thread_exists(int master) const;
bool thread_is_available(int slave, int master) const;
bool thread_should_stop(int threadID) const;
struct RootMove {
- RootMove() { nodes = cumulativeNodes = ourBeta = theirBeta = 0ULL; }
+ RootMove() : mp_score(0), nodes(0) {}
// 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;
- int64_t nodes, cumulativeNodes, ourBeta, theirBeta;
+ int mp_score;
+ int64_t nodes;
Move pv[PLY_MAX_PLUS_2];
};
public:
RootMoveList(Position& pos, Move searchMoves[]);
+ Move move(int moveNum) const { return moves[moveNum].move; }
+ Move move_pv(int moveNum, int i) const { return moves[moveNum].pv[i]; }
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; }
+ Value move_score(int moveNum) const { return moves[moveNum].score; }
+ int64_t move_nodes(int moveNum) const { return moves[moveNum].nodes; }
+ void add_move_nodes(int moveNum, int64_t nodes) { moves[moveNum].nodes += nodes; }
void set_move_score(int moveNum, Value score) { moves[moveNum].score = score; }
- Move get_move_pv(int moveNum, int i) const { return moves[moveNum].pv[i]; }
- int64_t get_move_cumulative_nodes(int moveNum) const { return moves[moveNum].cumulativeNodes; }
- void set_move_nodes(int moveNum, int64_t nodes);
- void set_beta_counters(int moveNum, int64_t our, int64_t their);
void set_move_pv(int moveNum, const Move pv[]);
+ void score_moves(const Position& pos);
void sort();
void sort_multipv(int n);
private:
- static const int MaxRootMoves = 500;
- RootMove moves[MaxRootMoves];
+ RootMove moves[MOVES_MAX];
int count;
};
+ // When formatting a move for std::cout we must know if we are in Chess960
+ // or not. To keep using the handy operator<<() on the move the trick is to
+ // embed this flag in the stream itself. Function-like named enum set960 is
+ // used as a custom manipulator and the stream internal general-purpose array,
+ // accessed through ios_base::iword(), is used to pass the flag to the move's
+ // operator<<() that will use it to properly format castling moves.
+ enum set960 {};
+
+ std::ostream& operator<< (std::ostream& os, const set960& m) {
+
+ os.iword(0) = int(m);
+ return os;
+ }
+
+
/// Adjustments
// Step 6. Razoring
// Dynamic razoring margin based on depth
inline Value razor_margin(Depth d) { return Value(0x200 + 0x10 * int(d)); }
- // Step 8. Null move search with verification search
-
- // Null move margin. A null move search will not be done if the static
- // evaluation of the position is more than NullMoveMargin below beta.
- const Value NullMoveMargin = Value(0x200);
-
// Maximum depth for use of dynamic threat detection when null move fails low
const Depth ThreatDepth = 5 * ONE_PLY;
const Value FutilityMarginQS = Value(0x80);
// Futility lookup tables (initialized at startup) and their getter functions
- int32_t FutilityMarginsMatrix[16][64]; // [depth][moveNumber]
+ Value FutilityMarginsMatrix[16][64]; // [depth][moveNumber]
int FutilityMoveCountArray[32]; // [depth]
- inline Value futility_margin(Depth d, int mn) { return Value(d < 7 * ONE_PLY ? FutilityMarginsMatrix[Max(d, 1)][Min(mn, 63)] : 2 * VALUE_INFINITE); }
+ inline Value futility_margin(Depth d, int mn) { return d < 7 * ONE_PLY ? FutilityMarginsMatrix[Max(d, 1)][Min(mn, 63)] : 2 * VALUE_INFINITE; }
inline int futility_move_count(Depth d) { return d < 16 * ONE_PLY ? FutilityMoveCountArray[d] : 512; }
// Step 14. Reduced search
// Init futility margins array
for (d = 1; d < 16; d++) for (mc = 0; mc < 64; mc++)
- FutilityMarginsMatrix[d][mc] = 112 * int(log(double(d * d) / 2) / log(2.0) + 1.001) - 8 * mc + 45;
+ FutilityMarginsMatrix[d][mc] = Value(112 * int(log(double(d * d) / 2) / log(2.0) + 1.001) - 8 * mc + 45);
// Init futility move count array
for (d = 0; d < 32; d++)
- FutilityMoveCountArray[d] = 3 + (1 << (3 * d / 8));
+ FutilityMoveCountArray[d] = int(3.001 + 0.25 * pow(d, 2.0));
}
int perft(Position& pos, Depth depth)
{
- MoveStack mlist[256];
+ MoveStack mlist[MOVES_MAX];
StateInfo st;
Move m;
int sum = 0;
MinimumSplitDepth = get_option_value_int("Minimum Split Depth") * ONE_PLY;
MaxThreadsPerSplitPoint = get_option_value_int("Maximum Number of Threads per Split Point");
MultiPV = get_option_value_int("MultiPV");
- Chess960 = get_option_value_bool("UCI_Chess960");
UseLogFile = get_option_value_bool("Use Search Log");
if (UseLogFile)
// Print RootMoveList startup scoring to the standard output,
// so to output information also for iteration 1.
- cout << "info depth " << 1
+ cout << set960(p.is_chess960()) // Is enough to set once at the beginning
+ << "info depth " << 1
<< "\ninfo depth " << 1
- << " score " << value_to_uci(rml.get_move_score(0))
+ << " score " << value_to_uci(rml.move_score(0))
<< " time " << current_search_time()
<< " nodes " << ThreadsMgr.nodes_searched()
<< " nps " << nps()
- << " pv " << rml.get_move(0) << "\n";
+ << " pv " << rml.move(0) << "\n";
// Initialize
TT.new_search();
H.clear();
init_ss_array(ss, PLY_MAX_PLUS_2);
pv[0] = pv[1] = MOVE_NONE;
- ValueByIteration[1] = rml.get_move_score(0);
+ ValueByIteration[1] = rml.move_score(0);
Iteration = 1;
// Is one move significantly better than others after initial scoring ?
if ( rml.move_count() == 1
- || rml.get_move_score(0) > rml.get_move_score(1) + EasyMoveMargin)
- EasyMove = rml.get_move(0);
+ || rml.move_score(0) > rml.move_score(1) + EasyMoveMargin)
+ EasyMove = rml.move(0);
// Iterative deepening loop
while (Iteration < PLY_MAX)
int64_t nodes = ThreadsMgr.nodes_searched();
if ( Iteration >= 8
&& EasyMove == pv[0]
- && ( ( rml.get_move_cumulative_nodes(0) > (nodes * 85) / 100
+ && ( ( rml.move_nodes(0) > (nodes * 85) / 100
&& current_search_time() > TimeMgr.available_time() / 16)
- ||( rml.get_move_cumulative_nodes(0) > (nodes * 98) / 100
+ ||( rml.move_nodes(0) > (nodes * 98) / 100
&& current_search_time() > TimeMgr.available_time() / 32)))
stopSearch = true;
// Print the best move and the ponder move to the standard output
if (pv[0] == MOVE_NONE)
{
- pv[0] = rml.get_move(0);
+ pv[0] = rml.move(0);
pv[1] = MOVE_NONE;
}
<< move_to_san(p, pv[1]) // Works also with MOVE_NONE
<< endl;
}
- return rml.get_move_score(0);
+ return rml.move_score(0);
}
Value root_search(Position& pos, SearchStack* ss, Move* pv, RootMoveList& rml, Value* alphaPtr, Value* betaPtr) {
- EvalInfo ei;
StateInfo st;
CheckInfo ci(pos);
int64_t nodes;
Move move;
Depth depth, ext, newDepth;
- Value value, alpha, beta;
+ Value value, evalMargin, alpha, beta;
bool isCheck, moveIsCheck, captureOrPromotion, dangerous;
int researchCountFH, researchCountFL;
// Step 5. Evaluate the position statically
// At root we do this only to get reference value for child nodes
- ss->eval = isCheck ? VALUE_NONE : evaluate(pos, ei);
+ ss->eval = isCheck ? VALUE_NONE : evaluate(pos, evalMargin);
// Step 6. Razoring (omitted at root)
// Step 7. Static null move pruning (omitted at root)
while (1)
{
// Sort the moves before to (re)search
+ rml.score_moves(pos);
rml.sort();
// Step 10. Loop through all moves in the root move list
// Save the current node count before the move is searched
nodes = ThreadsMgr.nodes_searched();
- // Reset beta cut-off counters
- ThreadsMgr.resetBetaCounters();
-
// Pick the next root move, and print the move and the move number to
// the standard output.
- move = ss->currentMove = rml.get_move(i);
+ move = ss->currentMove = rml.move(i);
if (current_search_time() >= 1000)
cout << "info currmove " << move
if (AbortSearch)
break;
- // Remember beta-cutoff and searched nodes counts for this move. The
- // info is used to sort the root moves for the next iteration.
- int64_t our, their;
- ThreadsMgr.get_beta_counters(pos.side_to_move(), our, their);
- rml.set_beta_counters(i, our, their);
- rml.set_move_nodes(i, ThreadsMgr.nodes_searched() - nodes);
+ // Remember searched nodes counts for this move
+ rml.add_move_nodes(i, ThreadsMgr.nodes_searched() - nodes);
assert(value >= -VALUE_INFINITE && value <= VALUE_INFINITE);
assert(value < beta);
for (int j = 0; j < Min(MultiPV, rml.move_count()); j++)
{
cout << "info multipv " << j + 1
- << " score " << value_to_uci(rml.get_move_score(j))
+ << " score " << value_to_uci(rml.move_score(j))
<< " depth " << (j <= i ? Iteration : Iteration - 1)
<< " time " << current_search_time()
<< " nodes " << ThreadsMgr.nodes_searched()
<< " nps " << nps()
<< " pv ";
- for (int k = 0; rml.get_move_pv(j, k) != MOVE_NONE && k < PLY_MAX; k++)
- cout << rml.get_move_pv(j, k) << " ";
+ for (int k = 0; rml.move_pv(j, k) != MOVE_NONE && k < PLY_MAX; k++)
+ cout << rml.move_pv(j, k) << " ";
cout << endl;
}
- alpha = rml.get_move_score(Min(i, MultiPV - 1));
+ alpha = rml.move_score(Min(i, MultiPV - 1));
}
} // PV move or new best move
assert(ply > 0 && ply < PLY_MAX);
assert(pos.thread() >= 0 && pos.thread() < ThreadsMgr.active_threads());
- Move movesSearched[256];
- EvalInfo ei;
+ Move movesSearched[MOVES_MAX];
StateInfo st;
const TTEntry *tte;
Key posKey;
Move ttMove, move, excludedMove, threatMove;
Depth ext, newDepth;
- Value bestValue, value, oldAlpha;
- Value refinedValue, nullValue, futilityValueScaled; // Non-PV specific
+ Value bestValue, value, evalMargin, oldAlpha;
+ Value refinedValue, nullValue, futilityBase, futilityValueScaled; // Non-PV specific
bool isCheck, singleEvasion, singularExtensionNode, moveIsCheck, captureOrPromotion, dangerous;
bool mateThreat = false;
int moveCount = 0;
// 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;
if (!PvNode && tte && ok_to_use_TT(tte, depth, beta, ply))
{
// Refresh tte entry to avoid aging
- TT.store(posKey, tte->value(), tte->type(), tte->depth(), ttMove, tte->static_value(), tte->king_danger());
+ TT.store(posKey, tte->value(), tte->type(), tte->depth(), ttMove, tte->static_value(), tte->static_value_margin());
ss->bestMove = ttMove; // Can be MOVE_NONE
return value_from_tt(tte->value(), ply);
// update gain statistics of parent move.
isCheck = pos.is_check();
if (isCheck)
- ss->eval = VALUE_NONE;
+ ss->eval = evalMargin = VALUE_NONE;
else if (tte)
{
assert(tte->static_value() != VALUE_NONE);
ss->eval = tte->static_value();
- ei.kingDanger[pos.side_to_move()] = tte->king_danger();
+ evalMargin = tte->static_value_margin();
refinedValue = refine_eval(tte, ss->eval, ply);
}
else
{
- refinedValue = ss->eval = evaluate(pos, ei);
- TT.store(posKey, VALUE_NONE, VALUE_TYPE_NONE, DEPTH_NONE, MOVE_NONE, ss->eval, ei.kingDanger[pos.side_to_move()]);
+ refinedValue = ss->eval = evaluate(pos, evalMargin);
+ TT.store(posKey, VALUE_NONE, VALUE_TYPE_NONE, DEPTH_NONE, MOVE_NONE, ss->eval, evalMargin);
}
// Save gain for the parent non-capture move
return refinedValue - futility_margin(depth, 0);
// Step 8. Null move search with verification search (is omitted in PV nodes)
- // When we jump directly to qsearch() we do a null move only if static value is
- // at least beta. Otherwise we do a null move if static value is not more than
- // NullMoveMargin under beta.
if ( !PvNode
&& !ss->skipNullMove
&& depth > ONE_PLY
&& !isCheck
- && refinedValue >= beta - (depth >= 4 * ONE_PLY ? NullMoveMargin : 0)
+ && refinedValue >= beta
&& !value_is_mate(beta)
&& pos.non_pawn_material(pos.side_to_move()))
{
CheckInfo ci(pos);
ss->bestMove = MOVE_NONE;
singleEvasion = isCheck && mp.number_of_evasions() == 1;
+ futilityBase = ss->eval + evalMargin;
singularExtensionNode = depth >= SingularExtensionDepth[PvNode]
&& 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
// We illogically ignore reduction condition depth >= 3*ONE_PLY for predicted depth,
// but fixing this made program slightly weaker.
Depth predictedDepth = newDepth - reduction<NonPV>(depth, moveCount);
- futilityValueScaled = ss->eval + futility_margin(predictedDepth, moveCount)
+ futilityValueScaled = futilityBase + futility_margin(predictedDepth, moveCount)
+ H.gain(pos.piece_on(move_from(move)), move_to(move));
if (futilityValueScaled < beta)
ValueType vt = (bestValue <= oldAlpha ? VALUE_TYPE_UPPER : bestValue >= beta ? VALUE_TYPE_LOWER : VALUE_TYPE_EXACT);
move = (bestValue <= oldAlpha ? MOVE_NONE : ss->bestMove);
- TT.store(posKey, value_to_tt(bestValue, ply), vt, depth, move, ss->eval, ei.kingDanger[pos.side_to_move()]);
+ TT.store(posKey, value_to_tt(bestValue, ply), vt, depth, move, ss->eval, evalMargin);
// Update killers and history only for non capture moves that fails high
- if (bestValue >= beta)
+ if ( bestValue >= beta
+ && !pos.move_is_capture_or_promotion(move))
{
- ThreadsMgr.incrementBetaCounter(pos.side_to_move(), depth, threadID);
- if (!pos.move_is_capture_or_promotion(move))
- {
update_history(pos, move, depth, movesSearched, moveCount);
update_killers(move, ss);
- }
}
assert(bestValue > -VALUE_INFINITE && bestValue < VALUE_INFINITE);
assert(ply > 0 && ply < PLY_MAX);
assert(pos.thread() >= 0 && pos.thread() < ThreadsMgr.active_threads());
- EvalInfo ei;
StateInfo st;
Move ttMove, move;
- Value bestValue, value, futilityValue, futilityBase;
+ Value bestValue, value, evalMargin, futilityValue, futilityBase;
bool isCheck, deepChecks, enoughMaterial, moveIsCheck, evasionPrunable;
const TTEntry* tte;
Value oldAlpha = alpha;
if (isCheck)
{
bestValue = futilityBase = -VALUE_INFINITE;
- ss->eval = VALUE_NONE;
+ ss->eval = evalMargin = VALUE_NONE;
deepChecks = enoughMaterial = false;
}
else
{
assert(tte->static_value() != VALUE_NONE);
- ei.kingDanger[pos.side_to_move()] = tte->king_danger();
- bestValue = tte->static_value();
+ evalMargin = tte->static_value_margin();
+ ss->eval = bestValue = tte->static_value();
}
else
- bestValue = evaluate(pos, ei);
+ ss->eval = bestValue = evaluate(pos, evalMargin);
- ss->eval = bestValue;
update_gains(pos, (ss-1)->currentMove, (ss-1)->eval, ss->eval);
// Stand pat. Return immediately if static value is at least beta
if (bestValue >= beta)
{
if (!tte)
- TT.store(pos.get_key(), value_to_tt(bestValue, ply), VALUE_TYPE_LOWER, DEPTH_NONE, MOVE_NONE, ss->eval, ei.kingDanger[pos.side_to_move()]);
+ TT.store(pos.get_key(), value_to_tt(bestValue, ply), VALUE_TYPE_LOWER, DEPTH_NONE, MOVE_NONE, ss->eval, evalMargin);
return bestValue;
}
deepChecks = (depth == -ONE_PLY && bestValue >= beta - PawnValueMidgame / 8);
// Futility pruning parameters, not needed when in check
- futilityBase = bestValue + FutilityMarginQS + ei.kingDanger[pos.side_to_move()];
+ futilityBase = ss->eval + evalMargin + FutilityMarginQS;
enoughMaterial = pos.non_pawn_material(pos.side_to_move()) > RookValueMidgame;
}
{
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)
{
}
}
- // Detect blocking evasions that are candidate to be pruned
+ // Detect non-capture evasions that are candidate to be pruned
evasionPrunable = isCheck
&& bestValue > value_mated_in(PLY_MAX)
&& !pos.move_is_capture(move)
- && pos.type_of_piece_on(move_from(move)) != KING
&& !pos.can_castle(pos.side_to_move());
// Don't search moves with negative SEE values
// Update transposition table
Depth d = (depth == DEPTH_ZERO ? DEPTH_ZERO : DEPTH_ZERO - ONE_PLY);
ValueType vt = (bestValue <= oldAlpha ? VALUE_TYPE_UPPER : bestValue >= beta ? VALUE_TYPE_LOWER : VALUE_TYPE_EXACT);
- TT.store(pos.get_key(), value_to_tt(bestValue, ply), vt, d, ss->bestMove, ss->eval, ei.kingDanger[pos.side_to_move()]);
-
- // Update killers only for checking moves that fails high
- if ( bestValue >= beta
- && !pos.move_is_capture_or_promotion(ss->bestMove))
- update_killers(ss->bestMove, ss);
+ TT.store(pos.get_key(), value_to_tt(bestValue, ply), vt, d, ss->bestMove, ss->eval, evalMargin);
assert(bestValue > -VALUE_INFINITE && bestValue < VALUE_INFINITE);
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;
StateInfo st;
TTEntry* tte;
Position p(pos, pos.thread());
- EvalInfo ei;
- Value v;
+ Value v, m = VALUE_NONE;
for (int i = 0; pv[i] != MOVE_NONE; i++)
{
tte = TT.retrieve(p.get_key());
if (!tte || tte->move() != pv[i])
{
- v = (p.is_check() ? VALUE_NONE : evaluate(p, ei));
- TT.store(p.get_key(), VALUE_NONE, VALUE_TYPE_NONE, DEPTH_NONE, pv[i], v, ei.kingDanger[pos.side_to_move()]);
+ v = (p.is_check() ? VALUE_NONE : evaluate(p, m));
+ TT.store(p.get_key(), VALUE_NONE, VALUE_TYPE_NONE, DEPTH_NONE, pv[i], v, m);
}
p.do_move(pv[i], st);
}
threads[i].nodes = 0ULL;
}
- void ThreadsManager::resetBetaCounters() {
-
- for (int i = 0; i < MAX_THREADS; i++)
- threads[i].betaCutOffs[WHITE] = threads[i].betaCutOffs[BLACK] = 0ULL;
- }
-
int64_t ThreadsManager::nodes_searched() const {
int64_t result = 0ULL;
return result;
}
- void ThreadsManager::get_beta_counters(Color us, int64_t& our, int64_t& their) const {
-
- our = their = 0UL;
- for (int i = 0; i < MAX_THREADS; i++)
- {
- our += threads[i].betaCutOffs[us];
- their += threads[i].betaCutOffs[opposite_color(us)];
- }
- }
-
// idle_loop() is where the threads are parked when they have no work to do.
// The parameter 'sp', if non-NULL, is a pointer to an active SplitPoint
// RootMoveList c'tor
- RootMoveList::RootMoveList(Position& pos, Move searchMoves[]) : count(0) {
+ RootMoveList::RootMoveList(Position& pos, Move searchMoves[]) {
SearchStack ss[PLY_MAX_PLUS_2];
- MoveStack mlist[MaxRootMoves];
+ MoveStack mlist[MOVES_MAX];
StateInfo st;
bool includeAllMoves = (searchMoves[0] == MOVE_NONE);
// Initialize search stack
init_ss_array(ss, PLY_MAX_PLUS_2);
- ss[0].currentMove = ss[0].bestMove = MOVE_NONE;
ss[0].eval = VALUE_NONE;
+ count = 0;
// Generate all legal moves
MoveStack* last = generate_moves(pos, mlist);
continue;
// Find a quick score for the move
+ moves[count].move = ss[0].currentMove = moves[count].pv[0] = cur->move;
+ moves[count].pv[1] = MOVE_NONE;
pos.do_move(cur->move, st);
- ss[0].currentMove = cur->move;
- moves[count].move = cur->move;
moves[count].score = -qsearch<PV>(pos, ss+1, -VALUE_INFINITE, VALUE_INFINITE, DEPTH_ZERO, 1);
- moves[count].pv[0] = cur->move;
- moves[count].pv[1] = MOVE_NONE;
pos.undo_move(cur->move);
count++;
}
sort();
}
+ // Score root moves using the standard way used in main search, the moves
+ // are scored according to the order in which are returned by MovePicker.
- // RootMoveList simple methods definitions
-
- void RootMoveList::set_move_nodes(int moveNum, int64_t nodes) {
+ void RootMoveList::score_moves(const Position& pos)
+ {
+ Move move;
+ int score = 1000;
+ MovePicker mp = MovePicker(pos, MOVE_NONE, ONE_PLY, H);
- moves[moveNum].nodes = nodes;
- moves[moveNum].cumulativeNodes += nodes;
+ while ((move = mp.get_next_move()) != MOVE_NONE)
+ for (int i = 0; i < count; i++)
+ if (moves[i].move == move)
+ {
+ moves[i].mp_score = score--;
+ break;
+ }
}
- void RootMoveList::set_beta_counters(int moveNum, int64_t our, int64_t their) {
-
- moves[moveNum].ourBeta = our;
- moves[moveNum].theirBeta = their;
- }
+ // RootMoveList simple methods definitions
void RootMoveList::set_move_pv(int moveNum, const Move pv[]) {
}
}
-} // namspace
+} // namespace