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];
+ Value DrawValue[COLOR_NB];
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();
+ RootColor = pos.side_to_move();
TimeMgr.init(Limits, pos.startpos_ply_counter(), pos.side_to_move());
TT.new_search();
H.clear();
{
int cf = Options["Contempt Factor"] * PawnValueMg / 100; // In centipawns
cf = cf * MaterialTable::game_phase(pos) / PHASE_MIDGAME; // Scale down with phase
- DrawValue[ Eval::RootColor] = VALUE_DRAW - Value(cf);
- DrawValue[~Eval::RootColor] = VALUE_DRAW + Value(cf);
+ DrawValue[ RootColor] = VALUE_DRAW - Value(cf);
+ DrawValue[~RootColor] = VALUE_DRAW + Value(cf);
}
else
DrawValue[WHITE] = DrawValue[BLACK] = VALUE_DRAW;
: 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);
&& 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)
: 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;
}
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))