Fix incorrect draw detection
[stockfish] / src / uci.cpp
index c18cfc35309a3ac9a4a0ab039e6097b5ba47aef2..a9811a9af7352ae74308979a4751721b6bfcc042 100644 (file)
@@ -1,7 +1,8 @@
 /*
   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
   Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
 /*
   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
   Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2012 Marco Costalba, Joona Kiiski, Tord Romstad
+  Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad
+  Copyright (C) 2015-2016 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
 #include <string>
 
 #include "evaluate.h"
 #include <string>
 
 #include "evaluate.h"
-#include "notation.h"
+#include "movegen.h"
 #include "position.h"
 #include "search.h"
 #include "thread.h"
 #include "position.h"
 #include "search.h"
 #include "thread.h"
-#include "tt.h"
-#include "ucioption.h"
+#include "timeman.h"
+#include "uci.h"
 
 using namespace std;
 
 
 using namespace std;
 
@@ -38,215 +39,251 @@ namespace {
   // FEN string of the initial position, normal chess
   const char* StartFEN = "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1";
 
   // FEN string of the initial position, normal chess
   const char* StartFEN = "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1";
 
-  // Keep track of position keys along the setup moves (from start position to the
-  // position just before to start searching). Needed by repetition draw detection.
-  Search::StateStackPtr SetupStates;
+  // A list to keep track of the position states along the setup moves (from the
+  // start position to the position just before the search starts). Needed by
+  // 'draw by repetition' detection.
+  StateListPtr States(new std::deque<StateInfo>(1));
 
 
-  void set_option(istringstream& up);
-  void set_position(Position& pos, istringstream& up);
-  void go(Position& pos, istringstream& up);
-}
 
 
+  // position() is called when engine receives the "position" UCI command.
+  // The function sets up the position described in the given FEN string ("fen")
+  // or the starting position ("startpos") and then makes the moves given in the
+  // following move list ("moves").
 
 
-/// 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.
+  void position(Position& pos, istringstream& is) {
 
 
-void UCI::loop(const string& args) {
+    Move m;
+    string token, fen;
 
 
-  Position pos(StartFEN, false, Threads.main_thread()); // The root position
-  string cmd, token;
+    is >> token;
 
 
-  while (token != "quit")
-  {
-      if (!args.empty())
-          cmd = args;
+    if (token == "startpos")
+    {
+        fen = StartFEN;
+        is >> token; // Consume "moves" token if any
+    }
+    else if (token == "fen")
+        while (is >> token && token != "moves")
+            fen += token + " ";
+    else
+        return;
 
 
-      else if (!getline(cin, cmd)) // Block here waiting for input
-          cmd = "quit";
+    States = StateListPtr(new std::deque<StateInfo>(1));
+    pos.set(fen, Options["UCI_Chess960"], &States->back(), Threads.main());
 
 
-      istringstream is(cmd);
+    // Parse move list (if any)
+    while (is >> token && (m = UCI::to_move(pos, token)) != MOVE_NONE)
+    {
+        States->push_back(StateInfo());
+        pos.do_move(m, States->back(), pos.gives_check(m, CheckInfo(pos)));
+    }
+  }
 
 
-      is >> skipws >> token;
 
 
-      if (token == "quit" || token == "stop")
-      {
-          Search::Signals.stop = true;
-          Threads.wait_for_search_finished(); // Cannot quit while threads are running
-      }
+  // setoption() is called when engine receives the "setoption" UCI command. The
+  // function updates the UCI option ("name") to the given value ("value").
 
 
-      else if (token == "ponderhit")
-      {
-          // The opponent has played the expected move. GUI sends "ponderhit" if
-          // we were told to ponder on the same move the opponent has played. We
-          // should continue searching but switching from pondering to normal search.
-          Search::Limits.ponder = false;
-
-          if (Search::Signals.stopOnPonderhit)
-          {
-              Search::Signals.stop = true;
-              Threads.main_thread()->wake_up(); // Could be sleeping
-          }
-      }
+  void setoption(istringstream& is) {
 
 
-      else if (token == "go")
-          go(pos, is);
+    string token, name, value;
 
 
-      else if (token == "ucinewgame")
-          TT.clear();
+    is >> token; // Consume "name" token
+
+    // Read option name (can contain spaces)
+    while (is >> token && token != "value")
+        name += string(" ", name.empty() ? 0 : 1) + token;
+
+    // Read option value (can contain spaces)
+    while (is >> token)
+        value += string(" ", value.empty() ? 0 : 1) + token;
+
+    if (Options.count(name))
+        Options[name] = value;
+    else
+        sync_cout << "No such option: " << name << sync_endl;
+  }
+
+
+  // go() is called when engine receives the "go" UCI command. The function sets
+  // the thinking time and other parameters from the input string, then starts
+  // the search.
+
+  void go(const Position& pos, istringstream& is) {
+
+    Search::LimitsType limits;
+    string token;
+
+    limits.startTime = now(); // As early as possible!
+
+    while (is >> token)
+        if (token == "searchmoves")
+            while (is >> token)
+                limits.searchmoves.push_back(UCI::to_move(pos, token));
+
+        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;
+        else if (token == "mate")      is >> limits.mate;
+        else if (token == "infinite")  limits.infinite = 1;
+        else if (token == "ponder")    limits.ponder = 1;
+
+    Threads.start_thinking(pos, States, limits);
+  }
+
+} // namespace
+
+
+/// UCI::loop() waits for a command from stdin, parses it and calls the appropriate
+/// function. Also intercepts EOF from stdin to ensure gracefully exiting if the
+/// GUI dies unexpectedly. When called with some command line arguments, e.g. to
+/// run 'bench', once the command is executed the function returns immediately.
+/// In addition to the UCI ones, also some additional debug commands are supported.
 
 
-      else if (token == "isready")
-          sync_cout << "readyok" << sync_endl;
+void UCI::loop(int argc, char* argv[]) {
 
 
-      else if (token == "position")
-          set_position(pos, is);
+  Position pos;
+  string token, cmd;
 
 
-      else if (token == "setoption")
-          set_option(is);
+  pos.set(StartFEN, false, &States->back(), Threads.main());
 
 
-      else if (token == "d")
-          pos.print();
+  for (int i = 1; i < argc; ++i)
+      cmd += std::string(argv[i]) + " ";
 
 
-      else if (token == "flip")
-          pos.flip();
+  do {
+      if (argc == 1 && !getline(cin, cmd)) // Block here waiting for input or EOF
+          cmd = "quit";
 
 
-      else if (token == "eval")
-          sync_cout << Eval::trace(pos) << sync_endl;
+      istringstream is(cmd);
 
 
-      else if (token == "bench")
-          benchmark(pos, is);
+      token.clear(); // getline() could return empty or blank line
+      is >> skipws >> token;
 
 
-      else if (token == "key")
-          sync_cout << "key: " << hex     << pos.key()
-                    << "\nmaterial key: " << pos.material_key()
-                    << "\npawn key: "     << pos.pawn_key() << sync_endl;
+      // 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
+      // switching from pondering to normal search.
+      if (    token == "quit"
+          ||  token == "stop"
+          || (token == "ponderhit" && Search::Signals.stopOnPonderhit))
+      {
+          Search::Signals.stop = true;
+          Threads.main()->start_searching(true); // Could be sleeping
+      }
+      else if (token == "ponderhit")
+          Search::Limits.ponder = 0; // Switch to normal search
 
       else if (token == "uci")
           sync_cout << "id name " << engine_info(true)
                     << "\n"       << Options
                     << "\nuciok"  << sync_endl;
 
 
       else if (token == "uci")
           sync_cout << "id name " << engine_info(true)
                     << "\n"       << Options
                     << "\nuciok"  << sync_endl;
 
-      else if (token == "perft" && (is >> token)) // Read depth
+      else if (token == "ucinewgame")
       {
       {
+          Search::clear();
+          Time.availableNodes = 0;
+      }
+      else if (token == "isready")    sync_cout << "readyok" << sync_endl;
+      else if (token == "go")         go(pos, is);
+      else if (token == "position")   position(pos, is);
+      else if (token == "setoption")  setoption(is);
+
+      // Additional custom non-UCI commands, useful for debugging
+      else if (token == "flip")       pos.flip();
+      else if (token == "bench")      benchmark(pos, is);
+      else if (token == "d")          sync_cout << pos << sync_endl;
+      else if (token == "eval")       sync_cout << Eval::trace(pos) << sync_endl;
+      else if (token == "perft")
+      {
+          int depth;
           stringstream ss;
 
           stringstream ss;
 
+          is >> depth;
           ss << Options["Hash"]    << " "
           ss << Options["Hash"]    << " "
-             << Options["Threads"] << " " << token << " current perft";
+             << Options["Threads"] << " " << depth << " current perft";
 
           benchmark(pos, ss);
       }
 
           benchmark(pos, ss);
       }
-
       else
           sync_cout << "Unknown command: " << cmd << sync_endl;
 
       else
           sync_cout << "Unknown command: " << cmd << sync_endl;
 
-      if (!args.empty()) // Command line arguments have one-shot behaviour
-      {
-          Threads.wait_for_search_finished();
-          break;
-      }
-  }
+  } while (token != "quit" && argc == 1); // Passed args have one-shot behaviour
+
+  Threads.main()->wait_for_search_finished();
 }
 
 
 }
 
 
-namespace {
+/// UCI::value() converts a Value to a string suitable for use with the UCI
+/// protocol specification:
+///
+/// cp <x>    The score from the engine's point of view in centipawns.
+/// mate <y>  Mate in y moves, not plies. If the engine is getting mated
+///           use negative values for y.
 
 
-  // set_position() is called when engine receives the "position" UCI command.
-  // The function sets up the position described in the given fen string ("fen")
-  // or the starting position ("startpos") and then makes the moves given in the
-  // following move list ("moves").
+string UCI::value(Value v) {
 
 
-  void set_position(Position& pos, istringstream& is) {
+  stringstream ss;
 
 
-    Move m;
-    string token, fen;
+  if (abs(v) < VALUE_MATE - MAX_PLY)
+      ss << "cp " << v * 100 / PawnValueEg;
+  else
+      ss << "mate " << (v > 0 ? VALUE_MATE - v + 1 : -VALUE_MATE - v) / 2;
 
 
-    is >> token;
+  return ss.str();
+}
 
 
-    if (token == "startpos")
-    {
-        fen = StartFEN;
-        is >> token; // Consume "moves" token if any
-    }
-    else if (token == "fen")
-        while (is >> token && token != "moves")
-            fen += token + " ";
-    else
-        return;
 
 
-    pos.from_fen(fen, Options["UCI_Chess960"], Threads.main_thread());
-    SetupStates = Search::StateStackPtr(new std::stack<StateInfo>());
+/// UCI::square() converts a Square to a string in algebraic notation (g1, a7, etc.)
 
 
-    // Parse move list (if any)
-    while (is >> token && (m = move_from_uci(pos, token)) != MOVE_NONE)
-    {
-        SetupStates->push(StateInfo());
-        pos.do_move(m, SetupStates->top());
-    }
-  }
+std::string UCI::square(Square s) {
+  return std::string{ char('a' + file_of(s)), char('1' + rank_of(s)) };
+}
 
 
 
 
-  // set_option() is called when engine receives the "setoption" UCI command. The
-  // function updates the UCI option ("name") to the given value ("value").
+/// UCI::move() converts a Move to a string in coordinate notation (g1f3, a7a8q).
+/// The only special case is castling, where we print in the e1g1 notation in
+/// normal chess mode, and in e1h1 notation in chess960 mode. Internally all
+/// castling moves are always encoded as 'king captures rook'.
 
 
-  void set_option(istringstream& is) {
+string UCI::move(Move m, bool chess960) {
 
 
-    string token, name, value;
+  Square from = from_sq(m);
+  Square to = to_sq(m);
 
 
-    is >> token; // Consume "name" token
+  if (m == MOVE_NONE)
+      return "(none)";
 
 
-    // Read option name (can contain spaces)
-    while (is >> token && token != "value")
-        name += string(" ", !name.empty()) + token;
+  if (m == MOVE_NULL)
+      return "0000";
 
 
-    // Read option value (can contain spaces)
-    while (is >> token)
-        value += string(" ", !value.empty()) + token;
+  if (type_of(m) == CASTLING && !chess960)
+      to = make_square(to > from ? FILE_G : FILE_C, rank_of(from));
 
 
-    if (Options.count(name))
-        Options[name] = value;
-    else
-        sync_cout << "No such option: " << name << sync_endl;
-  }
+  string move = UCI::square(from) + UCI::square(to);
 
 
+  if (type_of(m) == PROMOTION)
+      move += " pnbrqk"[promotion_type(m)];
 
 
-  // go() is called when engine receives the "go" UCI command. The function sets
-  // the thinking time and other parameters from the input string, and then starts
-  // the search.
+  return move;
+}
 
 
-  void go(Position& pos, istringstream& is) {
 
 
-    Search::LimitsType limits;
-    vector<Move> searchMoves;
-    string token;
+/// UCI::to_move() converts a string representing a move in coordinate notation
+/// (g1f3, a7a8q) to the corresponding legal Move, if any.
 
 
-    while (is >> token)
-    {
-        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;
-        else if (token == "infinite")
-            limits.infinite = true;
-        else if (token == "ponder")
-            limits.ponder = true;
-        else if (token == "searchmoves")
-            while (is >> token)
-                searchMoves.push_back(move_from_uci(pos, token));
-    }
+Move UCI::to_move(const Position& pos, string& str) {
 
 
-    Threads.start_searching(pos, limits, searchMoves, SetupStates);
-  }
+  if (str.length() == 5) // Junior could send promotion piece in uppercase
+      str[4] = char(tolower(str[4]));
+
+  for (const auto& m : MoveList<LEGAL>(pos))
+      if (str == UCI::move(m, pos.is_chess960()))
+          return m;
+
+  return MOVE_NONE;
 }
 }