usercmd.cpp

Go to the documentation of this file.

/*---------------------------------------------------------------------+
 * File: usercmd.cpp
 * Project: part of belofte - A Promising Chess Program
 * Author: yves
 * SPDX-License-Identifier: GPL-2.0-only
+----------------------------------------------------------------------*/
 
#include "belofte.h"
 
//-----------------------------------------------------------------------
 
engineUserCommand::engineUserCommand(std::string const& s,
        std::string const& h)
  : m_name(s)
  , m_hint(h)
{
}
 
engineUserCommand::~engineUserCommand()
{
}
 
void engineUserCommand::execute(std::string const& args)
{
  AppEI()->sendError("unimplemented command, not executing",
          m_name + " <" + args + ">");
}
 
//-----------------------------------------------------------------------
 
UCIengineCommand::UCIengineCommand(std::string const& s,
        std::string const& h)
  : engineUserCommand(s, h)
{
}
 
UCIengineCommand::~UCIengineCommand()
{
}
 
Xboard1engineCommand::Xboard1engineCommand(std::string const& s,
        std::string const& h)
  : engineUserCommand(s, h)
{
}
 
Xboard1engineCommand::~Xboard1engineCommand()
{
}
 
Xboard2engineCommand::Xboard2engineCommand(std::string const& s,
        std::string const& h)
  : engineUserCommand(s, h)
{
}
 
Xboard2engineCommand::~Xboard2engineCommand()
{
}
 
dummyEngineCommand::dummyEngineCommand(std::string const& s,
        std::string const& h)
  : engineUserCommand(s, h)
{
  m_isImplemented = false;
}
 
dummyEngineCommand::~dummyEngineCommand()
{
}
 
//-----------------------------------------------------------------------
 
cmdParam::cmdParam()
  : m_command("")
  , m_args("")
{
}
 
cmdParam::~cmdParam()
{
}
 
//-----------------------------------------------------------------------
 
/**
 * Send help on command or all commands
 * @param args --all means all commands, "" or a single command
 * TODO: implement hidden command flag
 */
void engineInterface::sendHelp(std::string const& args)
{
  App().bout << "Help for " MYNAME " - mode: " << m_name << '\n';
  if (args == "") {
    for (auto const& ec : engineInterface::m_engineCommands) {
      engineUserCommand *v = engineInterface::m_engineCommands[ec.first];
      if (m_allowedCommands.find(v->m_name) != m_allowedCommands.end()) {
        if (v->m_isImplemented)
          App().bout << std::left << std::setw(10) << v->m_name
                << " - " << v->m_hint << '\n';
      }
    }
  } else if (args == "--all") {
    for (auto const& ec : engineInterface::m_engineCommands) {
      engineUserCommand *v = engineInterface::m_engineCommands[ec.first];
      bool bAllowed = m_allowedCommands.find(v->m_name) != m_allowedCommands.end();
      App().bout << std::left << std::setw(10) << v->m_name
              << " - " << v->m_hint
              << (v->m_isImplemented ? "" : " (*)")
              << (bAllowed ? "" : " (+)")
              << '\n';
    }
    App().bout << "\n*: Unimplemented.\n+: Extra";
  } else {
    if (engineInterface::m_engineCommands.find(args)
            != engineInterface::m_engineCommands.end()) {
      engineUserCommand *v = engineInterface::m_engineCommands[args];
      App().bout << std::left << std::setw(10) << v->m_name
              << " - " << v->m_hint << '\n';
      if (!v->m_isImplemented)
        App().bout << "\n** Unimplemented **";
    } else {
      App().bout << "Unknown command [" << args << "]";
    }
  }
  App().bout << std::endl;
}
 
void engineInterface::sendResponse(std::string const& response)
{
  App().bout << response << std::endl;
}
 
void engineInterface::sendError(std::string const& error,
        std::string const& description)
{
  App().bout << "ERROR: " << error
          << ((description != "") ? " (" + description + ")" : "")
          << std::endl;
}
 
void engineInterface::sendDebug(int const l, std::string const& info)
{
  if (App().bout.getVerbosity() >= l)
    App().bout << "# " << info << std::endl;
}
 
