#include <iostream>
#include <sstream>
-#include "book.h"
#include "evaluate.h"
#include "movegen.h"
#include "movepick.h"
#include "notation.h"
+#include "rkiss.h"
#include "search.h"
#include "timeman.h"
#include "thread.h"
LimitsType Limits;
std::vector<RootMove> RootMoves;
Position RootPos;
- Color RootColor;
Time::point SearchTime;
StateStackPtr SetupStates;
}
return (Depth) Reductions[PvNode][i][std::min(int(d) / ONE_PLY, 63)][std::min(mn, 63)];
}
+ // Tempo bonus. Must be handled by search to preserve eval symmetry.
+ const int Tempo = 17;
+
size_t MultiPV, PVIdx;
TimeManager TimeMgr;
double BestMoveChanges;
void Search::think() {
- static PolyglotBook book; // Defined static to initialize the PRNG only once
-
- 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())
{
goto finalize;
}
- if (Options["OwnBook"] && !Limits.infinite && !Limits.mate)
- {
- Move bookMove = book.probe(RootPos, Options["Book File"], Options["Best Book Move"]);
-
- if (bookMove && std::count(RootMoves.begin(), RootMoves.end(), bookMove))
- {
- std::swap(RootMoves[0], *std::find(RootMoves.begin(), RootMoves.end(), bookMove));
- goto finalize;
- }
- }
-
if (Options["Write Search Log"])
{
Log log(Options["Search Log Filename"]);
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;
}
bestValue = -VALUE_INFINITE;
ss->currentMove = ss->ttMove = (ss+1)->excludedMove = bestMove = MOVE_NONE;
ss->ply = (ss-1)->ply + 1;
- (ss+1)->skipNullMove = false; (ss+1)->reduction = DEPTH_ZERO;
+ (ss+1)->skipNullMove = (ss+1)->nullChild = false; (ss+1)->reduction = DEPTH_ZERO;
(ss+2)->killers[0] = (ss+2)->killers[1] = MOVE_NONE;
// Used to send selDepth info to GUI
{
// Step 2. Check for aborted search and immediate draw
if (Signals.stop || pos.is_draw() || ss->ply > MAX_PLY)
- return ss->ply > MAX_PLY && !inCheck ? evaluate(pos) : DrawValue[pos.side_to_move()];
+ return ss->ply > MAX_PLY && !inCheck ? evaluate(pos) + Tempo : 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
{
// Never assume anything on values stored in TT
if ((ss->staticEval = eval = tte->eval_value()) == VALUE_NONE)
- eval = ss->staticEval = evaluate(pos);
+ eval = ss->staticEval = evaluate(pos) + Tempo;
// Can ttValue be used as a better position evaluation?
if (ttValue != VALUE_NONE)
}
else
{
- eval = ss->staticEval = evaluate(pos);
+ eval = ss->staticEval = ss->nullChild ? -(ss-1)->staticEval + 2 * Tempo : evaluate(pos) + Tempo;
TT.store(posKey, VALUE_NONE, BOUND_NONE, DEPTH_NONE, MOVE_NONE, ss->staticEval);
}
+ int(eval - beta) / PawnValueMg * ONE_PLY;
pos.do_null_move(st);
- (ss+1)->skipNullMove = true;
+ (ss+1)->skipNullMove = (ss+1)->nullChild = true;
nullValue = depth-R < ONE_PLY ? -qsearch<NonPV, false>(pos, ss+1, -beta, -beta+1, DEPTH_ZERO)
: - search<NonPV, false>(pos, ss+1, -beta, -beta+1, depth-R, !cutNode);
- (ss+1)->skipNullMove = false;
+ (ss+1)->skipNullMove = (ss+1)->nullChild = false;
pos.undo_null_move();
if (nullValue >= beta)
if (move == countermoves[0] || move == countermoves[1])
ss->reduction = std::max(DEPTH_ZERO, ss->reduction - ONE_PLY);
+ // 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(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);
if (SpNode)
alpha = splitPoint->alpha;
// Check for an instant draw or if the maximum ply has been reached
if (pos.is_draw() || ss->ply > MAX_PLY)
- return ss->ply > MAX_PLY && !InCheck ? evaluate(pos) : DrawValue[pos.side_to_move()];
+ return ss->ply > MAX_PLY && !InCheck ? evaluate(pos) + Tempo : DrawValue[pos.side_to_move()];
// 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
{
// Never assume anything on values stored in TT
if ((ss->staticEval = bestValue = tte->eval_value()) == VALUE_NONE)
- ss->staticEval = bestValue = evaluate(pos);
+ ss->staticEval = bestValue = evaluate(pos) + Tempo;
// Can ttValue be used as a better position evaluation?
if (ttValue != VALUE_NONE)
bestValue = ttValue;
}
else
- ss->staticEval = bestValue = evaluate(pos);
+ ss->staticEval = bestValue = ss->nullChild ? -(ss-1)->staticEval + 2 * Tempo : evaluate(pos) + Tempo;
// Stand pat. Return immediately if static value is at least beta
if (bestValue >= beta)
if (Threads.size() > 2)
for (size_t i = 0; i < Threads.size(); ++i)
{
- int size = Threads[i]->splitPointsSize; // Local copy
+ const int size = Threads[i]->splitPointsSize; // Local copy
sp = size ? &Threads[i]->splitPoints[size - 1] : NULL;
if ( sp
projects / stockfish / blobdiff