return Value((175 - 50 * improving) * d / ONE_PLY);
}
- // Margin for pruning capturing moves: almost linear in depth
- constexpr int CapturePruneMargin[] = { 0,
- 1 * PawnValueEg * 1055 / 1000,
- 2 * PawnValueEg * 1042 / 1000,
- 3 * PawnValueEg * 963 / 1000,
- 4 * PawnValueEg * 1038 / 1000,
- 5 * PawnValueEg * 950 / 1000,
- 6 * PawnValueEg * 930 / 1000
- };
-
// Futility and reductions lookup tables, initialized at startup
int FutilityMoveCounts[2][16]; // [improving][depth]
int Reductions[2][2][64][64]; // [pv][improving][depth][moveNumber]
if (idx > 0)
{
int i = (idx - 1) % 20;
- if (((rootDepth / ONE_PLY + rootPos.game_ply() + SkipPhase[i]) / SkipSize[i]) % 2)
+ if (((rootDepth / ONE_PLY + SkipPhase[i]) / SkipSize[i]) % 2)
continue; // Retry with an incremented rootDepth
}
{
tte->save(posKey, value_to_tt(value, ss->ply), b,
std::min(DEPTH_MAX - ONE_PLY, depth + 6 * ONE_PLY),
- MOVE_NONE, VALUE_NONE, TT.generation());
+ MOVE_NONE, VALUE_NONE);
return value;
}
: -(ss-1)->staticEval + 2 * Eval::Tempo;
tte->save(posKey, VALUE_NONE, BOUND_NONE, DEPTH_NONE, MOVE_NONE,
- ss->staticEval, TT.generation());
+ ss->staticEval);
}
// Step 7. Razoring (~2 Elo)
continue;
// Prune moves with negative SEE (~10 Elo)
- if ( lmrDepth < 8
- && !pos.see_ge(move, Value(-35 * lmrDepth * lmrDepth)))
+ if (!pos.see_ge(move, Value(-29 * lmrDepth * lmrDepth)))
continue;
}
- else if ( depth < 7 * ONE_PLY // (~20 Elo)
- && !extension
- && !pos.see_ge(move, -Value(CapturePruneMargin[depth / ONE_PLY])))
+ else if ( !extension // (~20 Elo)
+ && !pos.see_ge(move, -PawnValueEg * (depth / ONE_PLY)))
continue;
}
if (!pos.capture_or_promotion(bestMove))
update_quiet_stats(pos, ss, bestMove, quietsSearched, quietCount,
stat_bonus(depth + (bestValue > beta + PawnValueMg ? ONE_PLY : DEPTH_ZERO)));
- else
- update_capture_stats(pos, bestMove, capturesSearched, captureCount, stat_bonus(depth + ONE_PLY));
+
+ update_capture_stats(pos, bestMove, capturesSearched, captureCount, stat_bonus(depth + ONE_PLY));
// Extra penalty for a quiet TT move in previous ply when it gets refuted
if ((ss-1)->moveCount == 1 && !pos.captured_piece())
tte->save(posKey, value_to_tt(bestValue, ss->ply),
bestValue >= beta ? BOUND_LOWER :
PvNode && bestMove ? BOUND_EXACT : BOUND_UPPER,
- depth, bestMove, ss->staticEval, TT.generation());
+ depth, bestMove, ss->staticEval);
assert(bestValue > -VALUE_INFINITE && bestValue < VALUE_INFINITE);
&& ttHit
&& tte->depth() >= ttDepth
&& ttValue != VALUE_NONE // Only in case of TT access race
- && (ttValue >= beta ? (tte->bound() & BOUND_LOWER)
- : (tte->bound() & BOUND_UPPER)))
+ && (ttValue >= beta ? (tte->bound() & BOUND_LOWER)
+ : (tte->bound() & BOUND_UPPER)))
return ttValue;
// Evaluate the position statically
ss->staticEval = bestValue = evaluate(pos);
// Can ttValue be used as a better position evaluation?
- if ( ttValue != VALUE_NONE
+ if ( ttValue != VALUE_NONE
&& (tte->bound() & (ttValue > bestValue ? BOUND_LOWER : BOUND_UPPER)))
bestValue = ttValue;
}
{
if (!ttHit)
tte->save(posKey, value_to_tt(bestValue, ss->ply), BOUND_LOWER,
- DEPTH_NONE, MOVE_NONE, ss->staticEval, TT.generation());
+ DEPTH_NONE, MOVE_NONE, ss->staticEval);
return bestValue;
}
else // Fail high
{
tte->save(posKey, value_to_tt(value, ss->ply), BOUND_LOWER,
- ttDepth, move, ss->staticEval, TT.generation());
+ ttDepth, move, ss->staticEval);
return value;
}
tte->save(posKey, value_to_tt(bestValue, ss->ply),
PvNode && bestValue > oldAlpha ? BOUND_EXACT : BOUND_UPPER,
- ttDepth, bestMove, ss->staticEval, TT.generation());
+ ttDepth, bestMove, ss->staticEval);
assert(bestValue > -VALUE_INFINITE && bestValue < VALUE_INFINITE);
CapturePieceToHistory& captureHistory = pos.this_thread()->captureHistory;
Piece moved_piece = pos.moved_piece(move);
PieceType captured = type_of(pos.piece_on(to_sq(move)));
- captureHistory[moved_piece][to_sq(move)][captured] << bonus;
+
+ if (pos.capture_or_promotion(move))
+ captureHistory[moved_piece][to_sq(move)][captured] << bonus;
// Decrease all the other played capture moves
for (int i = 0; i < captureCnt; ++i)