//-----------------------------------------------------------------------
 
void UCIMode::sendMove(bBoard const& b UNUSED, bMove const& m)
{
  App().sout << "bestmove " << bCoordMove(m) << std::endl;
 
  // TODO: retrieve ponder out of board
  // if (ponder != "") App().sout << " ponder " << ponder;
}
 
void UCIMode::sendDebug(int const l, std::string const& info)
{
  if (App().bout.getVerbosity() >= l)
    App().bout << "info string " << info << std::endl;
}
 
void UCIMode::sendInfoDepth(depth_t nDepth, depth_t seldepth,
        int64_t nodes, int nps)
{
  if (App().sout.getVerbosity() >= nDepth) {
    App().sout << "info depth " << static_cast<int>(nDepth)
            << " seldepth " << static_cast<int>(seldepth)
            << " nodes " << nodes
            << " nps " << nps << '\n';
  }
}
 
void UCIMode::sendInfoScore(long long timems,
        bBoard const& b, bScore const sc)
{
  if (App().sout.getVerbosity() >= 0) {
    App().sout << "info" << UCIMode::uciscorestring(sc);
    if (timems) {
      App().sout << " time " << belofte::to_string(timems);
    }
    if (b.getVariation().size()) {
      App().sout << bMove::getMoveSequenceStr(" pv",
              b.getPreviousMoves(), b.getVariation());
    }
    App().sout << std::endl;
  }
}
 
void UCIMode::sendInfoSearching(bBoard const& b, depth_t const nLogDepth,
        depth_t const nMaxDepth DEVUNUSED, std::string const& comment,
        bScore const sc, int64_t const timems, int64_t const nodes) const
{
  if (App().sout.getVerbosity() >= nLogDepth) {
    std::stringstream sOut;
    sOut << "info"
            " depth " << static_cast<int>(nLogDepth);
    if (nLogDepth != nMaxDepth) sOut << " seldepth " << static_cast<int>(nMaxDepth);
    sOut << " time " << belofte::to_string(timems);
    if (timems > 10) {
      sOut  << " nodes " << belofte::to_string(nodes)
              << " nps " << belofte::to_string((nodes * 1000)/ timems);
    }
    sOut << UCIMode::uciscorestring(sc);
    int nVariationDepth = static_cast<int>(b.getVariation().size());
    if ((nLogDepth == 0) && nVariationDepth) {
      sOut << bMove::getMoveSequenceStr(" pv",
              b.getPreviousMoves(), b.getVariation());
    } else {
      if (App().getConfig("UCI_ShowCurrLine", 0)
              && b.getPreviousMoves().size()) {
        sOut << bMove::getMoveSequenceStr(" currline", b.getPreviousMoves());
      }
      if (nVariationDepth) {
        sOut << bMove::getMoveSequenceStr(" pv",
                b.getPreviousMoves(), b.getVariation());
      }
    }
    if ((comment != "") && App().getConfig("debug", 0))
      sOut << " string " << comment;
    App().sout << sOut.str() << '\n';
  }
}
 
void UCIMode::sendInfoCurrMove(bBoard const& b, depth_t const nLogDepth,
        depth_t const nMaxDepth DEVUNUSED, std::string const& comment DEVUNUSED,
        bMove const& mv, movenum_t const moveid, int64_t const nodes) const
{
  if (App().sout.getVerbosity() >= nLogDepth) {
    std::stringstream sOut;
    sOut << "info"
            " depth " << static_cast<int>(nLogDepth);
    if (nLogDepth != nMaxDepth) sOut << " seldepth " << static_cast<int>(nMaxDepth);
    sOut << " nodes " << belofte::to_string(nodes)
            << " currmovenumber " << static_cast<int>(moveid)
            << " currmove " << mv;
    int nVariationDepth = static_cast<int>(b.getVariation().size());
    if (App().getConfig("UCI_ShowCurrLine", 0)
              && nVariationDepth) {
      sOut << bMove::getMoveSequenceStr(" currline", b.getPreviousMoves());
    }
#if !defined(_DEBUG)
    if ((comment != "") && App().getConfig("debug", 0))
      sOut << " string " << comment;
#endif
    App().sout << sOut.str() << '\n';
  }
}
 
