// better than the second best move.
const Value EasyMoveMargin = Value(0x150);
+ // This is the minimum interval in msec between two check_time() calls
+ const int TimerResolution = 5;
+
/// Namespace variables
FORCE_INLINE bool is_dangerous(const Position& pos, Move m, bool captureOrPromotion) {
// Test for a pawn pushed to 7th or a passed pawn move
- if (type_of(pos.piece_on(move_from(m))) == PAWN)
+ if (type_of(pos.piece_moved(m)) == PAWN)
{
Color c = pos.side_to_move();
- if ( relative_rank(c, move_to(m)) == RANK_7
- || pos.pawn_is_passed(c, move_to(m)))
+ if ( relative_rank(c, to_sq(m)) == RANK_7
+ || pos.pawn_is_passed(c, to_sq(m)))
return true;
}
// Test for a capture that triggers a pawn endgame
if ( captureOrPromotion
- && type_of(pos.piece_on(move_to(m))) != PAWN
+ && type_of(pos.piece_on(to_sq(m))) != PAWN
&& ( pos.non_pawn_material(WHITE) + pos.non_pawn_material(BLACK)
- - PieceValueMidgame[pos.piece_on(move_to(m))] == VALUE_ZERO)
+ - PieceValueMidgame[pos.piece_on(to_sq(m))] == VALUE_ZERO)
&& !is_special(m))
return true;
// Populate RootMoves with all the legal moves (default) or, if a SearchMoves
// is given, with the subset of legal moves to search.
for (MoveList<MV_LEGAL> ml(pos); !ml.end(); ++ml)
- if ( SearchMoves.empty()
- || count(SearchMoves.begin(), SearchMoves.end(), ml.move()))
+ if (SearchMoves.empty() || count(SearchMoves.begin(), SearchMoves.end(), ml.move()))
RootMoves.push_back(RootMove(ml.move()));
if (Options["OwnBook"])
{
- if (book.name() != (string)Options["Book File"])
- book.open(Options["Book File"]);
-
- Move bookMove = book.probe(pos, Options["Best Book Move"]);
+ Move bookMove = book.probe(pos, Options["Book File"], Options["Best Book Move"]);
- if ( bookMove != MOVE_NONE
- && count(RootMoves.begin(), RootMoves.end(), bookMove))
+ if (bookMove && count(RootMoves.begin(), RootMoves.end(), bookMove))
{
std::swap(RootMoves[0], *find(RootMoves.begin(), RootMoves.end(), bookMove));
- goto finish;
+ goto finalize;
}
}
// Set best timer interval to avoid lagging under time pressure. Timer is
// used to check for remaining available thinking time.
- if (TimeMgr.available_time())
- Threads.set_timer(std::min(100, std::max(TimeMgr.available_time() / 8, 20)));
+ if (Limits.use_time_management())
+ Threads.set_timer(std::min(100, std::max(TimeMgr.available_time() / 16, TimerResolution)));
else
Threads.set_timer(100);
pos.undo_move(RootMoves[0].pv[0]);
}
-finish:
+finalize:
// When we reach max depth we arrive here even without a StopRequest, but if
// we are pondering or in infinite search, we shouldn't print the best move
void id_loop(Position& pos) {
- Stack ss[PLY_MAX_PLUS_2];
+ Stack ss[MAX_PLY_PLUS_2];
int depth, prevBestMoveChanges;
Value bestValue, alpha, beta, delta;
bool bestMoveNeverChanged = true;
}
// Iterative deepening loop until requested to stop or target depth reached
- while (!Signals.stop && ++depth <= PLY_MAX && (!Limits.maxDepth || depth <= Limits.maxDepth))
+ while (!Signals.stop && ++depth <= MAX_PLY && (!Limits.maxDepth || depth <= Limits.maxDepth))
{
// 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.
bestMoveNeverChanged = false;
// Do we have time for the next iteration? Can we stop searching now?
- if (!Signals.stop && !Signals.stopOnPonderhit && Limits.useTimeManagement())
+ if (!Signals.stop && !Signals.stopOnPonderhit && Limits.use_time_management())
{
bool stop = false; // Local variable, not the volatile Signals.stop
stop = true;
// Stop search early if one move seems to be much better than others
- if ( depth >= 10
+ if ( depth >= 12
&& !stop
- && ( bestMoveNeverChanged
+ && ( (bestMoveNeverChanged && pos.captured_piece_type())
|| elapsed_time() > (TimeMgr.available_time() * 40) / 100))
{
Value rBeta = bestValue - EasyMoveMargin;
(ss+1)->excludedMove = RootMoves[0].pv[0];
(ss+1)->skipNullMove = true;
- Value v = search<NonPV>(pos, ss+1, rBeta - 1, rBeta, (depth * ONE_PLY) / 2);
+ Value v = search<NonPV>(pos, ss+1, rBeta - 1, rBeta, (depth - 3) * ONE_PLY);
(ss+1)->skipNullMove = false;
(ss+1)->excludedMove = MOVE_NONE;
// Step 2. Check for aborted search and immediate draw
if (( Signals.stop
|| pos.is_draw<false>()
- || ss->ply > PLY_MAX) && !RootNode)
+ || ss->ply > MAX_PLY) && !RootNode)
return VALUE_DRAW;
// Step 3. Mate distance pruning. Even if we mate at the next move our score
if ( (move = (ss-1)->currentMove) != MOVE_NULL
&& (ss-1)->eval != VALUE_NONE
&& ss->eval != VALUE_NONE
- && pos.captured_piece_type() == NO_PIECE_TYPE
+ && !pos.captured_piece_type()
&& !is_special(move))
{
- Square to = move_to(move);
+ Square to = to_sq(move);
H.update_gain(pos.piece_on(to), to, -(ss-1)->eval - ss->eval);
}
&& !inCheck
&& refinedValue + razor_margin(depth) < beta
&& ttMove == MOVE_NONE
- && abs(beta) < VALUE_MATE_IN_PLY_MAX
+ && abs(beta) < VALUE_MATE_IN_MAX_PLY
&& !pos.has_pawn_on_7th(pos.side_to_move()))
{
Value rbeta = beta - razor_margin(depth);
&& depth < RazorDepth
&& !inCheck
&& refinedValue - futility_margin(depth, 0) >= beta
- && abs(beta) < VALUE_MATE_IN_PLY_MAX
+ && abs(beta) < VALUE_MATE_IN_MAX_PLY
&& pos.non_pawn_material(pos.side_to_move()))
return refinedValue - futility_margin(depth, 0);
&& depth > ONE_PLY
&& !inCheck
&& refinedValue >= beta
- && abs(beta) < VALUE_MATE_IN_PLY_MAX
+ && abs(beta) < VALUE_MATE_IN_MAX_PLY
&& pos.non_pawn_material(pos.side_to_move()))
{
ss->currentMove = MOVE_NULL;
if (nullValue >= beta)
{
// Do not return unproven mate scores
- if (nullValue >= VALUE_MATE_IN_PLY_MAX)
+ if (nullValue >= VALUE_MATE_IN_MAX_PLY)
nullValue = beta;
if (depth < 6 * ONE_PLY)
&& !inCheck
&& !ss->skipNullMove
&& excludedMove == MOVE_NONE
- && abs(beta) < VALUE_MATE_IN_PLY_MAX)
+ && abs(beta) < VALUE_MATE_IN_MAX_PLY)
{
Value rbeta = beta + 200;
Depth rdepth = depth - ONE_PLY - 3 * ONE_PLY;
// Loop through all pseudo-legal moves until no moves remain or a beta cutoff occurs
while ( bestValue < beta
&& (move = mp.next_move()) != MOVE_NONE
- && !thread.cutoff_occurred())
+ && !thread.cutoff_occurred()
+ && !Signals.stop)
{
assert(is_ok(move));
&& !dangerous
&& move != ttMove
&& !is_castle(move)
- && (bestValue > VALUE_MATED_IN_PLY_MAX || bestValue == -VALUE_INFINITE))
+ && (bestValue > VALUE_MATED_IN_MAX_PLY || bestValue == -VALUE_INFINITE))
{
// Move count based pruning
if ( moveCount >= futility_move_count(depth)
// but fixing this made program slightly weaker.
Depth predictedDepth = newDepth - reduction<PvNode>(depth, moveCount);
futilityValue = futilityBase + futility_margin(predictedDepth, moveCount)
- + H.gain(pos.piece_on(move_from(move)), move_to(move));
+ + H.gain(pos.piece_moved(move), to_sq(move));
if (futilityValue < beta)
{
// Increase history value of the cut-off move
Value bonus = Value(int(depth) * int(depth));
- H.add(pos.piece_on(move_from(move)), move_to(move), bonus);
+ H.add(pos.piece_moved(move), to_sq(move), bonus);
// Decrease history of all the other played non-capture moves
for (int i = 0; i < playedMoveCount - 1; i++)
{
Move m = movesSearched[i];
- H.add(pos.piece_on(move_from(m)), move_to(m), -bonus);
+ H.add(pos.piece_moved(m), to_sq(m), -bonus);
}
}
}
ss->ply = (ss-1)->ply + 1;
// Check for an instant draw or maximum ply reached
- if (pos.is_draw<true>() || ss->ply > PLY_MAX)
+ if (pos.is_draw<true>() || ss->ply > MAX_PLY)
return VALUE_DRAW;
// Decide whether or not to include checks, this fixes also the type of
// to search the moves. Because the depth is <= 0 here, only captures,
// queen promotions and checks (only if depth >= DEPTH_QS_CHECKS) will
// be generated.
- MovePicker mp(pos, ttMove, depth, H, move_to((ss-1)->currentMove));
+ MovePicker mp(pos, ttMove, depth, H, to_sq((ss-1)->currentMove));
CheckInfo ci(pos);
// Loop through the moves until no moves remain or a beta cutoff occurs
&& !pos.is_passed_pawn_push(move))
{
futilityValue = futilityBase
- + PieceValueEndgame[pos.piece_on(move_to(move))]
+ + PieceValueEndgame[pos.piece_on(to_sq(move))]
+ (is_enpassant(move) ? PawnValueEndgame : VALUE_ZERO);
if (futilityValue < beta)
// Detect non-capture evasions that are candidate to be pruned
evasionPrunable = !PvNode
&& inCheck
- && bestValue > VALUE_MATED_IN_PLY_MAX
+ && bestValue > VALUE_MATED_IN_MAX_PLY
&& !pos.is_capture(move)
&& !pos.can_castle(pos.side_to_move());
Color them;
Value futilityValue, bv = *bestValue;
- from = move_from(move);
- to = move_to(move);
- them = flip(pos.side_to_move());
+ from = from_sq(move);
+ to = to_sq(move);
+ them = ~pos.side_to_move();
ksq = pos.king_square(them);
kingAtt = pos.attacks_from<KING>(ksq);
pc = pos.piece_on(from);
assert(is_ok(m2));
// Case 1: The moving piece is the same in both moves
- f2 = move_from(m2);
- t1 = move_to(m1);
+ f2 = from_sq(m2);
+ t1 = to_sq(m1);
if (f2 == t1)
return true;
// Case 2: The destination square for m2 was vacated by m1
- t2 = move_to(m2);
- f1 = move_from(m1);
+ t2 = to_sq(m2);
+ f1 = from_sq(m1);
if (t2 == f1)
return true;
Value value_to_tt(Value v, int ply) {
- if (v >= VALUE_MATE_IN_PLY_MAX)
+ if (v >= VALUE_MATE_IN_MAX_PLY)
return v + ply;
- if (v <= VALUE_MATED_IN_PLY_MAX)
+ if (v <= VALUE_MATED_IN_MAX_PLY)
return v - ply;
return v;
Value value_from_tt(Value v, int ply) {
- if (v >= VALUE_MATE_IN_PLY_MAX)
+ if (v >= VALUE_MATE_IN_MAX_PLY)
return v - ply;
- if (v <= VALUE_MATED_IN_PLY_MAX)
+ if (v <= VALUE_MATED_IN_MAX_PLY)
return v + ply;
return v;
Square mfrom, mto, tfrom, tto;
- mfrom = move_from(m);
- mto = move_to(m);
- tfrom = move_from(threat);
- tto = move_to(threat);
+ mfrom = from_sq(m);
+ mto = to_sq(m);
+ tfrom = from_sq(threat);
+ tto = to_sq(threat);
// Case 1: Don't prune moves which move the threatened piece
if (mfrom == tto)
Value v = value_from_tt(tte->value(), ply);
return ( tte->depth() >= depth
- || v >= std::max(VALUE_MATE_IN_PLY_MAX, beta)
- || v < std::min(VALUE_MATED_IN_PLY_MAX, beta))
+ || v >= std::max(VALUE_MATE_IN_MAX_PLY, beta)
+ || v < std::min(VALUE_MATED_IN_MAX_PLY, beta))
&& ( ((tte->type() & VALUE_TYPE_LOWER) && v >= beta)
|| ((tte->type() & VALUE_TYPE_UPPER) && v < beta));
std::stringstream s;
- if (abs(v) < VALUE_MATE_IN_PLY_MAX)
+ if (abs(v) < VALUE_MATE_IN_MAX_PLY)
s << "cp " << v * 100 / int(PawnValueMidgame);
else
s << "mate " << (v > 0 ? VALUE_MATE - v + 1 : -VALUE_MATE - v) / 2;
std::stringstream s;
- if (v >= VALUE_MATE_IN_PLY_MAX)
+ if (v >= VALUE_MATE_IN_MAX_PLY)
s << "#" << (VALUE_MATE - v + 1) / 2;
- else if (v <= VALUE_MATED_IN_PLY_MAX)
+ else if (v <= VALUE_MATED_IN_MAX_PLY)
s << "-#" << (VALUE_MATE + v) / 2;
else
s << std::setprecision(2) << std::fixed << std::showpos
const int64_t K = 1000;
const int64_t M = 1000000;
- StateInfo state[PLY_MAX_PLUS_2], *st = state;
+ StateInfo state[MAX_PLY_PLUS_2], *st = state;
Move* m = pv;
string san, padding;
size_t length;
void RootMove::extract_pv_from_tt(Position& pos) {
- StateInfo state[PLY_MAX_PLUS_2], *st = state;
+ StateInfo state[MAX_PLY_PLUS_2], *st = state;
TTEntry* tte;
int ply = 1;
Move m = pv[0];
&& tte->move() != MOVE_NONE
&& pos.is_pseudo_legal(tte->move())
&& pos.pl_move_is_legal(tte->move(), pos.pinned_pieces())
- && ply < PLY_MAX
+ && ply < MAX_PLY
&& (!pos.is_draw<false>() || ply < 2))
{
pv.push_back(tte->move());
void RootMove::insert_pv_in_tt(Position& pos) {
- StateInfo state[PLY_MAX_PLUS_2], *st = state;
+ StateInfo state[MAX_PLY_PLUS_2], *st = state;
TTEntry* tte;
Key k;
Value v, m = VALUE_NONE;
assert(!do_terminate);
// Copy split point position and search stack and call search()
- Stack ss[PLY_MAX_PLUS_2];
+ Stack ss[MAX_PLY_PLUS_2];
SplitPoint* tsp = splitPoint;
Position pos(*tsp->pos, threadID);
}
-/// do_timer_event() is called by the timer thread when the timer triggers. It
-/// is used to print debug info and, more important, to detect when we are out of
+/// check_time() is called by the timer thread when the timer triggers. It is
+/// used to print debug info and, more important, to detect when we are out of
/// available time and so stop the search.
-void do_timer_event() {
+void check_time() {
static int lastInfoTime;
int e = elapsed_time();
&& !Signals.failedLowAtRoot
&& e > TimeMgr.available_time();
- bool noMoreTime = e > TimeMgr.maximum_time()
+ bool noMoreTime = e > TimeMgr.maximum_time() - 2 * TimerResolution
|| stillAtFirstMove;
- if ( (Limits.useTimeManagement() && noMoreTime)
+ if ( (Limits.use_time_management() && noMoreTime)
|| (Limits.maxTime && e >= Limits.maxTime)
/* missing nodes limit */ ) // FIXME
Signals.stop = true;
projects / stockfish / blobdiff