LimitsType Limits;
std::vector<RootMove> RootMoves;
Position RootPosition;
+ Color RootColor;
Time::point SearchTime;
StateStackPtr SetupStates;
}
int BestMoveChanges;
int SkillLevel;
bool SkillLevelEnabled, Chess960;
+ Value DrawValue[2];
History H;
template <NodeType NT>
// Init futility move count array
for (d = 0; d < 32; d++)
- FutilityMoveCounts[d] = int(3.001 + 0.25 * pow(d, 2.0));
+ FutilityMoveCounts[d] = int(3.001 + 0.25 * pow(double(d), 2.0));
}
Position& pos = RootPosition;
Chess960 = pos.is_chess960();
- Eval::RootColor = pos.side_to_move();
- int scaledCF = Eval::ContemptFactor * MaterialTable::game_phase(pos) / PHASE_MIDGAME;
- Eval::ValueDraw[ Eval::RootColor] = VALUE_DRAW - Value(scaledCF);
- Eval::ValueDraw[~Eval::RootColor] = VALUE_DRAW + Value(scaledCF);
+ RootColor = pos.side_to_move();
TimeMgr.init(Limits, pos.startpos_ply_counter(), pos.side_to_move());
TT.new_search();
H.clear();
goto finalize;
}
+ if (Options["Contempt Factor"] && !Options["UCI_AnalyseMode"])
+ {
+ int cf = Options["Contempt Factor"] * PawnValueMg / 100; // In centipawns
+ cf = cf * MaterialTable::game_phase(pos) / PHASE_MIDGAME; // Scale down with phase
+ DrawValue[ RootColor] = VALUE_DRAW - Value(cf);
+ DrawValue[~RootColor] = VALUE_DRAW + Value(cf);
+ }
+ else
+ DrawValue[WHITE] = DrawValue[BLACK] = VALUE_DRAW;
+
if (Options["OwnBook"] && !Limits.infinite)
{
Move bookMove = book.probe(pos, Options["Book File"], Options["Best Book Move"]);
{
// Step 2. Check for aborted search and immediate draw
if (Signals.stop || pos.is_draw<false>() || ss->ply > MAX_PLY)
- return Eval::ValueDraw[pos.side_to_move()];
+ return DrawValue[pos.side_to_move()];
// Step 3. Mate distance pruning. Even if we mate at the next move our score
// would be at best mate_in(ss->ply+1), but if alpha is already bigger because
: ttValue >= beta ? (tte->type() & BOUND_LOWER)
: (tte->type() & BOUND_UPPER)))
{
+ assert(ttValue != VALUE_NONE); // Due to depth > DEPTH_NONE
+
TT.refresh(tte);
ss->currentMove = ttMove; // Can be MOVE_NONE
// Step 5. Evaluate the position statically and update parent's gain statistics
if (inCheck)
ss->eval = ss->evalMargin = refinedValue = VALUE_NONE;
+
else if (tte)
{
assert(tte->static_value() != VALUE_NONE);
else
{
refinedValue = ss->eval = evaluate(pos, ss->evalMargin);
- TT.store(posKey, VALUE_NONE, BOUND_NONE, DEPTH_NONE, MOVE_NONE, ss->eval, ss->evalMargin);
+ TT.store(posKey, VALUE_NONE, BOUND_NONE, DEPTH_NONE, MOVE_NONE,
+ ss->eval, ss->evalMargin);
}
// Update gain for the parent non-capture move given the static position
&& pos.pl_move_is_legal(move, ci.pinned)
&& abs(ttValue) < VALUE_KNOWN_WIN)
{
+ assert(ttValue != VALUE_NONE);
+
Value rBeta = ttValue - int(depth);
ss->excludedMove = move;
ss->skipNullMove = true;
// If we are in a singular extension search then return a fail low score.
// A split node has at least one move, the one tried before to be splitted.
if (!moveCount)
- return excludedMove ? alpha : inCheck ? mated_in(ss->ply) : VALUE_DRAW;
+ return excludedMove ? alpha
+ : inCheck ? mated_in(ss->ply) : DrawValue[pos.side_to_move()];
// If we have pruned all the moves without searching return a fail-low score
if (bestValue == -VALUE_INFINITE)
// Check for an instant draw or maximum ply reached
if (pos.is_draw<true>() || ss->ply > MAX_PLY)
- return Eval::ValueDraw[pos.side_to_move()];
+ return DrawValue[pos.side_to_move()];
// Transposition table lookup. At PV nodes, we don't use the TT for
// pruning, but only for move ordering.
// Decide whether or not to include checks, this fixes also the type of
// TT entry depth that we are going to use. Note that in qsearch we use
// only two types of depth in TT: DEPTH_QS_CHECKS or DEPTH_QS_NO_CHECKS.
- ttDepth = inCheck || depth >= DEPTH_QS_CHECKS ? DEPTH_QS_CHECKS : DEPTH_QS_NO_CHECKS;
-
+ ttDepth = inCheck || depth >= DEPTH_QS_CHECKS ? DEPTH_QS_CHECKS
+ : DEPTH_QS_NO_CHECKS;
if ( tte && tte->depth() >= ttDepth
&& ( PvNode ? tte->type() == BOUND_EXACT
: ttValue >= beta ? (tte->type() & BOUND_LOWER)
: (tte->type() & BOUND_UPPER)))
{
+ assert(ttValue != VALUE_NONE); // Due to ttDepth > DEPTH_NONE
+
ss->currentMove = ttMove; // Can be MOVE_NONE
return ttValue;
}
if (bestValue >= beta)
{
if (!tte)
- TT.store(pos.key(), value_to_tt(bestValue, ss->ply), BOUND_LOWER, DEPTH_NONE, MOVE_NONE, ss->eval, ss->evalMargin);
+ TT.store(pos.key(), value_to_tt(bestValue, ss->ply), BOUND_LOWER,
+ DEPTH_NONE, MOVE_NONE, ss->eval, ss->evalMargin);
return bestValue;
}
Value value_to_tt(Value v, int ply) {
- if (v >= VALUE_MATE_IN_MAX_PLY)
- return v + ply;
+ assert(v != VALUE_NONE);
- if (v <= VALUE_MATED_IN_MAX_PLY)
- return v - ply;
-
- return v;
+ return v >= VALUE_MATE_IN_MAX_PLY ? v + ply
+ : v <= VALUE_MATED_IN_MAX_PLY ? v - ply : v;
}
Value value_from_tt(Value v, int ply) {
- if (v >= VALUE_MATE_IN_MAX_PLY)
- return v - ply;
-
- if (v <= VALUE_MATED_IN_MAX_PLY)
- return v + ply;
-
- return v;
+ return v == VALUE_NONE ? VALUE_NONE
+ : v >= VALUE_MATE_IN_MAX_PLY ? v - ply
+ : v <= VALUE_MATED_IN_MAX_PLY ? v + ply : v;
}
// refine_eval() returns the transposition table score if possible, otherwise
- // falls back on static position evaluation.
+ // falls back on static position evaluation. Note that we never return VALUE_NONE
+ // even if v == VALUE_NONE.
Value refine_eval(const TTEntry* tte, Value v, Value defaultEval) {
assert(tte);
+ assert(v != VALUE_NONE || !tte->type());
if ( ((tte->type() & BOUND_LOWER) && v >= defaultEval)
|| ((tte->type() & BOUND_UPPER) && v < defaultEval))