//-----------------------------------------------------------------------
 
void engineInterface::sendPrompt()
{
  App().bout << MYLCNAME << "> ";
}
 
void engineInterface::sendMove(bBoard const& b, bMove const& m)
{
  App().sout << "move " << bPgnMove(b, m) << std::endl;
}
 
void engineInterface::sendResult(bBoard& b, gameResult_t const rs) const
{
  if (rs != GR_UNKNOWN) {
    // end of game, so stop running
    AppEI()->setRunning(false);
    App().sout << Game()->getResult(rs);
    if ((rs >= GR_DRAW_STALEMATE) && (rs <= GR_DRAW_OTHER)) {
      gameResult_t nrs = Game()->EvalFinalScore(b);
      if (nrs == GR_DRAW_STALEMATE) {
        App().sout << " {Stalemate}";
      } else if (nrs == GR_DRAW_LACKMATERIAL) {
        App().sout << " {Draw by insufficient material}";
      } else if (nrs == GR_DRAW_THREEFOLD) {
        App().sout << " {Draw by repetition}";
      } else if (nrs == GR_DRAW_50) {
        App().sout << " {50 move rule}";
      } else {
        App().sout << " {Draw}";
      }
    } else if ((rs >= GR_WHITEMATES) && (rs <= GR_WHITEWINS_FLAG)) {
      App().sout << " {White mates}";
    } else {
      App().sout << " {Black mates}";
    }
    App().sout << std::endl;
  }
}
 
void XboardMode::sendInvalidMove(std::string const& mv,
        std::string const& reason)
{
  App().bout << "Illegal move: " << mv
          << ((reason != "") ? " (" + reason + ")" : "")
          << std::endl;
}
 
void XboardMode::sendInfoSearching(bBoard const& b, depth_t const nLogDepth,
        depth_t const nMaxDepth, std::string const& comment UNUSED,
        bScore const sc, int64_t const t, int64_t const nodes) const
{
  if (App().sout.getVerbosity() >= nLogDepth) {
    int nVariationDepth = static_cast<int>(b.getVariation().size());
    std::stringstream sNew;
    if (((sc & SCORE_POSITIVE) != SCORE_PUNDEFINED)
        && (nVariationDepth)) {
      sNew << bMove::getMoveSequenceStr("",
              b.getPreviousMoves(), b.getVariation());
      if (sNew.str().size()) {
        static std::string& sOld = *new std::string();
        if (sNew.str() != sOld) {
          // only post updates
          sOld = sNew.str();
          App().sout << " " << std::setw(3) << nVariationDepth
                  << (nVariationDepth == nMaxDepth ? " " : "&")
                  << " " << std::setw(8) << belofte::to_string(sc)
                  << " " << std::setw(6) << (t / 10)
                  << " " << std::setw(8) << nodes
                  << sOld << '\n';
        }
      }
    }
  }
}
 
//-----------------------------------------------------------------------
// command implementation
 
void cmd_help::execute(std::string const& args)
{
  AppEI()->sendHelp(args);
}
 
void cmd_quit::execute(std::string const& args UNUSED)
{
  App().bout << "Bye" << std::endl;
  throw quitCommandException();
}
 
void cmd_about::execute(std::string const& args UNUSED)
{
  App().bout << App().getConfig("enginename", "") << '\n'
          << App().getConfig("author", "")
          << std::endl;
}
 
void cmd_usage::execute(std::string const& args)
{
  App().bout << "Usage: " << args << " [options] [[@]script] \n"
          << "\t--help\tThis help message\n"
          << "\t--version\tShow version information and exit\n"
          << "\t--uci\t\tUse UCI interface\n"
          << "\t--xboard\tUse Xboard/Winboard interface\n"
          << "\t--bench\t\tRun benchmark and exit\n"
          << "\t[script]\tcontaining commands to execute."
          << std::endl;
}
 
