2008-08-31 23:59:13 -06:00
|
|
|
/*
|
2008-10-19 10:56:28 -06:00
|
|
|
Stockfish, a UCI chess playing engine derived from Glaurung 2.1
|
|
|
|
Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
|
2014-01-01 17:48:07 -07:00
|
|
|
Copyright (C) 2008-2014 Marco Costalba, Joona Kiiski, Tord Romstad
|
2008-08-31 23:59:13 -06:00
|
|
|
|
2008-10-19 10:56:28 -06:00
|
|
|
Stockfish is free software: you can redistribute it and/or modify
|
2008-08-31 23:59:13 -06:00
|
|
|
it under the terms of the GNU General Public License as published by
|
|
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
|
|
(at your option) any later version.
|
2008-09-01 06:05:02 -06:00
|
|
|
|
2008-10-19 10:56:28 -06:00
|
|
|
Stockfish is distributed in the hope that it will be useful,
|
2008-08-31 23:59:13 -06:00
|
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
GNU General Public License for more details.
|
2008-09-01 06:05:02 -06:00
|
|
|
|
2008-08-31 23:59:13 -06:00
|
|
|
You should have received a copy of the GNU General Public License
|
|
|
|
along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
*/
|
|
|
|
|
2013-02-19 00:54:16 -07:00
|
|
|
#include <iomanip>
|
2008-08-31 23:59:13 -06:00
|
|
|
#include <iostream>
|
2008-09-01 00:06:34 -06:00
|
|
|
#include <sstream>
|
2008-08-31 23:59:13 -06:00
|
|
|
#include <string>
|
|
|
|
|
|
|
|
#include "evaluate.h"
|
2012-07-15 01:14:25 -06:00
|
|
|
#include "notation.h"
|
2008-08-31 23:59:13 -06:00
|
|
|
#include "position.h"
|
|
|
|
#include "search.h"
|
2011-11-05 00:53:19 -06:00
|
|
|
#include "thread.h"
|
2013-11-29 02:50:14 -07:00
|
|
|
#include "tt.h"
|
2008-08-31 23:59:13 -06:00
|
|
|
#include "ucioption.h"
|
|
|
|
|
2009-05-20 04:40:07 -06:00
|
|
|
using namespace std;
|
2008-08-31 23:59:13 -06:00
|
|
|
|
2012-04-07 06:23:43 -06:00
|
|
|
extern void benchmark(const Position& pos, istream& is);
|
2012-04-01 02:25:07 -06:00
|
|
|
|
2008-08-31 23:59:13 -06:00
|
|
|
namespace {
|
|
|
|
|
2011-12-03 02:41:50 -07:00
|
|
|
// FEN string of the initial position, normal chess
|
|
|
|
const char* StartFEN = "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1";
|
2010-08-19 10:55:32 -06:00
|
|
|
|
2013-12-02 11:04:09 -07:00
|
|
|
// Keep a track of the position keys along the setup moves (from the start position
|
|
|
|
// to the position just before the search starts). This is needed by the repetition
|
|
|
|
// draw detection code.
|
2012-08-27 06:39:59 -06:00
|
|
|
Search::StateStackPtr SetupStates;
|
|
|
|
|
2008-08-31 23:59:13 -06:00
|
|
|
|
2013-06-22 04:45:14 -06:00
|
|
|
// position() is called when engine receives the "position" UCI command.
|
2013-12-04 23:18:12 -07:00
|
|
|
// The function sets up the position described in the given FEN string ("fen")
|
2012-08-26 10:07:54 -06:00
|
|
|
// or the starting position ("startpos") and then makes the moves given in the
|
|
|
|
// following move list ("moves").
|
2008-08-31 23:59:13 -06:00
|
|
|
|
2013-06-22 04:45:14 -06:00
|
|
|
void position(Position& pos, istringstream& is) {
|
2008-09-01 00:06:34 -06:00
|
|
|
|
2011-07-17 03:22:08 -06:00
|
|
|
Move m;
|
2011-04-26 03:19:57 -06:00
|
|
|
string token, fen;
|
2008-08-31 23:59:13 -06:00
|
|
|
|
2011-07-24 00:22:37 -06:00
|
|
|
is >> token;
|
2008-09-01 00:16:17 -06:00
|
|
|
|
|
|
|
if (token == "startpos")
|
2010-12-13 03:17:06 -07:00
|
|
|
{
|
2011-12-03 02:41:50 -07:00
|
|
|
fen = StartFEN;
|
2011-07-24 00:22:37 -06:00
|
|
|
is >> token; // Consume "moves" token if any
|
2010-12-13 03:17:06 -07:00
|
|
|
}
|
2011-01-09 06:45:49 -07:00
|
|
|
else if (token == "fen")
|
2011-07-24 00:22:37 -06:00
|
|
|
while (is >> token && token != "moves")
|
2011-01-09 06:45:49 -07:00
|
|
|
fen += token + " ";
|
2011-07-24 00:22:37 -06:00
|
|
|
else
|
|
|
|
return;
|
2011-01-09 03:22:59 -07:00
|
|
|
|
2013-07-31 01:33:26 -06:00
|
|
|
pos.set(fen, Options["UCI_Chess960"], Threads.main());
|
2012-08-27 06:39:59 -06:00
|
|
|
SetupStates = Search::StateStackPtr(new std::stack<StateInfo>());
|
2008-08-31 23:59:13 -06:00
|
|
|
|
2011-07-20 02:01:12 -06:00
|
|
|
// Parse move list (if any)
|
2011-07-24 00:22:37 -06:00
|
|
|
while (is >> token && (m = move_from_uci(pos, token)) != MOVE_NONE)
|
2011-07-18 02:20:37 -06:00
|
|
|
{
|
2012-08-27 06:39:59 -06:00
|
|
|
SetupStates->push(StateInfo());
|
|
|
|
pos.do_move(m, SetupStates->top());
|
2011-07-18 02:20:37 -06:00
|
|
|
}
|
2008-08-31 23:59:13 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2013-06-22 04:45:14 -06:00
|
|
|
// setoption() is called when engine receives the "setoption" UCI command. The
|
2011-12-03 02:41:50 -07:00
|
|
|
// function updates the UCI option ("name") to the given value ("value").
|
2008-08-31 23:59:13 -06:00
|
|
|
|
2013-06-22 04:45:14 -06:00
|
|
|
void setoption(istringstream& is) {
|
2008-09-01 00:06:34 -06:00
|
|
|
|
2011-07-17 05:26:50 -06:00
|
|
|
string token, name, value;
|
2008-09-01 00:16:17 -06:00
|
|
|
|
2011-07-24 00:22:37 -06:00
|
|
|
is >> token; // Consume "name" token
|
2010-01-07 03:59:32 -07:00
|
|
|
|
2011-07-17 05:26:50 -06:00
|
|
|
// Read option name (can contain spaces)
|
2011-07-24 00:22:37 -06:00
|
|
|
while (is >> token && token != "value")
|
2011-07-17 05:26:50 -06:00
|
|
|
name += string(" ", !name.empty()) + token;
|
2009-07-10 10:34:56 -06:00
|
|
|
|
2011-07-17 05:26:50 -06:00
|
|
|
// Read option value (can contain spaces)
|
2011-07-24 00:22:37 -06:00
|
|
|
while (is >> token)
|
2011-07-17 05:26:50 -06:00
|
|
|
value += string(" ", !value.empty()) + token;
|
2010-11-03 02:32:14 -06:00
|
|
|
|
2012-03-17 14:18:02 -06:00
|
|
|
if (Options.count(name))
|
2011-12-28 10:27:18 -07:00
|
|
|
Options[name] = value;
|
2012-03-17 14:18:02 -06:00
|
|
|
else
|
2012-08-29 05:28:59 -06:00
|
|
|
sync_cout << "No such option: " << name << sync_endl;
|
2008-08-31 23:59:13 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-12-03 02:41:50 -07:00
|
|
|
// go() is called when engine receives the "go" UCI command. The function sets
|
2013-01-06 04:49:01 -07:00
|
|
|
// the thinking time and other parameters from the input string, and starts
|
2012-03-27 04:27:57 -06:00
|
|
|
// the search.
|
2008-08-31 23:59:13 -06:00
|
|
|
|
2013-02-08 02:05:04 -07:00
|
|
|
void go(const Position& pos, istringstream& is) {
|
2008-09-01 00:06:34 -06:00
|
|
|
|
2011-11-27 09:07:17 -07:00
|
|
|
Search::LimitsType limits;
|
2012-03-27 04:27:57 -06:00
|
|
|
string token;
|
2008-08-31 23:59:13 -06:00
|
|
|
|
2011-07-24 00:22:37 -06:00
|
|
|
while (is >> token)
|
2008-09-01 00:16:17 -06:00
|
|
|
{
|
2012-10-28 04:09:47 -06:00
|
|
|
if (token == "searchmoves")
|
2011-07-24 00:22:37 -06:00
|
|
|
while (is >> token)
|
2014-02-09 09:31:45 -07:00
|
|
|
limits.searchmoves.push_back(move_from_uci(pos, token));
|
2012-10-28 04:09:47 -06:00
|
|
|
|
|
|
|
else if (token == "wtime") is >> limits.time[WHITE];
|
|
|
|
else if (token == "btime") is >> limits.time[BLACK];
|
|
|
|
else if (token == "winc") is >> limits.inc[WHITE];
|
|
|
|
else if (token == "binc") is >> limits.inc[BLACK];
|
|
|
|
else if (token == "movestogo") is >> limits.movestogo;
|
|
|
|
else if (token == "depth") is >> limits.depth;
|
|
|
|
else if (token == "nodes") is >> limits.nodes;
|
|
|
|
else if (token == "movetime") is >> limits.movetime;
|
2012-12-30 03:40:20 -07:00
|
|
|
else if (token == "mate") is >> limits.mate;
|
2012-10-28 04:09:47 -06:00
|
|
|
else if (token == "infinite") limits.infinite = true;
|
|
|
|
else if (token == "ponder") limits.ponder = true;
|
2008-08-31 23:59:13 -06:00
|
|
|
}
|
2011-12-03 02:41:50 -07:00
|
|
|
|
2014-02-09 09:31:45 -07:00
|
|
|
Threads.start_thinking(pos, limits, SetupStates);
|
2008-08-31 23:59:13 -06:00
|
|
|
}
|
2014-04-12 04:05:25 -06:00
|
|
|
|
|
|
|
} // namespace
|
|
|
|
|
|
|
|
|
|
|
|
/// Wait for a command from the user, parse this text string as an UCI command,
|
|
|
|
/// and call the appropriate functions. Also intercepts EOF from stdin to ensure
|
|
|
|
/// that we exit gracefully if the GUI dies unexpectedly. In addition to the UCI
|
|
|
|
/// commands, the function also supports a few debug commands.
|
|
|
|
|
2014-04-12 04:52:10 -06:00
|
|
|
void UCI::loop(int argc, char* argv[]) {
|
2014-04-12 04:05:25 -06:00
|
|
|
|
|
|
|
Position pos(StartFEN, false, Threads.main()); // The root position
|
2014-04-12 04:52:10 -06:00
|
|
|
string token, cmd;
|
|
|
|
|
|
|
|
for (int i = 1; i < argc; ++i)
|
|
|
|
cmd += std::string(argv[i]) + " ";
|
2014-04-12 04:05:25 -06:00
|
|
|
|
|
|
|
do {
|
2014-04-12 04:52:10 -06:00
|
|
|
if (argc == 1 && !getline(cin, cmd)) // Block here waiting for input
|
2014-04-12 04:05:25 -06:00
|
|
|
cmd = "quit";
|
|
|
|
|
|
|
|
istringstream is(cmd);
|
|
|
|
|
|
|
|
is >> skipws >> token;
|
|
|
|
|
|
|
|
if (token == "quit" || token == "stop" || token == "ponderhit")
|
|
|
|
{
|
|
|
|
// The GUI sends 'ponderhit' to tell us to ponder on the same move the
|
|
|
|
// opponent has played. In case Signals.stopOnPonderhit is set we are
|
|
|
|
// waiting for 'ponderhit' to stop the search (for instance because we
|
|
|
|
// already ran out of time), otherwise we should continue searching but
|
|
|
|
// switch from pondering to normal search.
|
|
|
|
if (token != "ponderhit" || Search::Signals.stopOnPonderhit)
|
|
|
|
{
|
|
|
|
Search::Signals.stop = true;
|
|
|
|
Threads.main()->notify_one(); // Could be sleeping
|
|
|
|
}
|
|
|
|
else
|
|
|
|
Search::Limits.ponder = false;
|
|
|
|
}
|
2014-05-23 20:31:36 -06:00
|
|
|
else if (token == "perft" || token == "divide")
|
2014-04-12 04:05:25 -06:00
|
|
|
{
|
2014-05-23 20:31:36 -06:00
|
|
|
int depth;
|
2014-04-12 04:05:25 -06:00
|
|
|
stringstream ss;
|
|
|
|
|
2014-05-23 20:31:36 -06:00
|
|
|
is >> depth;
|
2014-04-12 04:05:25 -06:00
|
|
|
ss << Options["Hash"] << " "
|
2014-05-23 20:31:36 -06:00
|
|
|
<< Options["Threads"] << " " << depth << " current " << token;
|
2014-04-12 04:05:25 -06:00
|
|
|
|
|
|
|
benchmark(pos, ss);
|
|
|
|
}
|
|
|
|
else if (token == "key")
|
|
|
|
sync_cout << hex << uppercase << setfill('0')
|
|
|
|
<< "position key: " << setw(16) << pos.key()
|
|
|
|
<< "\nmaterial key: " << setw(16) << pos.material_key()
|
|
|
|
<< "\npawn key: " << setw(16) << pos.pawn_key()
|
2014-04-26 01:20:37 -06:00
|
|
|
<< dec << nouppercase << setfill(' ') << sync_endl;
|
2014-04-12 04:05:25 -06:00
|
|
|
|
|
|
|
else if (token == "uci")
|
|
|
|
sync_cout << "id name " << engine_info(true)
|
|
|
|
<< "\n" << Options
|
|
|
|
<< "\nuciok" << sync_endl;
|
|
|
|
|
2014-05-26 13:39:48 -06:00
|
|
|
else if (token == "eval")
|
|
|
|
{
|
|
|
|
Search::RootColor = pos.side_to_move(); // Ensure it is set
|
|
|
|
sync_cout << Eval::trace(pos) << sync_endl;
|
|
|
|
}
|
2014-05-31 01:16:54 -06:00
|
|
|
else if (token == "ucinewgame") { /* Avoid returning "Unknown command" */ }
|
2014-04-12 04:05:25 -06:00
|
|
|
else if (token == "go") go(pos, is);
|
|
|
|
else if (token == "position") position(pos, is);
|
|
|
|
else if (token == "setoption") setoption(is);
|
|
|
|
else if (token == "flip") pos.flip();
|
|
|
|
else if (token == "bench") benchmark(pos, is);
|
|
|
|
else if (token == "d") sync_cout << pos.pretty() << sync_endl;
|
|
|
|
else if (token == "isready") sync_cout << "readyok" << sync_endl;
|
|
|
|
else
|
|
|
|
sync_cout << "Unknown command: " << cmd << sync_endl;
|
|
|
|
|
2014-04-12 04:52:10 -06:00
|
|
|
} while (token != "quit" && argc == 1); // Passed args have one-shot behaviour
|
2014-04-12 04:05:25 -06:00
|
|
|
|
|
|
|
Threads.wait_for_think_finished(); // Cannot quit whilst the search is running
|
2008-08-31 23:59:13 -06:00
|
|
|
}
|