mirror of
https://github.com/HChaZZY/Stockfish.git
synced 2025-12-25 19:46:55 +08:00
Merge branch 'master' of github.com:official-stockfish/Stockfish into nnue-player-merge-2020-08-28
# Conflicts: # README.md # src/Makefile # src/search.cpp # src/types.h # src/uci.cpp # src/ucioption.cpp
This commit is contained in:
nodchip
153
src/search.cpp
153
src/search.cpp
@@ -63,9 +63,9 @@ namespace {
|
||||
constexpr uint64_t TtHitAverageResolution = 1024;
|
||||
|
||||
// Razor and futility margins
|
||||
constexpr int RazorMargin = 527;
|
||||
constexpr int RazorMargin = 510;
|
||||
Value futility_margin(Depth d, bool improving) {
|
||||
return Value(227 * (d - improving));
|
||||
return Value(223 * (d - improving));
|
||||
}
|
||||
|
||||
bool training;
|
||||
@@ -75,7 +75,7 @@ namespace {
|
||||
|
||||
Depth reduction(bool i, Depth d, int mn) {
|
||||
int r = Reductions[d] * Reductions[mn];
|
||||
return (r + 570) / 1024 + (!i && r > 1018);
|
||||
return (r + 509) / 1024 + (!i && r > 894);
|
||||
}
|
||||
|
||||
constexpr int futility_move_count(bool improving, Depth depth) {
|
||||
@@ -84,7 +84,7 @@ namespace {
|
||||
|
||||
// History and stats update bonus, based on depth
|
||||
int stat_bonus(Depth d) {
|
||||
return d > 15 ? 27 : 17 * d * d + 133 * d - 134;
|
||||
return d > 13 ? 29 : 17 * d * d + 134 * d - 134;
|
||||
}
|
||||
|
||||
// Add a small random component to draw evaluations to avoid 3fold-blindness
|
||||
@@ -194,7 +194,7 @@ namespace {
|
||||
void Search::init() {
|
||||
|
||||
for (int i = 1; i < MAX_MOVES; ++i)
|
||||
Reductions[i] = int((24.8 + std::log(Threads.size())) * std::log(i));
|
||||
Reductions[i] = int((22.0 + std::log(Threads.size())) * std::log(i));
|
||||
|
||||
training = Options["Training"];
|
||||
}
|
||||
@@ -339,7 +339,7 @@ void Thread::search() {
|
||||
// for match (TC 60+0.6) results spanning a wide range of k values.
|
||||
PRNG rng(now());
|
||||
double floatLevel = Options["UCI_LimitStrength"] ?
|
||||
Utility::clamp(std::pow((Options["UCI_Elo"] - 1346.6) / 143.4, 1 / 0.806), 0.0, 20.0) :
|
||||
std::clamp(std::pow((Options["UCI_Elo"] - 1346.6) / 143.4, 1 / 0.806), 0.0, 20.0) :
|
||||
double(Options["Skill Level"]);
|
||||
int intLevel = int(floatLevel) +
|
||||
((floatLevel - int(floatLevel)) * 1024 > rng.rand<unsigned>() % 1024 ? 1 : 0);
|
||||
@@ -407,12 +407,12 @@ void Thread::search() {
|
||||
if (rootDepth >= 4)
|
||||
{
|
||||
Value prev = rootMoves[pvIdx].previousScore;
|
||||
delta = Value(19);
|
||||
delta = Value(17);
|
||||
alpha = std::max(prev - delta,-VALUE_INFINITE);
|
||||
beta = std::min(prev + delta, VALUE_INFINITE);
|
||||
|
||||
// Adjust contempt based on root move's previousScore (dynamic contempt)
|
||||
int dct = ct + (110 - ct / 2) * prev / (abs(prev) + 140);
|
||||
int dct = ct + (105 - ct / 2) * prev / (abs(prev) + 149);
|
||||
|
||||
contempt = (us == WHITE ? make_score(dct, dct / 2)
|
||||
: -make_score(dct, dct / 2));
|
||||
@@ -510,13 +510,13 @@ void Thread::search() {
|
||||
&& !Threads.stop
|
||||
&& !mainThread->stopOnPonderhit)
|
||||
{
|
||||
double fallingEval = (296 + 6 * (mainThread->bestPreviousScore - bestValue)
|
||||
+ 6 * (mainThread->iterValue[iterIdx] - bestValue)) / 725.0;
|
||||
fallingEval = Utility::clamp(fallingEval, 0.5, 1.5);
|
||||
double fallingEval = (318 + 6 * (mainThread->bestPreviousScore - bestValue)
|
||||
+ 6 * (mainThread->iterValue[iterIdx] - bestValue)) / 825.0;
|
||||
fallingEval = std::clamp(fallingEval, 0.5, 1.5);
|
||||
|
||||
// If the bestMove is stable over several iterations, reduce time accordingly
|
||||
timeReduction = lastBestMoveDepth + 10 < completedDepth ? 1.92 : 0.95;
|
||||
double reduction = (1.47 + mainThread->previousTimeReduction) / (2.22 * timeReduction);
|
||||
timeReduction = lastBestMoveDepth + 9 < completedDepth ? 1.92 : 0.95;
|
||||
double reduction = (1.47 + mainThread->previousTimeReduction) / (2.32 * timeReduction);
|
||||
|
||||
// Use part of the gained time from a previous stable move for the current move
|
||||
for (Thread* th : Threads)
|
||||
@@ -541,7 +541,7 @@ void Thread::search() {
|
||||
}
|
||||
else if ( Threads.increaseDepth
|
||||
&& !mainThread->ponder
|
||||
&& Time.elapsed() > totalTime * 0.56)
|
||||
&& Time.elapsed() > totalTime * 0.58)
|
||||
Threads.increaseDepth = false;
|
||||
else
|
||||
Threads.increaseDepth = true;
|
||||
@@ -600,7 +600,7 @@ namespace {
|
||||
Key posKey;
|
||||
Move ttMove, move, excludedMove, bestMove;
|
||||
Depth extension, newDepth;
|
||||
Value bestValue, value, ttValue, eval, maxValue, probcutBeta;
|
||||
Value bestValue, value, ttValue, eval, maxValue, probCutBeta;
|
||||
bool ttHit, ttPv, formerPv, givesCheck, improving, didLMR, priorCapture;
|
||||
bool captureOrPromotion, doFullDepthSearch, moveCountPruning,
|
||||
ttCapture, singularQuietLMR;
|
||||
@@ -798,11 +798,7 @@ namespace {
|
||||
else
|
||||
{
|
||||
if ((ss-1)->currentMove != MOVE_NULL)
|
||||
{
|
||||
int bonus = -(ss-1)->statScore / 512;
|
||||
|
||||
ss->staticEval = eval = evaluate(pos) + bonus;
|
||||
}
|
||||
ss->staticEval = eval = evaluate(pos);
|
||||
else
|
||||
ss->staticEval = eval = -(ss-1)->staticEval + 2 * Tempo;
|
||||
|
||||
@@ -815,8 +811,9 @@ namespace {
|
||||
&& eval <= alpha - RazorMargin)
|
||||
return qsearch<NT>(pos, ss, alpha, beta);
|
||||
|
||||
improving = (ss-2)->staticEval == VALUE_NONE ? (ss->staticEval > (ss-4)->staticEval
|
||||
|| (ss-4)->staticEval == VALUE_NONE) : ss->staticEval > (ss-2)->staticEval;
|
||||
improving = (ss-2)->staticEval == VALUE_NONE
|
||||
? ss->staticEval > (ss-4)->staticEval || (ss-4)->staticEval == VALUE_NONE
|
||||
: ss->staticEval > (ss-2)->staticEval;
|
||||
|
||||
// Step 8. Futility pruning: child node (~50 Elo)
|
||||
if ( !PvNode
|
||||
@@ -828,10 +825,10 @@ namespace {
|
||||
// Step 9. Null move search with verification search (~40 Elo)
|
||||
if ( !PvNode
|
||||
&& (ss-1)->currentMove != MOVE_NULL
|
||||
&& (ss-1)->statScore < 23824
|
||||
&& (ss-1)->statScore < 22977
|
||||
&& eval >= beta
|
||||
&& eval >= ss->staticEval
|
||||
&& ss->staticEval >= beta - 28 * depth - 28 * improving + 94 * ttPv + 200
|
||||
&& ss->staticEval >= beta - 30 * depth - 28 * improving + 84 * ttPv + 182
|
||||
&& !excludedMove
|
||||
&& pos.non_pawn_material(us)
|
||||
&& (ss->ply >= thisThread->nmpMinPly || us != thisThread->nmpColor))
|
||||
@@ -839,7 +836,7 @@ namespace {
|
||||
assert(eval - beta >= 0);
|
||||
|
||||
// Null move dynamic reduction based on depth and value
|
||||
Depth R = (737 + 77 * depth) / 246 + std::min(int(eval - beta) / 192, 3);
|
||||
Depth R = (817 + 71 * depth) / 213 + std::min(int(eval - beta) / 192, 3);
|
||||
|
||||
ss->currentMove = MOVE_NULL;
|
||||
ss->continuationHistory = &thisThread->continuationHistory[0][0][NO_PIECE][0];
|
||||
@@ -875,7 +872,7 @@ namespace {
|
||||
}
|
||||
}
|
||||
|
||||
probcutBeta = beta + 176 - 49 * improving;
|
||||
probCutBeta = beta + 176 - 49 * improving;
|
||||
|
||||
// Step 10. ProbCut (~10 Elo)
|
||||
// If we have a good enough capture and a reduced search returns a value
|
||||
@@ -883,21 +880,27 @@ namespace {
|
||||
if ( !PvNode
|
||||
&& depth > 4
|
||||
&& abs(beta) < VALUE_TB_WIN_IN_MAX_PLY
|
||||
// if value from transposition table is lower than probCutBeta, don't attempt probCut
|
||||
// there and in further interactions with transposition table cutoff depth is set to depth - 3
|
||||
// because probCut search has depth set to depth - 4 but we also do a move before it
|
||||
// so effective depth is equal to depth - 3
|
||||
&& !( ttHit
|
||||
&& tte->depth() >= depth - 3
|
||||
&& ttValue != VALUE_NONE
|
||||
&& ttValue < probcutBeta))
|
||||
&& ttValue < probCutBeta))
|
||||
{
|
||||
// if ttMove is a capture and value from transposition table is good enough produce probCut
|
||||
// cutoff without digging into actual probCut search
|
||||
if ( ttHit
|
||||
&& tte->depth() >= depth - 3
|
||||
&& ttValue != VALUE_NONE
|
||||
&& ttValue >= probcutBeta
|
||||
&& ttValue >= probCutBeta
|
||||
&& ttMove
|
||||
&& pos.capture_or_promotion(ttMove))
|
||||
return probcutBeta;
|
||||
return probCutBeta;
|
||||
|
||||
assert(probcutBeta < VALUE_INFINITE);
|
||||
MovePicker mp(pos, ttMove, probcutBeta - ss->staticEval, &captureHistory);
|
||||
assert(probCutBeta < VALUE_INFINITE);
|
||||
MovePicker mp(pos, ttMove, probCutBeta - ss->staticEval, &captureHistory);
|
||||
int probCutCount = 0;
|
||||
|
||||
while ( (move = mp.next_move()) != MOVE_NONE
|
||||
@@ -919,16 +922,17 @@ namespace {
|
||||
pos.do_move(move, st);
|
||||
|
||||
// Perform a preliminary qsearch to verify that the move holds
|
||||
value = -qsearch<NonPV>(pos, ss+1, -probcutBeta, -probcutBeta+1);
|
||||
value = -qsearch<NonPV>(pos, ss+1, -probCutBeta, -probCutBeta+1);
|
||||
|
||||
// If the qsearch held, perform the regular search
|
||||
if (value >= probcutBeta)
|
||||
value = -search<NonPV>(pos, ss+1, -probcutBeta, -probcutBeta+1, depth - 4, !cutNode);
|
||||
if (value >= probCutBeta)
|
||||
value = -search<NonPV>(pos, ss+1, -probCutBeta, -probCutBeta+1, depth - 4, !cutNode);
|
||||
|
||||
pos.undo_move(move);
|
||||
|
||||
if (value >= probcutBeta)
|
||||
if (value >= probCutBeta)
|
||||
{
|
||||
// if transposition table doesn't have equal or more deep info write probCut data into it
|
||||
if ( !(ttHit
|
||||
&& tte->depth() >= depth - 3
|
||||
&& ttValue != VALUE_NONE))
|
||||
@@ -940,16 +944,6 @@ namespace {
|
||||
}
|
||||
}
|
||||
|
||||
// Step 11. Internal iterative deepening (~1 Elo)
|
||||
if (depth >= 7 && !ttMove)
|
||||
{
|
||||
search<NT>(pos, ss, alpha, beta, depth - 7, cutNode);
|
||||
|
||||
tte = TT.probe(posKey, ttHit);
|
||||
ttValue = ttHit ? value_from_tt(tte->value(), ss->ply, pos.rule50_count()) : VALUE_NONE;
|
||||
ttMove = ttHit ? tte->move() : MOVE_NONE;
|
||||
}
|
||||
|
||||
moves_loop: // When in check, search starts from here
|
||||
|
||||
const PieceToHistory* contHist[] = { (ss-1)->continuationHistory, (ss-2)->continuationHistory,
|
||||
@@ -973,7 +967,7 @@ moves_loop: // When in check, search starts from here
|
||||
// Mark this node as being searched
|
||||
ThreadHolding th(thisThread, posKey, ss->ply);
|
||||
|
||||
// Step 12. Loop through all pseudo-legal moves until no moves remain
|
||||
// Step 11. Loop through all pseudo-legal moves until no moves remain
|
||||
// or a beta cutoff occurs.
|
||||
while ((move = mp.next_move(moveCountPruning)) != MOVE_NONE)
|
||||
{
|
||||
@@ -1015,7 +1009,7 @@ moves_loop: // When in check, search starts from here
|
||||
// Calculate new depth for this move
|
||||
newDepth = depth - 1;
|
||||
|
||||
// Step 13. Pruning at shallow depth (~200 Elo)
|
||||
// Step 12. Pruning at shallow depth (~200 Elo)
|
||||
if ( !rootNode
|
||||
&& !(training && PvNode)
|
||||
&& pos.non_pawn_material(us)
|
||||
@@ -1037,17 +1031,17 @@ moves_loop: // When in check, search starts from here
|
||||
continue;
|
||||
|
||||
// Futility pruning: parent node (~5 Elo)
|
||||
if ( lmrDepth < 8
|
||||
if ( lmrDepth < 7
|
||||
&& !ss->inCheck
|
||||
&& ss->staticEval + 284 + 188 * lmrDepth <= alpha
|
||||
&& ss->staticEval + 283 + 170 * lmrDepth <= alpha
|
||||
&& (*contHist[0])[movedPiece][to_sq(move)]
|
||||
+ (*contHist[1])[movedPiece][to_sq(move)]
|
||||
+ (*contHist[3])[movedPiece][to_sq(move)]
|
||||
+ (*contHist[5])[movedPiece][to_sq(move)] / 2 < 28388)
|
||||
+ (*contHist[5])[movedPiece][to_sq(move)] / 2 < 27376)
|
||||
continue;
|
||||
|
||||
// Prune moves with negative SEE (~20 Elo)
|
||||
if (!pos.see_ge(move, Value(-(29 - std::min(lmrDepth, 17)) * lmrDepth * lmrDepth)))
|
||||
if (!pos.see_ge(move, Value(-(29 - std::min(lmrDepth, 18)) * lmrDepth * lmrDepth)))
|
||||
continue;
|
||||
}
|
||||
else
|
||||
@@ -1064,17 +1058,17 @@ moves_loop: // When in check, search starts from here
|
||||
&& !(PvNode && abs(bestValue) < 2)
|
||||
&& PieceValue[MG][type_of(movedPiece)] >= PieceValue[MG][type_of(pos.piece_on(to_sq(move)))]
|
||||
&& !ss->inCheck
|
||||
&& ss->staticEval + 178 + 261 * lmrDepth
|
||||
&& ss->staticEval + 169 + 244 * lmrDepth
|
||||
+ PieceValue[MG][type_of(pos.piece_on(to_sq(move)))] <= alpha)
|
||||
continue;
|
||||
|
||||
// See based pruning
|
||||
if (!pos.see_ge(move, Value(-202) * depth)) // (~25 Elo)
|
||||
if (!pos.see_ge(move, Value(-221) * depth)) // (~25 Elo)
|
||||
continue;
|
||||
}
|
||||
}
|
||||
|
||||
// Step 14. Extensions (~75 Elo)
|
||||
// Step 13. Extensions (~75 Elo)
|
||||
|
||||
// Singular extension search (~70 Elo). If all moves but one fail low on a
|
||||
// search of (alpha-s, beta-s), and just one fails high on (alpha, beta),
|
||||
@@ -1128,19 +1122,14 @@ moves_loop: // When in check, search starts from here
|
||||
&& (pos.is_discovery_check_on_king(~us, move) || pos.see_ge(move)))
|
||||
extension = 1;
|
||||
|
||||
// Passed pawn extension
|
||||
else if ( move == ss->killers[0]
|
||||
&& pos.advanced_pawn_push(move)
|
||||
&& pos.pawn_passed(us, to_sq(move)))
|
||||
extension = 1;
|
||||
|
||||
// Last captures extension
|
||||
else if ( PieceValue[EG][pos.captured_piece()] > PawnValueEg
|
||||
&& pos.non_pawn_material() <= 2 * RookValueMg)
|
||||
extension = 1;
|
||||
|
||||
// Castling extension
|
||||
if (type_of(move) == CASTLING)
|
||||
if ( type_of(move) == CASTLING
|
||||
&& popcount(pos.pieces(us) & ~pos.pieces(PAWN) & (to_sq(move) & KingSide ? KingSide : QueenSide)) <= 2)
|
||||
extension = 1;
|
||||
|
||||
// Late irreversible move extension
|
||||
@@ -1162,10 +1151,10 @@ moves_loop: // When in check, search starts from here
|
||||
[movedPiece]
|
||||
[to_sq(move)];
|
||||
|
||||
// Step 15. Make the move
|
||||
// Step 14. Make the move
|
||||
pos.do_move(move, st, givesCheck);
|
||||
|
||||
// Step 16. Reduced depth search (LMR, ~200 Elo). If the move fails high it will be
|
||||
// Step 15. Reduced depth search (LMR, ~200 Elo). If the move fails high it will be
|
||||
// re-searched at full depth.
|
||||
if ( depth >= 3
|
||||
&& moveCount > 1 + 2 * rootNode + 2 * (PvNode && abs(bestValue) < 2)
|
||||
@@ -1174,7 +1163,7 @@ moves_loop: // When in check, search starts from here
|
||||
|| moveCountPruning
|
||||
|| ss->staticEval + PieceValue[EG][pos.captured_piece()] <= alpha
|
||||
|| cutNode
|
||||
|| thisThread->ttHitAverage < 415 * TtHitAverageResolution * TtHitAverageWindow / 1024))
|
||||
|| thisThread->ttHitAverage < 427 * TtHitAverageResolution * TtHitAverageWindow / 1024))
|
||||
{
|
||||
Depth r = reduction(improving, depth, moveCount);
|
||||
|
||||
@@ -1186,7 +1175,7 @@ moves_loop: // When in check, search starts from here
|
||||
r--;
|
||||
|
||||
// Decrease reduction if the ttHit running average is large
|
||||
if (thisThread->ttHitAverage > 473 * TtHitAverageResolution * TtHitAverageWindow / 1024)
|
||||
if (thisThread->ttHitAverage > 509 * TtHitAverageResolution * TtHitAverageWindow / 1024)
|
||||
r--;
|
||||
|
||||
// Reduction if other threads are searching this position
|
||||
@@ -1229,17 +1218,17 @@ moves_loop: // When in check, search starts from here
|
||||
+ (*contHist[0])[movedPiece][to_sq(move)]
|
||||
+ (*contHist[1])[movedPiece][to_sq(move)]
|
||||
+ (*contHist[3])[movedPiece][to_sq(move)]
|
||||
- 4826;
|
||||
- 5287;
|
||||
|
||||
// Decrease/increase reduction by comparing opponent's stat score (~10 Elo)
|
||||
if (ss->statScore >= -100 && (ss-1)->statScore < -112)
|
||||
if (ss->statScore >= -106 && (ss-1)->statScore < -104)
|
||||
r--;
|
||||
|
||||
else if ((ss-1)->statScore >= -125 && ss->statScore < -138)
|
||||
else if ((ss-1)->statScore >= -119 && ss->statScore < -140)
|
||||
r++;
|
||||
|
||||
// Decrease/increase reduction for moves with a good/bad history (~30 Elo)
|
||||
r -= ss->statScore / 14615;
|
||||
r -= ss->statScore / 14884;
|
||||
}
|
||||
else
|
||||
{
|
||||
@@ -1249,11 +1238,11 @@ moves_loop: // When in check, search starts from here
|
||||
|
||||
// Unless giving check, this capture is likely bad
|
||||
if ( !givesCheck
|
||||
&& ss->staticEval + PieceValue[EG][pos.captured_piece()] + 211 * depth <= alpha)
|
||||
&& ss->staticEval + PieceValue[EG][pos.captured_piece()] + 213 * depth <= alpha)
|
||||
r++;
|
||||
}
|
||||
|
||||
Depth d = Utility::clamp(newDepth - r, 1, newDepth);
|
||||
Depth d = std::clamp(newDepth - r, 1, newDepth);
|
||||
|
||||
value = -search<NonPV>(pos, ss+1, -(alpha+1), -alpha, d, true);
|
||||
|
||||
@@ -1268,7 +1257,7 @@ moves_loop: // When in check, search starts from here
|
||||
didLMR = false;
|
||||
}
|
||||
|
||||
// Step 17. Full depth search when LMR is skipped or fails high
|
||||
// Step 16. Full depth search when LMR is skipped or fails high
|
||||
if (doFullDepthSearch)
|
||||
{
|
||||
value = -search<NonPV>(pos, ss+1, -(alpha+1), -alpha, newDepth, !cutNode);
|
||||
@@ -1296,12 +1285,12 @@ moves_loop: // When in check, search starts from here
|
||||
value = -search<PV>(pos, ss+1, -beta, -alpha, newDepth, false);
|
||||
}
|
||||
|
||||
// Step 18. Undo move
|
||||
// Step 17. Undo move
|
||||
pos.undo_move(move);
|
||||
|
||||
assert(value > -VALUE_INFINITE && value < VALUE_INFINITE);
|
||||
|
||||
// Step 19. Check for a new best move
|
||||
// Step 18. Check for a new best move
|
||||
// Finished searching the move. If a stop occurred, the return value of
|
||||
// the search cannot be trusted, and we return immediately without
|
||||
// updating best move, PV and TT.
|
||||
@@ -1378,7 +1367,7 @@ moves_loop: // When in check, search starts from here
|
||||
return VALUE_DRAW;
|
||||
*/
|
||||
|
||||
// Step 20. Check for mate and stalemate
|
||||
// Step 19. Check for mate and stalemate
|
||||
// All legal moves have been searched and if there are no legal moves, it
|
||||
// must be a mate or a stalemate. If we are in a singular extension search then
|
||||
// return a fail low score.
|
||||
@@ -1511,7 +1500,7 @@ moves_loop: // When in check, search starts from here
|
||||
if (PvNode && bestValue > alpha)
|
||||
alpha = bestValue;
|
||||
|
||||
futilityBase = bestValue + 141;
|
||||
futilityBase = bestValue + 145;
|
||||
}
|
||||
|
||||
const PieceToHistory* contHist[] = { (ss-1)->continuationHistory, (ss-2)->continuationHistory,
|
||||
@@ -1545,6 +1534,10 @@ moves_loop: // When in check, search starts from here
|
||||
{
|
||||
assert(type_of(move) != ENPASSANT); // Due to !pos.advanced_pawn_push
|
||||
|
||||
// moveCount pruning
|
||||
if (moveCount > 2)
|
||||
continue;
|
||||
|
||||
futilityValue = futilityBase + PieceValue[EG][pos.piece_on(to_sq(move))];
|
||||
|
||||
if (futilityValue <= alpha)
|
||||
@@ -1586,6 +1579,12 @@ moves_loop: // When in check, search starts from here
|
||||
[pos.moved_piece(move)]
|
||||
[to_sq(move)];
|
||||
|
||||
if ( !captureOrPromotion
|
||||
&& moveCount >= abs(depth) + 1
|
||||
&& (*contHist[0])[pos.moved_piece(move)][to_sq(move)] < CounterMovePruneThreshold
|
||||
&& (*contHist[1])[pos.moved_piece(move)][to_sq(move)] < CounterMovePruneThreshold)
|
||||
continue;
|
||||
|
||||
// Make and search the move
|
||||
pos.do_move(move, st, givesCheck);
|
||||
value = -qsearch<NT>(pos, ss+1, -beta, -alpha, depth - 1);
|
||||
@@ -1768,7 +1767,7 @@ moves_loop: // When in check, search starts from here
|
||||
}
|
||||
|
||||
if (depth > 11 && ss->ply < MAX_LPH)
|
||||
thisThread->lowPlyHistory[ss->ply][from_to(move)] << stat_bonus(depth - 6);
|
||||
thisThread->lowPlyHistory[ss->ply][from_to(move)] << stat_bonus(depth - 7);
|
||||
}
|
||||
|
||||
// When playing with strength handicap, choose best move among a set of RootMoves
|
||||
|
||||
Reference in New Issue
Block a user