void cmd_uci::execute(std::string const& args UNUSED)
{
  App().setMode("uci");
  AppEI()->sendResponse("");
  AppEI()->sendResponse("id name " MYFULLNAME " (u)");
  AppEI()->sendResponse("id author " MYAUTHOR);
  /// @todo specific implementation of option
  AppEI()->sendResponse("option name alg type combo default " + Game()->setAlgorithm() + " "
                        "var Random var StaticEval var BruteForce "
                        "var SearchIterativeBF var AB var ABFS var ABFH");
  AppEI()->sendResponse("option name evaltype type combo default " + Game()->setEval() + " "
                        "var PiecesOnly var StaticBoard var PositionalBoard");
  AppEI()->sendResponse("option name UCI_ShowCurrLine type check default false");
  AppEI()->sendResponse("option name UCI_EngineAbout type string default "
                        + App().getConfig("about", ""));
  AppEI()->sendResponse("option name UCI_Opponent type string default <empty>");
  AppEI()->sendResponse("option name UCI_Variant type combo default normal "
                        "var normal");
  // TODO: option name UCI_Chess960 type check default false
  //       setoption name UCI_Chess960 value true
  //       setoption name UCI_Variant value fischerandom
  // TODO: option name UCI_AnalyseMode
  AppEI()->sendResponse("uciok");
}
 
void cmd_xboard::execute(std::string const& args UNUSED)
{
  App().setMode("xboard");
  App().bout << std::endl;
}
 
void cmd_belofte::execute(std::string const& args UNUSED)
{
  App().setMode("belofte");
}
 
/** execute command file with @ command
 *  @warning command will do noting but change mode
 *  @see commandReader::runner() for actual parsing
 */
void cmd_execat::execute(std::string const& args)
{
  if (args.substr(0,1) == "@") {
    App().m_reader.attach(args.substr(1));
  } else {
    App().m_reader.attach(args);
  }
}
 
/** execute command file with exec command
 *  @warning command will do noting but change mode
 *  @see commandReader::runner() for actual parsing
 */
void cmd_exec::execute(std::string const& args)
{
  App().m_reader.attach(args);
}
 
void cmd_echo::execute(std::string const& args)
{
  AppEI()->sendResponse(args);
}
 
/** check if engine still alive, doing delayed constructors
 */
void cmd_isready::execute(std::string const& args UNUSED)
{
  // readyok to be sent only after newgame has finished
  AppEI()->sendResponse("readyok");
}
 
/** check if engine still alive, doing delayed constructors
 */
void cmd_ping::execute(std::string const& args)
{
  AppEI()->sendResponse("pong " + args);
}
 
void cmd_ucinewgame::execute(std::string const& args UNUSED)
{
  Game()->newGame();
}
 
void cmd_debug::execute(std::string const& args)
{
  App().m_debuginterface.execute(args);
}
 
/** Read setoption command
 *  TODO: allow value parameter with space in it
 */
void cmd_setoption::execute(std::string const& args)
{
  belofte::stringList const sOptions = belofte::stringSplit(args, " ");
  if (sOptions.size() >= 3) {
    /// @todo get array from initialisation
    std::string const opt[] = {"alg", "evaltype", "UCI_ShowCurrLine", "UCI_Opponent", "UCI_EngineAbout"};
    if (std::find(std::begin(opt), std::end(opt), sOptions[1])
            != std::end(opt)) {
      /// @todo change to specific setoption function
      if (sOptions.size() == 3) {
        AppEI()->execute(sOptions[1], "");
      } else {
        std::string sParams = std::accumulate(sOptions.begin() + 3, sOptions.end(), std::string(),
          [](std::string result, std::string sElem) {
            return std::move(result) + std::move(sElem) + " ";
          });
        AppEI()->execute(sOptions[1], sParams);
      }
    } else {
      AppEI()->sendError("command not understood", args);
    }
  } else {
    AppEI()->sendError("bad command parameters", args);
  }
}
 
/** set start position, alternatives
 * args = [fen fenstring | startpos ] moves move1 .... movei
 * attention: should do noting if position set is identical to actual position
 */
