LimitsType Limits;
std::vector<RootMove> RootMoves;
Position RootPos;
- Color RootColor;
Time::point SearchTime;
StateStackPtr SetupStates;
}
void Search::think() {
- RootColor = RootPos.side_to_move();
- TimeMgr.init(Limits, RootPos.game_ply(), RootColor);
+ TimeMgr.init(Limits, RootPos.game_ply(), RootPos.side_to_move());
int cf = Options["Contempt Factor"] * PawnValueEg / 100; // From centipawns
- DrawValue[ RootColor] = VALUE_DRAW - Value(cf);
- DrawValue[~RootColor] = VALUE_DRAW + Value(cf);
+ DrawValue[ RootPos.side_to_move()] = VALUE_DRAW - Value(cf);
+ DrawValue[~RootPos.side_to_move()] = VALUE_DRAW + Value(cf);
if (RootMoves.empty())
{
log << "\nSearching: " << RootPos.fen()
<< "\ninfinite: " << Limits.infinite
<< " ponder: " << Limits.ponder
- << " time: " << Limits.time[RootColor]
- << " increment: " << Limits.inc[RootColor]
+ << " time: " << Limits.time[RootPos.side_to_move()]
+ << " increment: " << Limits.inc[RootPos.side_to_move()]
<< " moves to go: " << Limits.movestogo
<< "\n" << std::endl;
}
Value bestValue, alpha, beta, delta;
std::memset(ss-2, 0, 5 * sizeof(Stack));
- (ss-1)->currentMove = MOVE_NULL; // Hack to skip update gains
depth = 0;
BestMoveChanges = 0;
}
else
{
- eval = ss->staticEval = evaluate(pos);
+ eval = ss->staticEval =
+ (ss-1)->currentMove != MOVE_NULL ? evaluate(pos) : -(ss-1)->staticEval + 2 * Eval::Tempo;
+
TT.store(posKey, VALUE_NONE, BOUND_NONE, DEPTH_NONE, MOVE_NONE, ss->staticEval);
}
&& ss->staticEval != VALUE_NONE
&& (ss-1)->staticEval != VALUE_NONE
&& (move = (ss-1)->currentMove) != MOVE_NULL
+ && move != MOVE_NONE
&& type_of(move) == NORMAL)
{
Square to = to_sq(move);
&& depth < 4 * ONE_PLY
&& eval + razor_margin(depth) <= alpha
&& ttMove == MOVE_NONE
- && abs(beta) < VALUE_MATE_IN_MAX_PLY
&& !pos.pawn_on_7th(pos.side_to_move()))
{
if ( depth <= ONE_PLY
&& !ss->skipNullMove
&& depth >= 2 * ONE_PLY
&& eval >= beta
- && abs(beta) < VALUE_MATE_IN_MAX_PLY
&& pos.non_pawn_material(pos.side_to_move()))
{
ss->currentMove = MOVE_NULL;
// Null move dynamic reduction based on depth and value
Depth R = 3 * ONE_PLY
+ depth / 4
- + int(eval - beta) / PawnValueMg * ONE_PLY;
+ + (abs(beta) < VALUE_KNOWN_WIN ? int(eval - beta) / PawnValueMg * ONE_PLY
+ : DEPTH_ZERO);
pos.do_null_move(st);
(ss+1)->skipNullMove = true;
if (nullValue >= VALUE_MATE_IN_MAX_PLY)
nullValue = beta;
- if (depth < 12 * ONE_PLY)
+ if (depth < 12 * ONE_PLY && abs(beta) < VALUE_KNOWN_WIN)
return nullValue;
// Do verification search at high depths
singularExtensionNode = !RootNode
&& !SpNode
&& depth >= 8 * ONE_PLY
+ && abs(beta) < VALUE_KNOWN_WIN
&& ttMove != MOVE_NONE
+ /* && ttValue != VALUE_NONE Already implicit in the next condition */
+ && abs(ttValue) < VALUE_KNOWN_WIN
&& !excludedMove // Recursive singular search is not allowed
&& (tte->bound() & BOUND_LOWER)
&& tte->depth() >= depth - 3 * ONE_PLY;
if ( singularExtensionNode
&& move == ttMove
&& !ext
- && pos.legal(move, ci.pinned)
- && abs(ttValue) < VALUE_KNOWN_WIN)
+ && pos.legal(move, ci.pinned))
{
- assert(ttValue != VALUE_NONE);
-
Value rBeta = ttValue - int(depth);
ss->excludedMove = move;
ss->skipNullMove = true;
// Decrease reduction for moves that escape a capture
if ( ss->reduction
+ && type_of(move) == NORMAL
&& type_of(pos.piece_on(to_sq(move))) != PAWN
- && pos.see_sign(make_move(to_sq(move), from_sq(move))) < 0)
+ && pos.see(make_move(to_sq(move), from_sq(move))) < 0)
ss->reduction = std::max(DEPTH_ZERO, ss->reduction - ONE_PLY);
Depth d = std::max(newDepth - ss->reduction, ONE_PLY);
bestValue = ttValue;
}
else
- ss->staticEval = bestValue = evaluate(pos);
+ ss->staticEval = bestValue =
+ (ss-1)->currentMove != MOVE_NULL ? evaluate(pos) : -(ss-1)->staticEval + 2 * Eval::Tempo;
// Stand pat. Return immediately if static value is at least beta
if (bestValue >= beta)