bool check_is_dangerous(Position &pos, Move move, Value futilityBase, Value beta, Value *bValue);
bool connected_moves(const Position& pos, Move m1, Move m2);
- bool value_is_mate(Value value);
Value value_to_tt(Value v, int ply);
Value value_from_tt(Value v, int ply);
bool ok_to_use_TT(const TTEntry* tte, Depth depth, Value beta, int ply);
bool connected_threat(const Position& pos, Move m, Move threat);
Value refine_eval(const TTEntry* tte, Value defaultEval, int ply);
void update_history(const Position& pos, Move move, Depth depth, Move movesSearched[], int moveCount);
- void update_killers(Move m, Move killers[]);
void update_gains(const Position& pos, Move move, Value before, Value after);
int current_search_time();
// Do we have to play with skill handicap? In this case enable MultiPV that
// we will use behind the scenes to retrieve a set of possible moves.
- MultiPV = (SkillLevel < 10 ? Max(UCIMultiPV, 4) : UCIMultiPV);
+ MultiPV = (SkillLevel < 20 ? Max(UCIMultiPV, 4) : UCIMultiPV);
// Set the number of active threads
ThreadsMgr.read_uci_options();
}
}
- // When playing with strength handicap choose best move among the MultiPV
- // set using a statistical rule dependent on SkillLevel.
- if (SkillLevel < 10)
+ // When playing with strength handicap choose best move among the MultiPV set
+ // using a statistical rule dependent on SkillLevel. Idea by Heinz van Saanen.
+ if (SkillLevel < 20)
{
assert(MultiPV > 1);
int size = Min(MultiPV, (int)Rml.size());
int max = Rml[0].pv_score;
int var = Min(max - Rml[size - 1].pv_score, PawnValueMidgame);
- int wk = 128 - 8 * SkillLevel;
+ int wk = 120 - 2 * SkillLevel;
// PRNG sequence should be non deterministic
for (int i = abs(get_system_time() % 50); i > 0; i--)
&& !isCheck
&& refinedValue < beta - razor_margin(depth)
&& ttMove == MOVE_NONE
- && !value_is_mate(beta)
+ && abs(beta) < VALUE_MATE_IN_PLY_MAX
&& !pos.has_pawn_on_7th(pos.side_to_move()))
{
Value rbeta = beta - razor_margin(depth);
&& depth < RazorDepth
&& !isCheck
&& refinedValue >= beta + futility_margin(depth, 0)
- && !value_is_mate(beta)
+ && abs(beta) < VALUE_MATE_IN_PLY_MAX
&& pos.non_pawn_material(pos.side_to_move()))
return refinedValue - futility_margin(depth, 0);
&& depth > ONE_PLY
&& !isCheck
&& refinedValue >= beta
- && !value_is_mate(beta)
+ && abs(beta) < VALUE_MATE_IN_PLY_MAX
&& 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_PLY_MAX)
nullValue = beta;
if (depth < 6 * ONE_PLY)
// Move count based pruning
if ( moveCount >= futility_move_count(depth)
&& !(threatMove && connected_threat(pos, move, threatMove))
- && bestValue > value_mated_in(PLY_MAX)) // FIXME bestValue is racy
+ && bestValue > VALUE_MATED_IN_PLY_MAX) // FIXME bestValue is racy
{
if (SpNode)
lock_grab(&(sp->lock));
// Prune moves with negative SEE at low depths
if ( predictedDepth < 2 * ONE_PLY
- && bestValue > value_mated_in(PLY_MAX)
+ && bestValue > VALUE_MATED_IN_PLY_MAX
&& pos.see_sign(move) < 0)
{
if (SpNode)
if ( bestValue >= beta
&& !pos.move_is_capture_or_promotion(move))
{
+ if (move != ss->killers[0])
+ {
+ ss->killers[1] = ss->killers[0];
+ ss->killers[0] = move;
+ }
update_history(pos, move, depth, movesSearched, playedMoveCount);
- update_killers(move, ss->killers);
}
}
// Detect non-capture evasions that are candidate to be pruned
evasionPrunable = isCheck
- && bestValue > value_mated_in(PLY_MAX)
+ && bestValue > VALUE_MATED_IN_PLY_MAX
&& !pos.move_is_capture(move)
&& !pos.can_castle(pos.side_to_move());
}
- // value_is_mate() checks if the given value is a mate one eventually
- // compensated for the ply.
-
- bool value_is_mate(Value value) {
-
- assert(abs(value) <= VALUE_INFINITE);
-
- return value <= value_mated_in(PLY_MAX)
- || value >= value_mate_in(PLY_MAX);
- }
-
-
// 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.
Value value_to_tt(Value v, int ply) {
- if (v >= value_mate_in(PLY_MAX))
+ if (v >= VALUE_MATE_IN_PLY_MAX)
return v + ply;
- if (v <= value_mated_in(PLY_MAX))
+ if (v <= VALUE_MATED_IN_PLY_MAX)
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_PLY_MAX)
return v - ply;
- if (v <= value_mated_in(PLY_MAX))
+ if (v <= VALUE_MATED_IN_PLY_MAX)
return v + ply;
return v;
*dangerous = true;
}
- if ( PvNode
- && captureOrPromotion
- && pos.type_of_piece_on(move_to(m)) != PAWN
- && pos.see_sign(m) >= 0)
- {
- result += ONE_PLY / 2;
- *dangerous = true;
- }
-
return Min(result, ONE_PLY);
}
Value v = value_from_tt(tte->value(), ply);
return ( tte->depth() >= depth
- || v >= Max(value_mate_in(PLY_MAX), beta)
- || v < Min(value_mated_in(PLY_MAX), beta))
+ || v >= Max(VALUE_MATE_IN_PLY_MAX, beta)
+ || v < Min(VALUE_MATED_IN_PLY_MAX, beta))
&& ( ((tte->type() & VALUE_TYPE_LOWER) && v >= beta)
|| ((tte->type() & VALUE_TYPE_UPPER) && v < beta));
}
- // update_killers() add a good move that produced a beta-cutoff
- // among the killer moves of that ply.
-
- void update_killers(Move m, Move killers[]) {
-
- if (m != killers[0])
- {
- killers[1] = killers[0];
- killers[0] = m;
- }
- }
-
-
// update_gains() updates the gains table of a non-capture move given
// the static position evaluation before and after the move.
H.update_gain(pos.piece_on(move_to(m)), move_to(m), -(before + after));
}
+
// current_search_time() returns the number of milliseconds which have passed
// since the beginning of the current search.
if (abs(v) < VALUE_MATE - PLY_MAX * ONE_PLY)
s << "cp " << int(v) * 100 / int(PawnValueMidgame); // Scale to centipawns
else
- s << "mate " << (v > 0 ? (VALUE_MATE - v + 1) / 2 : -(VALUE_MATE + v) / 2);
+ s << "mate " << (v > 0 ? VALUE_MATE - v + 1 : -VALUE_MATE - v) / 2;
return s.str();
}
// We are line oriented, don't read single chars
std::string command;
- if (!std::getline(std::cin, command))
- command = "quit";
-
- if (command == "quit")
+ if (!std::getline(std::cin, command) || command == "quit")
{
// Quit the program as soon as possible
Pondering = false;
std::string command;
- while (true)
- {
- // Wait for a command from stdin
- if (!std::getline(std::cin, command))
- command = "quit";
+ // Wait for a command from stdin
+ while ( std::getline(std::cin, command)
+ && command != "ponderhit" && command != "stop" && command != "quit") {};
- if (command == "quit")
- {
- QuitRequest = true;
- break;
- }
- else if (command == "ponderhit" || command == "stop")
- break;
- }
+ if (command != "ponderhit" && command != "stop")
+ QuitRequest = true; // Must be "quit" or getline() returned false
}
projects / stockfish / blobdiff