void cmd_position::execute(std::string const& args)
{
  std::string startorfen = args.substr(0, args.find(' '));
  std::size_t iMoves = args.find("moves ");
  if (startorfen == "startpos" || startorfen == "") {
    Game()->setFENInitialPos();
    if (iMoves != std::string::npos) {
      if (!Game()->playGameMoveSeries(args.substr(static_cast<unsigned long>(iMoves) + 6)))
        AppEI()->sendInvalidMove(args.substr(static_cast<unsigned long>(iMoves) + 6), "");
    }
  } else if (startorfen == "fen") {
    if (iMoves != std::string::npos) {
      Game()->setFEN(args.substr(4, static_cast<unsigned long>(iMoves) - 4));
      if (!Game()->playGameMoveSeries(args.substr(static_cast<unsigned long>(iMoves) + 6)))
        AppEI()->sendInvalidMove(args.substr(static_cast<unsigned long>(iMoves) + 6), "");
    } else {
      Game()->setFEN(args.substr(4));
    }
  } else {
    AppEI()->sendError("invalid parameter for position", args);
  }
}
 
void cmd_bench::execute(std::string const& args)
{
  depth_t nDepth = 5;
 
  if (args.size()) {
    belofte::stringList const goOptions = belofte::stringSplit(args, " ");
    if (atoi(goOptions[0].c_str()) > 0) nDepth = static_cast<depth_t>(atoi(goOptions[0].c_str()));
  }
 
  { SearchPerft search; bel_debug::run_bench(search, nDepth); }
  { SearchBruteForce search; bel_debug::run_bench(search, nDepth); }
  { SearchAlphaBeta search; bel_debug::run_bench(search, nDepth); }
 
  Game()->newGame();
  Game()->setFENInitialPos();
}
 
void cmd_perft::execute(std::string const& args)
{
  belofte::stringList const perftOptions = belofte::stringSplit(args, " ");
 
  SearchPerft search;
  int64_t nNodes = Game()->DoPerft(static_cast<depth_t>(atoi(perftOptions[0].c_str())), search);
  int64_t nNonLeafNodes = search.getNonLeafNodes();
 
  std::string sNodes = belofte::to_string(nNodes);
  std::string sTotalNodes = belofte::to_string(nNodes + nNonLeafNodes);
  std::string sNPS = "0";
  if ((nNodes + nNonLeafNodes) > 0LL) {
    sNPS = belofte::to_string(
            (nNodes + nNonLeafNodes) * 1000000LL / search.getDurationMicroSec());
  }
 
  if (App().bout.checkExpected(sNodes)) {
    App().bout << "perft " << args << " -> " << sNodes
            << " (Total: " << sTotalNodes
            << ") <- Execution time = " << search.getDuration()
            << " NPS " << sNPS
            << std::endl;
  } else {
    AppEI()->sendError("Expectation missed",
            "perft " + args + " -> " + sNodes + " instead of <- "
            + App().bout.getExpecting());
  }
  // clear expect flag
  App().bout.setExpecting("");
}
 
/** Parse epd position or epd file
 * e.g. epd pos fen-epd fen-params
 *      epd [file] filename
 */
void cmd_epd::execute(std::string const& args)
{
  epdTest_t typeOfTest = tEpdTestType::EPD_GENERIC;
  belofte::stringList sParams = belofte::stringSplit(args, " ");
 
  // remove any modifier flags
  if (std::any_of(sParams.begin(), sParams.end(),
            [](std::string const& s)
            { return s == "-perf"; })) {
    sParams.erase(sParams.begin() + 1);
    typeOfTest = tEpdTestType::EPD_PERF;
  }
 
  if (std::any_of(sParams.begin(), sParams.end(),
            [](std::string const& s)
            { return s == "-sts"; })) {
    sParams.erase(sParams.begin() + 1);
    typeOfTest = tEpdTestType::EPD_STS;
  }
 
  if (sParams[0] == "pos") {
    sParams.erase(sParams.begin());
    bEpdPos epd(sParams);
    epd.parse(typeOfTest);
  } else if (sParams[0] == "file") {
    sParams.erase(sParams.begin());
    bEpdFile epd(sParams);
    epd.parse(typeOfTest);
  } else {
    // same as epd file
    bEpdFile epd(args);
    epd.parse(typeOfTest);
  }
}
 
/** Parse epd position
 * e.g. epdpos fen-epd fen-params
 */
void cmd_epdpos::execute(std::string const& args)
{
  bEpdPos epd(args);
  epd.parse(tEpdTestType::EPD_GENERIC);
}
 
