TimePoint moveOverhead = TimePoint(Options["Move Overhead"]);

TimePoint slowMover = TimePoint(Options["Slow Mover"]);

TimePoint npmsec = TimePoint(Options["nodestime"]);

// optScale is a percentage of available time to use for the current move.

// maxScale is a multiplier applied to optimumTime.

double optScale, maxScale;

// If we have to play in 'nodes as time' mode, then convert from time

// to nodes, and use resulting values in time management formulas.

// WARNING: to avoid time losses, the given npmsec (nodes per millisecond)

// must be much lower than the real engine speed.

if (npmsec)

{

if (!availableNodes) // Only once at game start

availableNodes = npmsec * limits.time[us]; // Time is in msec

// Convert from milliseconds to nodes

limits.time[us] = TimePoint(availableNodes);

limits.inc[us] *= npmsec;

limits.npmsec = npmsec;

}

startTime = limits.startTime;

// Maximum move horizon of 50 moves

int mtg = limits.movestogo ? std::min(limits.movestogo, 50) : 50;

// Make sure timeLeft is > 0 since we may use it as a divisor

TimePoint timeLeft = std::max(TimePoint(1),

limits.time[us] + limits.inc[us] * (mtg - 1) - moveOverhead * (2 + mtg));

// A user may scale time usage by setting UCI option "Slow Mover"

// Default is 100 and changing this value will probably lose elo.

timeLeft = slowMover * timeLeft / 100;

// x basetime (+ z increment)

// If there is a healthy increment, timeLeft can exceed actual available

// game time for the current move, so also cap to 20% of available game time.

if (limits.movestogo == 0)

{

optScale = std::min(0.008 + std::pow(ply + 3.0, 0.5) / 250.0,

0.2 * limits.time[us] / double(timeLeft));

maxScale = std::min(7.0, 4.0 + ply / 12.0);

}

// x moves in y seconds (+ z increment)

else

{

optScale = std::min((0.8 + ply / 128.0) / mtg,

0.8 * limits.time[us] / double(timeLeft));

maxScale = std::min(6.3, 1.5 + 0.11 * mtg);

}

// Never use more than 80% of the available time for this move

optimumTime = TimePoint(optScale * timeLeft);

maximumTime = TimePoint(std::min(0.8 * limits.time[us] - moveOverhead, maxScale * optimumTime));

if (Options["Ponder"])

optimumTime += optimumTime / 4;