#include <cmath>
#include <cstring>
#include <fstream>
+#include <iomanip>
#include <iostream>
#include <sstream>
#include <vector>
using std::cout;
using std::endl;
+using std::string;
namespace {
Move pv[PLY_MAX_PLUS_2];
};
- // RootMoveList struct is just a vector of RootMove objects,
- // with an handful of methods above the standard ones.
+ // RootMoveList struct is mainly a std::vector of RootMove objects
struct RootMoveList : public std::vector<RootMove> {
-
- typedef std::vector<RootMove> Base;
-
void init(Position& pos, Move searchMoves[]);
- void sort() { insertion_sort<RootMove, Base::iterator>(begin(), end()); }
- void sort_first(int n) { insertion_sort<RootMove, Base::iterator>(begin(), begin() + n); }
-
int bestMoveChanges;
};
void do_skill_level(Move* best, Move* ponder);
int current_search_time(int set = 0);
- std::string score_to_uci(Value v, Value alpha, Value beta);
- std::string speed_to_uci(int64_t nodes);
- std::string pv_to_uci(Move pv[], int pvNum);
- std::string depth_to_uci(Depth depth);
+ string score_to_uci(Value v, Value alpha, Value beta);
+ string speed_to_uci(int64_t nodes);
+ string pv_to_uci(Move pv[], int pvNum, bool chess960);
+ string pretty_pv(Position& pos, int depth, Value score, int time, Move pv[]);
+ string depth_to_uci(Depth depth);
void poll(const Position& pos);
void wait_for_stop_or_ponderhit();
// Look for a book move
if (Options["OwnBook"].value<bool>())
{
- if (Options["Book File"].value<std::string>() != book.name())
- book.open(Options["Book File"].value<std::string>());
+ if (Options["Book File"].value<string>() != book.name())
+ book.open(Options["Book File"].value<string>());
Move bookMove = book.get_move(pos, Options["Best Book Move"].value<bool>());
if (bookMove != MOVE_NONE)
// Write to log file and keep it open to be accessed during the search
if (Options["Use Search Log"].value<bool>())
{
- std::string name = Options["Search Log Filename"].value<std::string>();
+ string name = Options["Search Log Filename"].value<string>();
LogFile.open(name.c_str(), std::ios::out | std::ios::app);
if (LogFile.is_open())
<< depth_to_uci(depth * ONE_PLY)
<< score_to_uci(Rml[i].pv_score, alpha, beta)
<< speed_to_uci(pos.nodes_searched())
- << pv_to_uci(Rml[i].pv, i + 1) << endl;
+ << pv_to_uci(Rml[i].pv, i + 1, pos.is_chess960()) << endl;
// In case of failing high/low increase aspiration window and research,
// otherwise exit the fail high/low loop.
// Check for some early stop condition
if (!StopRequest && Limits.useTimeManagement())
{
- // Stop search early when the last two iterations returned a mate score
- if ( depth >= 5
- && abs(bestValues[depth]) >= VALUE_MATE_IN_PLY_MAX
- && abs(bestValues[depth - 1]) >= VALUE_MATE_IN_PLY_MAX)
- StopRequest = true;
-
// Stop search early if one move seems to be much better than the
// others or if there is only a single legal move. Also in the latter
// case we search up to some depth anyway to get a proper score.
if (PvNode && thread.maxPly < ss->ply)
thread.maxPly = ss->ply;
- if (SpNode)
+ // Step 1. Initialize node and poll. Polling can abort search
+ if (!SpNode)
+ {
+ ss->currentMove = ss->bestMove = threatMove = (ss+1)->excludedMove = MOVE_NONE;
+ (ss+1)->skipNullMove = false; (ss+1)->reduction = DEPTH_ZERO;
+ (ss+2)->killers[0] = (ss+2)->killers[1] = MOVE_NONE;
+ }
+ else
{
sp = ss->sp;
tte = NULL;
goto split_point_start;
}
- // Step 1. Initialize node and poll. Polling can abort search
- ss->currentMove = ss->bestMove = threatMove = (ss+1)->excludedMove = MOVE_NONE;
- (ss+1)->skipNullMove = false; (ss+1)->reduction = DEPTH_ZERO;
- (ss+2)->killers[0] = (ss+2)->killers[1] = MOVE_NONE;
-
if (pos.thread() == 0 && ++NodesSincePoll > NodesBetweenPolls)
{
NodesSincePoll = 0;
// At PV nodes we check for exact scores, while at non-PV nodes we check for
// a fail high/low. Biggest advantage at probing at PV nodes is to have a
- // smooth experience in analysis mode.
- if (tte && (PvNode ? tte->depth() >= depth && tte->type() == VALUE_TYPE_EXACT
- : ok_to_use_TT(tte, depth, beta, ss->ply)))
+ // smooth experience in analysis mode. We don't probe at Root nodes otherwise
+ // we should also update RootMoveList to avoid bogus output.
+ if (!RootNode && tte && (PvNode ? tte->depth() >= depth && tte->type() == VALUE_TYPE_EXACT
+ : ok_to_use_TT(tte, depth, beta, ss->ply)))
{
TT.refresh(tte);
ss->bestMove = ttMove; // Can be MOVE_NONE
// because all the values but the first are usually set to
// -VALUE_INFINITE and we want to keep the same order for all
// the moves but the new PV that goes to head.
- Rml.sort_first(moveCount);
+ sort<RootMove>(Rml.begin(), Rml.begin() + moveCount);
// Update alpha. In multi-pv we don't use aspiration window, so set
// alpha equal to minimum score among the PV lines searched so far.
bool connected_moves(const Position& pos, Move m1, Move m2) {
Square f1, t1, f2, t2;
- Piece p;
+ Piece p1, p2;
+ Square ksq;
assert(m1 && move_is_ok(m1));
assert(m2 && move_is_ok(m2));
return true;
// Case 3: Moving through the vacated square
- if ( piece_is_slider(pos.piece_on(f2))
+ p2 = pos.piece_on(f2);
+ if ( piece_is_slider(p2)
&& bit_is_set(squares_between(f2, t2), f1))
return true;
// Case 4: The destination square for m2 is defended by the moving piece in m1
- p = pos.piece_on(t1);
- if (bit_is_set(pos.attacks_from(p, t1), t2))
+ p1 = pos.piece_on(t1);
+ if (bit_is_set(pos.attacks_from(p1, t1), t2))
return true;
// Case 5: Discovered check, checking piece is the piece moved in m1
- if ( piece_is_slider(p)
- && bit_is_set(squares_between(t1, pos.king_square(pos.side_to_move())), f2)
- && !bit_is_set(squares_between(t1, pos.king_square(pos.side_to_move())), t2))
+ ksq = pos.king_square(pos.side_to_move());
+ if ( piece_is_slider(p1)
+ && bit_is_set(squares_between(t1, ksq), f2))
{
- // discovered_check_candidates() works also if the Position's side to
- // move is the opposite of the checking piece.
- Color them = opposite_color(pos.side_to_move());
- Bitboard dcCandidates = pos.discovered_check_candidates(them);
-
- if (bit_is_set(dcCandidates, f2))
+ Bitboard occ = pos.occupied_squares();
+ clear_bit(&occ, f2);
+ if (bit_is_set(pos.attacks_from(p1, t1, occ), ksq))
return true;
}
return false;
// mate <y> Mate in y moves, not plies. If the engine is getting mated
// use negative values for y.
- std::string score_to_uci(Value v, Value alpha, Value beta) {
+ string score_to_uci(Value v, Value alpha, Value beta) {
std::stringstream s;
// speed_to_uci() returns a string with time stats of current search suitable
// to be sent to UCI gui.
- std::string speed_to_uci(int64_t nodes) {
+ string speed_to_uci(int64_t nodes) {
std::stringstream s;
int t = current_search_time();
// pv_to_uci() returns a string with information on the current PV line
// formatted according to UCI specification.
- std::string pv_to_uci(Move pv[], int pvNum) {
+ string pv_to_uci(Move pv[], int pvNum, bool chess960) {
std::stringstream s;
- s << " multipv " << pvNum << " pv ";
+ s << " multipv " << pvNum << " pv " << set960(chess960);
for ( ; *pv != MOVE_NONE; pv++)
s << *pv << " ";
// depth_to_uci() returns a string with information on the current depth and
// seldepth formatted according to UCI specification.
- std::string depth_to_uci(Depth depth) {
+ string depth_to_uci(Depth depth) {
std::stringstream s;
return s.str();
}
+ string time_to_string(int millisecs) {
+
+ const int MSecMinute = 1000 * 60;
+ const int MSecHour = 1000 * 60 * 60;
+
+ int hours = millisecs / MSecHour;
+ int minutes = (millisecs % MSecHour) / MSecMinute;
+ int seconds = ((millisecs % MSecHour) % MSecMinute) / 1000;
+
+ std::stringstream s;
+
+ if (hours)
+ s << hours << ':';
+
+ s << std::setfill('0') << std::setw(2) << minutes << ':' << std::setw(2) << seconds;
+ return s.str();
+ }
+
+ string score_to_string(Value v) {
+
+ std::stringstream s;
+
+ if (v >= VALUE_MATE_IN_PLY_MAX)
+ s << "#" << (VALUE_MATE - v + 1) / 2;
+ else if (v <= VALUE_MATED_IN_PLY_MAX)
+ s << "-#" << (VALUE_MATE + v) / 2;
+ else
+ s << std::setprecision(2) << std::fixed << std::showpos << float(v) / PawnValueMidgame;
+
+ return s.str();
+ }
+
+ // pretty_pv() creates a human-readable string from a position and a PV.
+ // It is used to write search information to the log file (which is created
+ // when the UCI parameter "Use Search Log" is "true").
+
+ string pretty_pv(Position& pos, int depth, Value value, int time, Move pv[]) {
+
+ const int64_t K = 1000;
+ const int64_t M = 1000000;
+ const int startColumn = 28;
+ const size_t maxLength = 80 - startColumn;
+
+ StateInfo state[PLY_MAX_PLUS_2], *st = state;
+ Move* m = pv;
+ string san;
+ std::stringstream s;
+ size_t length = 0;
+
+ // First print depth, score, time and searched nodes...
+ s << set960(pos.is_chess960())
+ << std::setw(2) << depth
+ << std::setw(8) << score_to_string(value)
+ << std::setw(8) << time_to_string(time);
+
+ if (pos.nodes_searched() < M)
+ s << std::setw(8) << pos.nodes_searched() / 1 << " ";
+ else if (pos.nodes_searched() < K * M)
+ s << std::setw(7) << pos.nodes_searched() / K << "K ";
+ else
+ s << std::setw(7) << pos.nodes_searched() / M << "M ";
+
+ // ...then print the full PV line in short algebraic notation
+ while (*m != MOVE_NONE)
+ {
+ san = move_to_san(pos, *m);
+ length += san.length() + 1;
+
+ if (length > maxLength)
+ {
+ length = san.length() + 1;
+ s << "\n" + string(startColumn, ' ');
+ }
+ s << san << ' ';
+
+ pos.do_move(*m++, *st++);
+ }
+
+ // Restore original position before to leave
+ while (m != pv) pos.undo_move(*--m);
+
+ return s.str();
+ }
// poll() performs two different functions: It polls for user input, and it
// looks at the time consumed so far and decides if it's time to abort the
if (input_available())
{
// We are line oriented, don't read single chars
- std::string command;
+ string command;
if (!std::getline(std::cin, command) || command == "quit")
{
void wait_for_stop_or_ponderhit() {
- std::string command;
+ string command;
// Wait for a command from stdin
while ( std::getline(std::cin, command)
while ( (tte = TT.probe(pos.get_key())) != NULL
&& tte->move() != MOVE_NONE
&& pos.move_is_pl(tte->move())
- && pos.pl_move_is_legal(tte->move(), pos.pinned_pieces(pos.side_to_move()))
+ && pos.pl_move_is_legal(tte->move(), pos.pinned_pieces())
&& ply < PLY_MAX
&& (!pos.is_draw<false>() || ply < 2))
{
break;
}
- Rml.sort();
+ sort<RootMove>(Rml.begin(), Rml.end());
}
} // namespace
projects / stockfish / blobdiff