void cmd_go::execute(std::string const& args)
{
  belofte::stringList const goOptions = belofte::stringSplit(args, " ");
  bLevel level;
  depth_t nDepth, nMate;
  int nInf, nTime, nInc, nMoves, nMoveTime, nPonder;
  int64_t nNodes;
 
  nDepth = static_cast<depth_t>(belofte::positionParamValue(goOptions, "depth", 1));
  nInf = belofte::positionParamIndex(goOptions, "infinite");
 
  if (Game()->getCurrentPosition().whiteToMove()) {
    nTime = belofte::positionParamValue(goOptions, "wtime", 1);
    nInc = belofte::positionParamValue(goOptions, "winc", 1);
  } else {
    nTime = belofte::positionParamValue(goOptions, "btime", 1);
    nInc = belofte::positionParamValue(goOptions, "binc", 1);
  }
 
  nMoves = belofte::positionParamValue(goOptions, "movestogo", 1);
  nMoveTime = belofte::positionParamValue(goOptions, "movetime", 1);
 
  nNodes = belofte::positionParamValue(goOptions, "nodes", 1);
  nMate = static_cast<depth_t>(belofte::positionParamValue(goOptions, "mate", 1));
  nPonder = belofte::positionParamIndex(goOptions, "ponder");
 
  if (belofte::positionParamIndex(goOptions, "searchmoves") != -1) {
    // TODO: add searchmoves
  }
 
  if (nInf != -1) {
    level.setInfinite();
  } else if (nMoveTime != -1) {
    level.setMoveTime(nMoveTime);
  } else if (nTime != -1) {
    if (nInc != -1) {
      if (nMoves != -1) level.setMoveTime(nTime, nMoves, nInc);
      else level.setGameTime(nTime, nInc);
    } else {
      if (nMoves != -1) level.setMoveTime(nTime, nMoves);
      else level.setGameTime(nTime);
    }
  } else if (nMate != -1) {
    level.setMateSearch(nMate);
  }
 
  if (nDepth != -1) level.setDepth(nDepth);
  if (nNodes != -1) level.setNodes(nNodes);
  if (nPonder != -1) level.setPondering();
 
  if (args != "") {
    Game()->setLevel(level);
  } else if ((App().getMode() != "xboard")
             && (Game()->getLevel().getType() != LevelType::Infinite)
             && (Game()->getLevel().getType() != LevelType::MateSearch)
             && (Game()->getLevel().getType() != LevelType::Unset)) {
    // no arguments passed in uci mode, so we use previously set level
    // but with cleared nodes and depth limitation, unless required to
    // abort search
    Game()->getLevel().setDepth(0);
    Game()->getLevel().setNodes(0);
  }
  AppEI()->setRunning(true);
  Game()->DoSearch();
}
 
void cmd_again::execute(std::string const& args UNUSED)
{
  Game()->revertGameMove();
  AppEI()->execute("go", "");
}
 
void cmd_usermove::execute(std::string const& args)
{
  Game()->playUIsuppliedMove(args);
}
 
void cmd_questionmark::execute(std::string const& args UNUSED)
{
  Game()->AbortSearch();
}
 
void cmd_stop::execute(std::string const& args UNUSED)
{
  Game()->AbortSearch();
}
 
void cmd_save::execute(std::string const& args UNUSED)
{
  /// @todo save to file
  App().bout << Game()->operator std::string() << '\n';
}
 
void cmd_game::execute(std::string const& args UNUSED)
{
  App().bout << Game()->operator std::string() << '\n';
}
 
void cmd_bd::execute(std::string const& args UNUSED)
{
  bBoard const& b = Game()->getCurrentPosition();
  App().bout << b.operator std::string() << '\n';
}
 
void cmd_undo::execute(std::string const& args UNUSED)
{
  Game()->revertGameMove();
}
 
void cmd_easy::execute(std::string const& args UNUSED)
{
  Game()->getLevel().clearPondering();
}
 
void cmd_hard::execute(std::string const& args UNUSED)
{
  Game()->getLevel().setPondering();
}
 
void cmd_verbose::execute(std::string const& args)
{
  App().sout.setVerbosity(atoi(args.c_str()));
}
 
