LimitsType Limits;
std::vector<RootMove> RootMoves;
Position RootPosition;
+ Color RootColor;
Time::point SearchTime;
StateStackPtr SetupStates;
}
size_t MultiPV, UCIMultiPV, PVIdx;
TimeManager TimeMgr;
int BestMoveChanges;
- int SkillLevel;
- bool SkillLevelEnabled, Chess960;
+ bool Chess960;
+ Value DrawValue[COLOR_NB];
History H;
template <NodeType NT>
bool connected_moves(const Position& pos, Move m1, Move m2);
Value value_to_tt(Value v, int ply);
Value value_from_tt(Value v, int ply);
- bool can_return_tt(const TTEntry* tte, Depth depth, Value ttValue, Value beta);
bool connected_threat(const Position& pos, Move m, Move threat);
- Value refine_eval(const TTEntry* tte, Value ttValue, Value defaultEval);
- Move do_skill_level();
string uci_pv(const Position& pos, int depth, Value alpha, Value beta);
+ struct Skill {
+ Skill(int l) : level(l), best(MOVE_NONE) {}
+ ~Skill() {
+ if (enabled()) // Swap best PV line with the sub-optimal one
+ std::swap(RootMoves[0], *std::find(RootMoves.begin(),
+ RootMoves.end(), best ? best : pick_move()));
+ }
+
+ bool enabled() const { return level < 20; }
+ bool time_to_pick(int depth) const { return depth == 1 + level; }
+ Move pick_move();
+
+ int level;
+ Move best;
+ };
+
} // namespace
// 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();
- Eval::ValueDraw[ Eval::RootColor] = VALUE_DRAW - Eval::ContemptFactor;
- Eval::ValueDraw[~Eval::RootColor] = VALUE_DRAW + Eval::ContemptFactor;
+ 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"]);
}
}
- UCIMultiPV = Options["MultiPV"];
- SkillLevel = Options["Skill Level"];
-
- // Do we have to play with skill handicap? In this case enable MultiPV that
- // we will use behind the scenes to retrieve a set of possible moves.
- SkillLevelEnabled = (SkillLevel < 20);
- MultiPV = (SkillLevelEnabled ? std::max(UCIMultiPV, (size_t)4) : UCIMultiPV);
-
if (Options["Use Search Log"])
{
Log log(Options["Search Log Filename"]);
int depth, prevBestMoveChanges;
Value bestValue, alpha, beta, delta;
bool bestMoveNeverChanged = true;
- Move skillBest = MOVE_NONE;
memset(ss, 0, 4 * sizeof(Stack));
depth = BestMoveChanges = 0;
bestValue = delta = -VALUE_INFINITE;
ss->currentMove = MOVE_NULL; // Hack to skip update gains
+ UCIMultiPV = Options["MultiPV"];
+ Skill skill(Options["Skill Level"]);
+
+ // Do we have to play with skill handicap? In this case enable MultiPV that
+ // we will use behind the scenes to retrieve a set of possible moves.
+ MultiPV = skill.enabled() ? std::max(UCIMultiPV, (size_t)4) : UCIMultiPV;
+
// Iterative deepening loop until requested to stop or target depth reached
- while (!Signals.stop && ++depth <= MAX_PLY && (!Limits.depth || depth <= Limits.depth))
+ while (++depth <= MAX_PLY && !Signals.stop && (!Limits.depth || depth <= Limits.depth))
{
// Save last iteration's scores before first PV line is searched and all
// the move scores but the (new) PV are set to -VALUE_INFINITE.
// the already searched PV lines are preserved.
sort<RootMove>(RootMoves.begin() + PVIdx, RootMoves.end());
- // In case we have found an exact score and we are going to leave
- // the fail high/low loop then reorder the PV moves, otherwise
- // leave the last PV move in its position so to be searched again.
- // Of course this is needed only in MultiPV search.
- if (PVIdx && bestValue > alpha && bestValue < beta)
- sort<RootMove>(RootMoves.begin(), RootMoves.begin() + PVIdx);
-
// Write PV back to transposition table in case the relevant
// entries have been overwritten during the search.
for (size_t i = 0; i <= PVIdx; i++)
RootMoves[i].insert_pv_in_tt(pos);
- // If search has been stopped exit the aspiration window loop.
- // Sorting and writing PV back to TT is safe becuase RootMoves
- // is still valid, although refers to previous iteration.
+ // If search has been stopped return immediately. Sorting and
+ // writing PV back to TT is safe becuase RootMoves is still
+ // valid, although refers to previous iteration.
if (Signals.stop)
+ return;
+
+ // In case of failing high/low increase aspiration window and
+ // research, otherwise exit the loop.
+ if (bestValue > alpha && bestValue < beta)
break;
- // Send full PV info to GUI if we are going to leave the loop or
- // if we have a fail high/low and we are deep in the search.
- if ((bestValue > alpha && bestValue < beta) || Time::now() - SearchTime > 2000)
+ // Give some update (without cluttering the UI) before to research
+ if (Time::now() - SearchTime > 3000)
sync_cout << uci_pv(pos, depth, alpha, beta) << sync_endl;
- // In case of failing high/low increase aspiration window and
- // research, otherwise exit the fail high/low loop.
- if (bestValue >= beta)
+ if (abs(bestValue) >= VALUE_KNOWN_WIN)
+ {
+ alpha = -VALUE_INFINITE;
+ beta = VALUE_INFINITE;
+ }
+ else if (bestValue >= beta)
{
beta += delta;
delta += delta / 2;
}
- else if (bestValue <= alpha)
+ else
{
Signals.failedLowAtRoot = true;
Signals.stopOnPonderhit = false;
alpha -= delta;
delta += delta / 2;
}
- else
- break;
-
- // Search with full window in case we have a win/mate score
- if (abs(bestValue) >= VALUE_KNOWN_WIN)
- {
- alpha = -VALUE_INFINITE;
- beta = VALUE_INFINITE;
- }
assert(alpha >= -VALUE_INFINITE && beta <= VALUE_INFINITE);
}
+
+ // Sort the PV lines searched so far and update the GUI
+ sort<RootMove>(RootMoves.begin(), RootMoves.begin() + PVIdx);
+ sync_cout << uci_pv(pos, depth, alpha, beta) << sync_endl;
}
- // Skills: Do we need to pick now the best move ?
- if (SkillLevelEnabled && depth == 1 + SkillLevel)
- skillBest = do_skill_level();
+ // Do we need to pick now the sub-optimal best move ?
+ if (skill.enabled() && skill.time_to_pick(depth))
+ skill.pick_move();
- if (!Signals.stop && Options["Use Search Log"])
+ if (Options["Use Search Log"])
{
Log log(Options["Search Log Filename"]);
log << pretty_pv(pos, depth, bestValue, Time::now() - SearchTime, &RootMoves[0].pv[0])
bestMoveNeverChanged = false;
// Do we have time for the next iteration? Can we stop searching now?
- if (!Signals.stop && !Signals.stopOnPonderhit && Limits.use_time_management())
+ if (Limits.use_time_management() && !Signals.stopOnPonderhit)
{
bool stop = false; // Local variable, not the volatile Signals.stop
}
}
}
-
- // When using skills swap best PV line with the sub-optimal one
- if (SkillLevelEnabled)
- {
- if (skillBest == MOVE_NONE) // Still unassigned ?
- skillBest = do_skill_level();
-
- std::swap(RootMoves[0], *std::find(RootMoves.begin(), RootMoves.end(), skillBest));
- }
}
Move ttMove, move, excludedMove, bestMove, threatMove;
Depth ext, newDepth;
Value bestValue, value, ttValue;
- Value refinedValue, nullValue, futilityValue;
+ Value eval, nullValue, futilityValue;
bool inCheck, givesCheck, pvMove, singularExtensionNode;
bool captureOrPromotion, dangerous, doFullDepthSearch;
int moveCount, playedMoveCount;
{
// 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
// a fail high/low. Biggest advantage at probing at PV nodes is to have a
// smooth experience in analysis mode. We don't probe at Root nodes otherwise
// we should also update RootMoveList to avoid bogus output.
- if (!RootNode && tte && (PvNode ? tte->depth() >= depth && tte->type() == BOUND_EXACT
- : can_return_tt(tte, depth, ttValue, beta)))
+ if ( !RootNode
+ && tte && tte->depth() >= depth
+ && ( PvNode ? tte->type() == BOUND_EXACT
+ : 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;
+ ss->staticEval = ss->evalMargin = eval = VALUE_NONE;
+
else if (tte)
{
assert(tte->static_value() != VALUE_NONE);
+ assert(ttValue != VALUE_NONE || tte->type() == BOUND_NONE);
- ss->eval = tte->static_value();
+ ss->staticEval = eval = tte->static_value();
ss->evalMargin = tte->static_value_margin();
- refinedValue = refine_eval(tte, ttValue, ss->eval);
+
+ // Can ttValue be used as a better position evaluation?
+ if ( ((tte->type() & BOUND_LOWER) && ttValue > eval)
+ || ((tte->type() & BOUND_UPPER) && ttValue < eval))
+ eval = ttValue;
}
else
{
- refinedValue = ss->eval = evaluate(pos, ss->evalMargin);
- TT.store(posKey, VALUE_NONE, BOUND_NONE, DEPTH_NONE, MOVE_NONE, ss->eval, ss->evalMargin);
+ eval = ss->staticEval = evaluate(pos, ss->evalMargin);
+ TT.store(posKey, VALUE_NONE, BOUND_NONE, DEPTH_NONE, MOVE_NONE,
+ ss->staticEval, ss->evalMargin);
}
// Update gain for the parent non-capture move given the static position
// evaluation before and after the move.
- if ( (move = (ss-1)->currentMove) != MOVE_NULL
- && (ss-1)->eval != VALUE_NONE
- && ss->eval != VALUE_NONE
+ if ( (move = (ss-1)->currentMove) != MOVE_NULL
+ && (ss-1)->staticEval != VALUE_NONE
+ && ss->staticEval != VALUE_NONE
&& !pos.captured_piece_type()
&& type_of(move) == NORMAL)
{
Square to = to_sq(move);
- H.update_gain(pos.piece_on(to), to, -(ss-1)->eval - ss->eval);
+ H.update_gain(pos.piece_on(to), to, -(ss-1)->staticEval - ss->staticEval);
}
// Step 6. Razoring (is omitted in PV nodes)
if ( !PvNode
&& depth < 4 * ONE_PLY
&& !inCheck
- && refinedValue + razor_margin(depth) < beta
+ && eval + razor_margin(depth) < beta
&& ttMove == MOVE_NONE
&& abs(beta) < VALUE_MATE_IN_MAX_PLY
&& !pos.pawn_on_7th(pos.side_to_move()))
&& !ss->skipNullMove
&& depth < 4 * ONE_PLY
&& !inCheck
- && refinedValue - FutilityMargins[depth][0] >= beta
+ && eval - FutilityMargins[depth][0] >= beta
&& abs(beta) < VALUE_MATE_IN_MAX_PLY
&& pos.non_pawn_material(pos.side_to_move()))
- return refinedValue - FutilityMargins[depth][0];
+ return eval - FutilityMargins[depth][0];
// Step 8. Null move search with verification search (is omitted in PV nodes)
if ( !PvNode
&& !ss->skipNullMove
&& depth > ONE_PLY
&& !inCheck
- && refinedValue >= beta
+ && eval >= beta
&& abs(beta) < VALUE_MATE_IN_MAX_PLY
&& pos.non_pawn_material(pos.side_to_move()))
{
Depth R = 3 * ONE_PLY + depth / 4;
// Null move dynamic reduction based on value
- if (refinedValue - PawnValueMg > beta)
+ if (eval - PawnValueMg > beta)
R += ONE_PLY;
pos.do_null_move<true>(st);
// Step 10. Internal iterative deepening
if ( depth >= (PvNode ? 5 * ONE_PLY : 8 * ONE_PLY)
&& ttMove == MOVE_NONE
- && (PvNode || (!inCheck && ss->eval + Value(256) >= beta)))
+ && (PvNode || (!inCheck && ss->staticEval + Value(256) >= beta)))
{
Depth d = (PvNode ? depth - 2 * ONE_PLY : depth / 2);
&& type_of(pos.piece_on(to_sq(move))) != PAWN
&& type_of(move) == NORMAL
&& ( pos.non_pawn_material(WHITE) + pos.non_pawn_material(BLACK)
- - PieceValue[Mg][pos.piece_on(to_sq(move))] == VALUE_ZERO));
+ - PieceValue[MG][pos.piece_on(to_sq(move))] == VALUE_ZERO));
// Step 12. Extend checks and, in PV nodes, also dangerous moves
if (PvNode && dangerous)
// on all the other moves but the ttMove, if result is lower than ttValue minus
// a margin then we extend ttMove.
if ( singularExtensionNode
- && !ext
&& move == ttMove
+ && !ext
&& 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;
&& !inCheck
&& !dangerous
&& move != ttMove
- && (bestValue > VALUE_MATED_IN_MAX_PLY || bestValue == -VALUE_INFINITE))
+ && (bestValue > VALUE_MATED_IN_MAX_PLY || ( bestValue == -VALUE_INFINITE
+ && alpha > VALUE_MATED_IN_MAX_PLY)))
{
// Move count based pruning
if ( depth < 16 * ONE_PLY
// We illogically ignore reduction condition depth >= 3*ONE_PLY for predicted depth,
// but fixing this made program slightly weaker.
Depth predictedDepth = newDepth - reduction<PvNode>(depth, moveCount);
- futilityValue = ss->eval + ss->evalMargin + futility_margin(predictedDepth, moveCount)
+ futilityValue = ss->staticEval + ss->evalMargin + futility_margin(predictedDepth, moveCount)
+ H.gain(pos.piece_moved(move), to_sq(move));
if (futilityValue < beta)
// 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)
if (bestValue >= beta) // Failed high
{
TT.store(posKey, value_to_tt(bestValue, ss->ply), BOUND_LOWER, depth,
- bestMove, ss->eval, ss->evalMargin);
+ bestMove, ss->staticEval, ss->evalMargin);
if (!pos.is_capture_or_promotion(bestMove) && !inCheck)
{
else // Failed low or PV search
TT.store(posKey, value_to_tt(bestValue, ss->ply),
PvNode && bestMove != MOVE_NONE ? BOUND_EXACT : BOUND_UPPER,
- depth, bestMove, ss->eval, ss->evalMargin);
+ depth, bestMove, ss->staticEval, ss->evalMargin);
assert(bestValue > -VALUE_INFINITE && 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;
-
- if (!PvNode && tte && can_return_tt(tte, ttDepth, ttValue, beta))
+ 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;
}
// Evaluate the position statically
if (inCheck)
{
- ss->eval = ss->evalMargin = VALUE_NONE;
+ ss->staticEval = ss->evalMargin = VALUE_NONE;
bestValue = futilityBase = -VALUE_INFINITE;
enoughMaterial = false;
}
{
assert(tte->static_value() != VALUE_NONE);
- ss->eval = bestValue = tte->static_value();
+ ss->staticEval = bestValue = tte->static_value();
ss->evalMargin = tte->static_value_margin();
}
else
- ss->eval = bestValue = evaluate(pos, ss->evalMargin);
+ ss->staticEval = bestValue = evaluate(pos, ss->evalMargin);
// Stand pat. Return immediately if static value is at least beta
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->staticEval, ss->evalMargin);
return bestValue;
}
if (PvNode && bestValue > alpha)
alpha = bestValue;
- futilityBase = ss->eval + ss->evalMargin + Value(128);
+ futilityBase = ss->staticEval + ss->evalMargin + Value(128);
enoughMaterial = pos.non_pawn_material(pos.side_to_move()) > RookValueMg;
}
&& !pos.is_passed_pawn_push(move))
{
futilityValue = futilityBase
- + PieceValue[Eg][pos.piece_on(to_sq(move))]
+ + PieceValue[EG][pos.piece_on(to_sq(move))]
+ (type_of(move) == ENPASSANT ? PawnValueEg : VALUE_ZERO);
if (futilityValue < beta)
&& givesCheck
&& move != ttMove
&& !pos.is_capture_or_promotion(move)
- && ss->eval + PawnValueMg / 4 < beta
+ && ss->staticEval + PawnValueMg / 4 < beta
&& !check_is_dangerous(pos, move, futilityBase, beta))
continue;
else // Fail high
{
TT.store(posKey, value_to_tt(value, ss->ply), BOUND_LOWER,
- ttDepth, move, ss->eval, ss->evalMargin);
+ ttDepth, move, ss->staticEval, ss->evalMargin);
return value;
}
TT.store(posKey, value_to_tt(bestValue, ss->ply),
PvNode && bestMove != MOVE_NONE ? BOUND_EXACT : BOUND_UPPER,
- ttDepth, bestMove, ss->eval, ss->evalMargin);
+ ttDepth, bestMove, ss->staticEval, ss->evalMargin);
assert(bestValue > -VALUE_INFINITE && bestValue < VALUE_INFINITE);
while (b)
{
// Note that here we generate illegal "double move"!
- if (futilityBase + PieceValue[Eg][pos.piece_on(pop_lsb(&b))] >= beta)
+ if (futilityBase + PieceValue[EG][pos.piece_on(pop_lsb(&b))] >= beta)
return true;
}
Value value_to_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;
+ assert(v != VALUE_NONE);
- 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;
}
// Case 2: If the threatened piece has value less than or equal to the
// value of the threatening piece, don't prune moves which defend it.
if ( pos.is_capture(threat)
- && ( PieceValue[Mg][pos.piece_on(tfrom)] >= PieceValue[Mg][pos.piece_on(tto)]
+ && ( PieceValue[MG][pos.piece_on(tfrom)] >= PieceValue[MG][pos.piece_on(tto)]
|| type_of(pos.piece_on(tfrom)) == KING)
&& pos.move_attacks_square(m, tto))
return true;
}
- // can_return_tt() returns true if a transposition table score can be used to
- // cut-off at a given point in search.
-
- bool can_return_tt(const TTEntry* tte, Depth depth, Value v, Value beta) {
-
- return ( tte->depth() >= depth
- || v >= std::max(VALUE_MATE_IN_MAX_PLY, beta)
- || v < std::min(VALUE_MATED_IN_MAX_PLY, beta))
-
- && ( ((tte->type() & BOUND_LOWER) && v >= beta)
- || ((tte->type() & BOUND_UPPER) && v < beta));
- }
-
-
- // refine_eval() returns the transposition table score if possible, otherwise
- // falls back on static position evaluation.
-
- Value refine_eval(const TTEntry* tte, Value v, Value defaultEval) {
-
- assert(tte);
-
- if ( ((tte->type() & BOUND_LOWER) && v >= defaultEval)
- || ((tte->type() & BOUND_UPPER) && v < defaultEval))
- return v;
-
- return defaultEval;
- }
-
-
// When playing with strength handicap choose best move among the MultiPV set
- // using a statistical rule dependent on SkillLevel. Idea by Heinz van Saanen.
+ // using a statistical rule dependent on 'level'. Idea by Heinz van Saanen.
- Move do_skill_level() {
+ Move Skill::pick_move() {
assert(MultiPV > 1);
// RootMoves are already sorted by score in descending order
size_t size = std::min(MultiPV, RootMoves.size());
int variance = std::min(RootMoves[0].score - RootMoves[size - 1].score, PawnValueMg);
- int weakness = 120 - 2 * SkillLevel;
+ int weakness = 120 - 2 * level;
int max_s = -VALUE_INFINITE;
- Move best = MOVE_NONE;
+ best = MOVE_NONE;
// Choose best move. For each move score we add two terms both dependent on
// weakness, one deterministic and bigger for weaker moves, and one random,
projects / stockfish / blobdiff