MovePickerExt(const Position& p, Move ttm, Depth d, const History& h, Stack* ss, Value b)
: MovePicker(p, ttm, d, h, ss, b), mp(ss->sp->mp) {}
- Move get_next_move() { return mp->get_next_move(); }
+ Move next_move() { return mp->next_move(); }
MovePicker* mp;
};
TT.set_size(Options["Hash"].value<int>());
if (Options["Clear Hash"].value<bool>())
{
- Options["Clear Hash"].set_value("false");
+ Options["Clear Hash"] = false;
TT.clear();
}
const bool SpNode = (NT == SplitPointPV || NT == SplitPointNonPV || NT == SplitPointRoot);
const bool RootNode = (NT == Root || NT == SplitPointRoot);
- assert(alpha >= -VALUE_INFINITE && alpha <= VALUE_INFINITE);
- assert(beta > alpha && beta <= VALUE_INFINITE);
- assert(PvNode || alpha == beta - 1);
+ assert(alpha >= -VALUE_INFINITE && alpha < beta && beta <= VALUE_INFINITE);
+ assert(PvNode == (alpha != beta - 1));
+ assert(depth > DEPTH_ZERO);
assert(pos.thread() >= 0 && pos.thread() < Threads.size());
Move movesSearched[MAX_MOVES];
|| ss->ply > PLY_MAX) && !RootNode)
return VALUE_DRAW;
- // Step 3. Mate distance pruning
+ // 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
+ // a shorter mate was found upward in the tree then there is no need to search
+ // further, we will never beat current alpha. Same logic but with reversed signs
+ // applies also in the opposite condition of being mated instead of giving mate,
+ // in this case return a fail-high score.
if (!RootNode)
{
- alpha = std::max(value_mated_in(ss->ply), alpha);
- beta = std::min(value_mate_in(ss->ply+1), beta);
+ alpha = std::max(mated_in(ss->ply), alpha);
+ beta = std::min(mate_in(ss->ply+1), beta);
if (alpha >= beta)
return alpha;
}
// We don't want the score of a partial search to overwrite a previous full search
// TT value, so we use a different position key in case of an excluded move.
excludedMove = ss->excludedMove;
- posKey = excludedMove ? pos.get_exclusion_key() : pos.get_key();
+ posKey = excludedMove ? pos.exclusion_key() : pos.key();
tte = TT.probe(posKey);
ttMove = RootNode ? RootMoves[PVIdx].pv[0] : tte ? tte->move() : MOVE_NONE;
if ( (move = (ss-1)->currentMove) != MOVE_NULL
&& (ss-1)->eval != VALUE_NONE
&& ss->eval != VALUE_NONE
- && pos.captured_piece_type() == PIECE_TYPE_NONE
+ && pos.captured_piece_type() == NO_PIECE_TYPE
&& !is_special(move))
{
Square to = move_to(move);
MovePicker mp(pos, ttMove, H, pos.captured_piece_type());
CheckInfo ci(pos);
- while ((move = mp.get_next_move()) != MOVE_NONE)
+ while ((move = mp.next_move()) != MOVE_NONE)
if (pos.pl_move_is_legal(move, ci.pinned))
{
pos.do_move(move, st, ci, pos.move_gives_check(move, ci));
// Step 11. Loop through moves
// Loop through all pseudo-legal moves until no moves remain or a beta cutoff occurs
while ( bestValue < beta
- && (move = mp.get_next_move()) != MOVE_NONE
+ && (move = mp.next_move()) != MOVE_NONE
&& !thread.cutoff_occurred())
{
assert(is_ok(move));
// harmless because return value is discarded anyhow in the parent nodes.
// If we are in a singular extension search then return a fail low score.
if (!moveCount)
- return excludedMove ? oldAlpha : inCheck ? value_mated_in(ss->ply) : VALUE_DRAW;
+ return excludedMove ? oldAlpha : inCheck ? mated_in(ss->ply) : VALUE_DRAW;
// If we have pruned all the moves without searching return a fail-low score
if (bestValue == -VALUE_INFINITE)
const bool PvNode = (NT == PV);
assert(NT == PV || NT == NonPV);
- assert(alpha >= -VALUE_INFINITE && alpha <= VALUE_INFINITE);
- assert(beta >= -VALUE_INFINITE && beta <= VALUE_INFINITE);
- assert(PvNode || alpha == beta - 1);
- assert(depth <= 0);
+ assert(alpha >= -VALUE_INFINITE && alpha < beta && beta <= VALUE_INFINITE);
+ assert(PvNode == (alpha != beta - 1));
+ assert(depth <= DEPTH_ZERO);
assert(pos.thread() >= 0 && pos.thread() < Threads.size());
StateInfo st;
// Transposition table lookup. At PV nodes, we don't use the TT for
// pruning, but only for move ordering.
- tte = TT.probe(pos.get_key());
+ tte = TT.probe(pos.key());
ttMove = (tte ? tte->move() : MOVE_NONE);
if (!PvNode && tte && can_return_tt(tte, ttDepth, beta, ss->ply))
if (bestValue >= beta)
{
if (!tte)
- TT.store(pos.get_key(), value_to_tt(bestValue, ss->ply), VALUE_TYPE_LOWER, DEPTH_NONE, MOVE_NONE, ss->eval, evalMargin);
+ TT.store(pos.key(), value_to_tt(bestValue, ss->ply), VALUE_TYPE_LOWER, DEPTH_NONE, MOVE_NONE, ss->eval, evalMargin);
return bestValue;
}
// Loop through the moves until no moves remain or a beta cutoff occurs
while ( bestValue < beta
- && (move = mp.get_next_move()) != MOVE_NONE)
+ && (move = mp.next_move()) != MOVE_NONE)
{
assert(is_ok(move));
// All legal moves have been searched. A special case: If we're in check
// and no legal moves were found, it is checkmate.
if (inCheck && bestValue == -VALUE_INFINITE)
- return value_mated_in(ss->ply);
+ return mated_in(ss->ply); // Plies to mate from the root
// Update transposition table
move = bestValue <= oldAlpha ? MOVE_NONE : ss->bestMove;
vt = bestValue <= oldAlpha ? VALUE_TYPE_UPPER
: bestValue >= beta ? VALUE_TYPE_LOWER : VALUE_TYPE_EXACT;
- TT.store(pos.get_key(), value_to_tt(bestValue, ss->ply), vt, ttDepth, move, ss->eval, evalMargin);
+ TT.store(pos.key(), value_to_tt(bestValue, ss->ply), vt, ttDepth, move, ss->eval, evalMargin);
assert(bestValue > -VALUE_INFINITE && bestValue < VALUE_INFINITE);
// value_to_tt() adjusts a mate score from "plies to mate from the root" to
- // "plies to mate from the current ply". Non-mate scores are unchanged. The
- // function is called before storing a value to the transposition table.
+ // "plies to mate from the current position". Non-mate scores are unchanged.
+ // The function is called before storing a value to the transposition table.
Value value_to_tt(Value v, int ply) {
}
- // value_from_tt() is the inverse of value_to_tt(): It adjusts a mate score from
- // the transposition table to a mate score corrected for the current ply.
+ // value_from_tt() is the inverse of value_to_tt(): It adjusts a mate score
+ // from the transposition table (where refers to the plies to mate/be mated
+ // from current position) to "plies to mate/be mated from the root".
Value value_from_tt(Value v, int ply) {
static int searchStartTime;
if (reset)
- searchStartTime = get_system_time();
+ searchStartTime = system_time();
- return get_system_time() - searchStartTime;
+ return system_time() - searchStartTime;
}
static RKISS rk;
// PRNG sequence should be not deterministic
- for (int i = abs(get_system_time() % 50); i > 0; i--)
+ for (int i = abs(system_time() % 50); i > 0; i--)
rk.rand<unsigned>();
// RootMoves are already sorted by score in descending order
pv.push_back(m);
pos.do_move(m, *st++);
- while ( (tte = TT.probe(pos.get_key())) != NULL
+ while ( (tte = TT.probe(pos.key())) != NULL
&& tte->move() != MOVE_NONE
&& pos.is_pseudo_legal(tte->move())
&& pos.pl_move_is_legal(tte->move(), pos.pinned_pieces())
assert(pv[ply] != MOVE_NONE && pos.is_pseudo_legal(pv[ply]));
do {
- k = pos.get_key();
+ k = pos.key();
tte = TT.probe(k);
// Don't overwrite existing correct entries
static int lastInfoTime;
int e = elapsed_time();
- if (get_system_time() - lastInfoTime >= 1000 || !lastInfoTime)
+ if (system_time() - lastInfoTime >= 1000 || !lastInfoTime)
{
- lastInfoTime = get_system_time();
+ lastInfoTime = system_time();
dbg_print_mean();
dbg_print_hit_rate();
projects / stockfish / blobdiff