#if !defined(NODIRENT)
void cmd_ls::execute(std::string const& args)
{
  /// @todo does not compile with mingw cross compiler
  std::string curdir = ".";
  DIR *hDir;
  if (args.length()) curdir = args + ".";
 
  hDir = opendir(curdir.c_str());
  if (hDir) {
    struct dirent *hFile;
    while ((hFile = readdir(hDir)) != nullptr) {
      std::string sFile(hFile->d_name);
      if (sFile[0] == '.') continue;
      App().bout << sFile << std::endl;
    }
    closedir(hDir);
  }
}
#endif
 
void cmd_expect::execute(std::string const& args)
{
  App().bout.setExpecting(args);
}
 
void cmd_new::execute(std::string const& args UNUSED)
{
  Game()->newGame();
  Game()->getLevel().initDepths(INFINITE_DEPTH);
  Game()->setFENInitialPos();
  AppEI()->setRunning(true);
}
 
void cmd_setboard::execute(std::string const& args)
{
  Game()->setFEN(belofte::alltrim(args));
}
 
void cmd_remove::execute(std::string const& args UNUSED)
{
  Game()->revertGameMove();
  Game()->revertGameMove();
}
 
void cmd_protover::execute(std::string const& args UNUSED)
{
  if (App().getMode() != "xboard") {
    AppEI()->execute("xboard", "");
  }
  AppEI()->sendResponse("feature done=0");
  AppEI()->sendResponse("feature ping=1 setboard=1 playother=1");
  AppEI()->sendResponse("feature usermove=1 time=1 draw=0");
  AppEI()->sendResponse("feature variants=\"normal\"");
#if defined(BELOFTE_NOSIGNALS)
  AppEI()->sendResponse("feature sigint=0 sigterm=0");
#else
  AppEI()->sendResponse("feature sigint=1 sigterm=1");
#endif
  AppEI()->sendResponse("feature analyze=0 debug=1 colors=0");
  AppEI()->sendResponse("feature name=1");
  AppEI()->sendResponse("feature myname=\"" MYFULLNAME " (wb)\"");
  AppEI()->sendResponse("feature option=\"alg -combo AB /// Random /// StaticEval /// "
                       "BruteForce /// SearchIterativeBF /// ABFS /// ABFH\"");
  AppEI()->sendResponse("feature option=\"evaltype -combo "
                        "PositionalBoard /// PiecesOnly /// StaticBoard \"");
  AppEI()->sendResponse("feature done=1");
}
 
void cmd_force::execute(std::string const& args UNUSED)
{
  AppEI()->setRunning(false);
}
 
void cmd_playother::execute(std::string const& args UNUSED)
{
  AppEI()->setRunning(true);
}
 
void cmd_alg::execute(std::string const& args)
{
  Game()->setAlgorithm(args);
}
 
void cmd_evaltype::execute(std::string const& args)
{
  Game()->setEval(args);
}
 
void cmd_UCI_ShowCurrLine::execute(std::string const& args)
{
  App().setConfig("UCI_ShowCurrLine", (args == "true") ? 1 : 0);
}
 
void cmd_UCI_Opponent::execute(std::string const& args)
{
  App().setConfig("opponent", args);
  Game()->setPlayerName(args);
}
 
void cmd_name::execute(std::string const& args)
{
  App().setConfig("opponent", args);
  Game()->setPlayerName(args);
}
 
void cmd_option::execute(std::string const& args)
{
  belofte::stringList const options = belofte::stringSplit(args, "=");
  if (options.size() == 2) {
    /// @todo get array from initialisation
    std::string const opt[] = {"alg", "evaltype"};
    if (std::find(std::begin(opt), std::end(opt), options[0])
            != std::end(opt)) {
      /// @todo change to specific setoption function
      AppEI()->execute(options[0], options[1]);
    } else {
      AppEI()->sendError("option not understood", args);
    }
  } else {
    AppEI()->sendError("bad option parameters", args);
  }
}
 
void cmd_info::execute(std::string const& args UNUSED)
{
  App().m_debuginterface.info();
}
 
void cmd_rejected::execute(std::string const& args)
{
  AppEI()->sendDebug(1, "UI rejected " + args);
}
 
void cmd_eval::execute(std::string const& args UNUSED)
{
  std::stringstream ss;
  bBoard& b = Game()->getCurrentPosition();
 
  ss << "# Eval: (" << (b.minimizing() == 1 ? "maximizing) white" : "minimizing) black")
          << " to move - " << Game()->getEval()->operator std::string();
  if (Game()->getRandom()) ss << " +-Rnd";
 
  if (b.getStage() == bGameStage::ST_OPENING) ss << " - Opening";
  else if (b.getStage() == bGameStage::ST_ENDGAME) ss << " - Endgame";
  else if (b.getStage() == bGameStage::ST_MATING) ss << " - Mating";
  else if (b.getStage() == bGameStage::ST_PAWNENDING) ss << " - Pawnending";
 
  bScore sc = Game()->EvalForPlayer(b);
  ss << "\ninfo" << UCIMode::uciscorestring(sc);
 
  if (!Game()->getRandom()) {
    b.invert();
    bScore isc = Game()->EvalForPlayer(b);
    if (isc != sc) {
      ss << " (inbalanced eval: "
              << UCIMode::uciscorestring(isc)
              << ")";
    }
    b.invert();
  }
 
  ss << " material" << UCIMode::uciscorestring(Game()->MaterialEvalForPlayer(b));
 
  App().bout << ss.str() << std::endl;
}
 
//-----------------------------------------------------------------------
// xboard implementation
 
/** limit maximum search depth */
void cmd_sd::execute(std::string const& args)
{
  Game()->getLevel().setDepth(static_cast<depth_t>(atoi(args.c_str())));
}
 
void cmd_fd::execute(std::string const& args)
{
  Game()->getLevel().setMateSearch(static_cast<depth_t>(atoi(args.c_str())));
}
 
void cmd_level::execute(std::string const& args)
{
  belofte::stringList const levelOptions = belofte::stringSplit(args, " ");
  int nMovesPerPeriod = 0;
  int nTimePerPeriod = 0;
  int nIncrement = 0;
  Game()->getLevel().flagLevelChange();
  if (levelOptions.size() == 3) {
    nMovesPerPeriod = atoi(levelOptions[0].c_str());
    nIncrement = atoi(levelOptions[2].c_str());
    belofte::stringList const sPeriods = belofte::stringSplit(levelOptions[1], ":");
    if (sPeriods.size() == 2) {
      nTimePerPeriod = atoi(sPeriods[0].c_str()) * 60
              + atoi(sPeriods[1].c_str());
    } else {
      nTimePerPeriod = atoi(levelOptions[1].c_str()) * 60;
    }
  }
  // TODO: keep initial game time so that after move 35, all increment time is
  // used, currently, it is flapping around 10s left
  if (nMovesPerPeriod == 0) {
    if (nIncrement == 0) {
      Game()->getLevel().setGameTime(nTimePerPeriod * 1000);
    } else {
      Game()->getLevel().setGameTime(nTimePerPeriod * 1000,
              nIncrement * 1000);
    }
  } else {
    if (nIncrement == 0) {
      Game()->getLevel().setMoveTime(nTimePerPeriod * 1000,
              nMovesPerPeriod);
    } else {
      Game()->getLevel().setMoveTime(nTimePerPeriod * 1000,
              nMovesPerPeriod, nIncrement * 1000);
    }
  }
}
 
void cmd_st::execute(std::string const& args)
{
  Game()->getLevel().setMoveTime(atoi(args.c_str())*1000);
}
 
void cmd_time::execute(std::string const& args)
{
  // centiseconds to milliseconds conversion
  Game()->getLevel().setRemainingTime(atoi(args.c_str())*10);
}
 
void cmd_random::execute(std::string const& args UNUSED)
{
#if !defined(BELOFTE_NORANDOM)
  Game()->setRandom(!Game()->getRandom());
#endif
}
 
void cmd_post::execute(std::string const& args UNUSED)
{
  App().sout.setVerbosity(1);
}
 
void cmd_nopost::execute(std::string const& args UNUSED)
{
  App().sout.setVerbosity(-1);
}
 
// eof