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()
{
}
 
UCIengineOption::UCIengineOption(std::string const& s,
        std::string const& h)
  : UCIengineCommand(s, h)
{
}
 
UCIengineOption::~UCIengineOption()
{
}
 
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
 *             unsupported means all plus unsupported commands
 *             hidden means all plus hidden commands
 */
void engineInterface::sendHelp(std::string const& args)
{
  belofte::stringList sParams = belofte::stringSplit(args, " ");
  bool bUnsupported = std::any_of(sParams.begin(), sParams.end(),
            [](std::string const& s)
            { return s == "unsupported"; });
  bool bUnpublished = std::any_of(sParams.begin(), sParams.end(),
            [](std::string const& s)
            { return s == "hidden"; });
  if (bUnsupported || bUnpublished || args == "") {
    // trigger all case
    sParams.emplace_back("all");
  }
  if (std::any_of(sParams.begin(), sParams.end(),
            [](std::string const& s)
            { return ((s == "all") || (s == "--all")); })) {
    App().bout << "Help for " MYNAME " - mode: " << m_name << "\n";
    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();
      if (bUnsupported && !v->m_isImplemented) {
        App().bout << std::left << std::setw(10) << v->m_name
              << " - " << v->m_hint
              << (v->m_isImplemented ? "" : " (u)")
              << "\n";
      } else if ((bUnpublished || bAllowed) && v->m_isImplemented) {
        App().bout << std::left << std::setw(10) << v->m_name
              << " - " << v->m_hint
              << (bAllowed ? "" : " (h)")
              << "\n";
      }
    }
    if (bUnsupported) App().bout << "\nu: Unsupported.";
    if (bUnpublished) App().bout << "\nh: Hidden";
  } else {
    App().bout << "Help for " MYNAME << "\n";
    if (engineInterface::m_engineCommands.find(args)
            != engineInterface::m_engineCommands.end()) {
      engineUserCommand const *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** Unsupported **";
    } else {
      App().bout << "Unknown command [" << args << "]";
    }
  }
  App().bout.endl();
}
 
void engineInterface::sendResponse(std::string const& response)
{
  App().bout << response;
  App().bout.endl();
}
 
void engineInterface::sendError(std::string const& error, std::string const& description)
{
  App().bout(-2) << "ERROR: " << error;
  if (!description.empty()) App().bout << " (" << description << ")";
  App().bout.endl();
}
 
void XboardMode::sendInfo(std::string const& info)
{
  App().sout << "# "; // TOCHECK: line needs to be split for respecting tmplevel
  App().sout << info;
  App().sout.endl();
}
 
void XboardMode::sendDebug(int const l, std::string const& info)
{
  App().bout(l) << "# ";
  App().bout << info; // TOFIX: why do we need to split in 2 lines?
  App().bout.endl();
}
 
//-----------------------------------------------------------------------
 
void UCIMode::sendMove(bBoard& b UNUSED, bMove const& m)
{
  std::stringstream sOut;
  sOut << "bestmove " << bCoordMove(m);
  // TODO: retrieve ponder out of board
  // if (ponder != "")  sOut << " ponder " << ponder;
  App().sout(-2) << sOut.str();
  App().sout.endl();
}
 
void UCIMode::sendInfo(std::string const& info)
{
  App().sout << "info string ";
  App().sout << info;
  App().sout.endl();
}
 
void UCIMode::sendDebug(int const l, std::string const& info)
{
  App().bout(l) << "info string ";
  App().bout << info;
  App().bout.endl();
}
 
void UCIMode::sendInfoDepth(int depth, int seldepth DEVUNUSED, int64_t nodes, int nps)
{
  if (depth <= App().sout.getLevel()) {
    std::stringstream sOut;
    sOut << "info depth " << depth
#if !defined(_DEBUG)
            << " seldepth " << seldepth
#endif
            << " nodes " << nodes
            << " nps " << nps;
    App().sout << sOut.str();
    App().sout.endl();
  }
}
 
void UCIMode::sendInfoScore(long long timems DEVUNUSED, bBoard const& b,
        bScore const sc)
{
  if (0 <= App().sout.getLevel()) {
    std::stringstream sOut;
    bScore mateinx = 0;
    if ((sc < SCORE_ALMOST_NORMAL) && (sc > SCORE_WINNING)) {
      mateinx = SCORE_MATE + 1 - sc;
    } else if ((sc > -SCORE_ALMOST_NORMAL) && (sc < -SCORE_WINNING)) {
      mateinx = -SCORE_MATE - 1 + sc;
    }
    sOut << "info";
    if (mateinx) {
      sOut << " score mate " << mateinx;
    } else if (sc == -SCORE_INFINITE) {
      sOut << " score lowerbound";
    } else if (sc == SCORE_INFINITE) {
      sOut << " score upperbound";
    } else if ((sc & SCORE_POSITIVE) == SCORE_PUNDEFINED) {
      // skip output
    } else {
      sOut << " score cp " << belofte::scoreAsStr(sc);
    }
#if !defined(_DEBUG)
    if (timems) {
      sOut << " time " << belofte::prettyTime(timems);
    }
#endif
    if (b.getVariation().size()) {
      sOut << " pv";
      for (std::string const& m : b.getPreviousMoves()) sOut << " " << m;
      for (std::string const& m : b.getVariation()) sOut << " " << m;
    }
    App().sout << sOut.str();
    App().sout.endl();
  }
}
 
void UCIMode::sendInfoSearching(bBoard const& b, int const nLogDepth,
        depth_t const nMaxDepth DEVUNUSED, std::string const& comment,
        bScore const sc, int64_t const timems DEVUNUSED,
        int64_t const nodes) const
{
  if (nLogDepth <= App().sout.getLevel()) {
    int nVariationDepth = static_cast<int>(b.getVariation().size());
    std::stringstream sOut;
    sOut << "info";
    if (nVariationDepth) sOut << " depth " << nVariationDepth;
#if !defined(_DEBUG)
    if (nVariationDepth != 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);
    }
#else
    sOut  << " nodes " << belofte::to_string(nodes);
#endif
    if ((sc & SCORE_POSITIVE) == SCORE_PUNDEFINED) {
      // skip output
    } else if (sc >= SCORE_INFINITE) {
      // TOCHECK: black scores inverted
      sOut << " score upperbound";
    } else if (sc <= -SCORE_INFINITE) {
      // TOCHECK: black scores inverted
      sOut << " score lowerbound";
    } else {
      sOut << " score cp " << belofte::scoreAsStr(sc);
    }
    if ((nLogDepth == 0) && nVariationDepth) {
      sOut << " pv";
      for (std::string const& m : b.getPreviousMoves()) sOut << " " << m;
      for (std::string const& m : b.getVariation()) sOut << " " << m;
    } else {
      if (b.getPreviousMoves().size()) {
        // TODO: only print currline in case requested by UI
        sOut << " currline";
        for (std::string const& m : b.getPreviousMoves()) sOut << " " << m;
      }
      if (nVariationDepth) {
        sOut << " pv";
        for (std::string const& m : b.getPreviousMoves()) sOut << " " << m;
        for (std::string const& m : b.getVariation()) sOut << " " << m;
      }
    }
    if (comment != "") sOut << " string " << comment;
    sOut << "\n";
    App().sout << sOut.str();
  }
}
 
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 (nLogDepth <= App().sout.getLevel()) {
    int nVariationDepth = static_cast<int>(b.getVariation().size());
    std::stringstream sOut;
    sOut << "info";
    if (nVariationDepth) sOut << " depth " << nVariationDepth;
#if !defined(_DEBUG)
    if (nVariationDepth != nMaxDepth) sOut << " seldepth " << nMaxDepth;
#endif
    sOut << " nodes " << belofte::to_string(nodes);
    sOut << " currmovenumber " << moveid;
    sOut << " currmove ";
    sOut << mv;
#if !defined(_DEBUG)
    if (nVariationDepth) {
      // TODO: only print currline in case requested by UI
      sOut << " currline";
      for (std::string const& m : b.getPreviousMoves()) sOut << " " << m;
    }
    if (comment != "") sOut << " string " << comment;
#endif
    sOut << "\n";
    App().sout << sOut.str();
  }
}
 
//-----------------------------------------------------------------------
 
void BelofteMode::sendPrompt()
{
  App().bout << MYLCNAME << "> ";
}
 
void engineInterface::sendMove(bBoard& b, bMove const& m)
{
  App().sout(-2) << "move " << bPgnMove(b, m);
  App().sout.endl();
}
 
void engineInterface::sendResult(bBoard const& b, gameResult_t const rs) const
{
  if (rs != GR_UNKNOWN) {
    // end of game, so stop running
    AppEI()->setRunning(false);
    App().sout(-2) << 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.endl();
  }
}
 
void XboardMode::sendInvalidMove(std::string const& mv, std::string const& reason)
{
  App().bout(-2) << "Illegal move: " << mv;
  if (reason != "") App().bout << " (" << reason << ")";
  App().bout.endl();
}
 
void XboardMode::sendInfoSearching(bBoard const& b, int const nLogDepth,
        depth_t const nMaxDepth, std::string const& comment UNUSED,
        bScore const sc, int64_t const t, int64_t const nodes) const
{
  if (nLogDepth <= App().sout.getLevel()) {
    int nVariationDepth = static_cast<int>(b.getVariation().size());
    if (((sc & SCORE_POSITIVE) != SCORE_PUNDEFINED)
        && (nVariationDepth)) {
      std::stringstream sNew;
      for (std::string const& m : b.getPreviousMoves()) sNew << " " << m;
      for (std::string const& m : b.getVariation()) sNew << " " << m;
      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 ? " " : "&");
          App().sout << " " << std::setw(8) << belofte::to_string(sc);
          App().sout << " " << std::setw(6) << (t / 10);
          App().sout << " " << std::setw(8) << nodes;
          App().sout << sOld;
          App().sout << "\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\n";
  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\t\tThis help message\n"
          << "\t--version\tShow version information\n"
          << "\t--uci\t\tUse UCI interface\n"
          << "\t--xboard\tUse Xboard/Winboard interface\n"
          << "\t[script]\tcontaining commands to execute.";
  App().bout.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);
  AppEI()->sendResponse("option name alg type combo default AB "
                        "var Random var StaticEval var BruteForce "
                        "var SearchIterativeBF var AB var ABFS var ABFH");
  AppEI()->sendResponse("option name evaltype type combo default PositionalBoard "
                        "var PiecesOnly var StaticBoard var PositionalBoard");
  AppEI()->sendResponse("option name UCI_Variant type combo default normal "
                        "var normal");
  AppEI()->sendResponse("option name UCI_EngineAbout type string default "
                        + App().getConfig("about", ""));
  AppEI()->sendResponse("option name UCI_Opponent type string default <empty>");
  // option name x type string default <empty>
  // 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.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 sOptions = belofte::stringSplit(args, " ");
  if (sOptions.size() && sOptions[0] == "name") {
    // if first element is 'name', suppress it (arena compatibility)
    sOptions.erase(sOptions.begin());
  }
  if (sOptions.size() >= 2) {
    /// @todo get array from initialisation
    std::string const opt[] = {"alg", "evaltype", "UCI_Opponent",
                               "UCI_EngineAbout", "UCI_Variant"};
    if (std::find(std::begin(opt), std::end(opt), sOptions[0])
            != std::end(opt)) {
      /// @todo change to specific setoption function
      if (sOptions.size() == 2) {
        AppEI()->execute(sOptions[0], "");
      } else {
        std::string sParams = std::accumulate(sOptions.begin() + 2, sOptions.end(), std::string(),
          [](std::string result, std::string sElem) {
            return std::move(result) + std::move(sElem) + " ";
          });
        AppEI()->execute(sOptions[0], 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 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 goOptions = belofte::stringSplit(args, " ");
  int perftdepth = 0;
  if (!goOptions.empty()) perftdepth = atoi(goOptions[0].c_str());
 
  SearchPerft search;
  int64_t nNodes = Game()->DoPerft(search, perftdepth);
  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(static_cast<int64_t>(
            (nNodes + nNonLeafNodes) * 1000000LL / search.getDurationMicroSec()));
  }
 
  if (Game()->isExpecting(sNodes)) {
    std::stringstream ss;
    ss << "perft " << args << " -> " << sNodes
            << " (Total: " << sTotalNodes
            << ") <- Execution time = " << search.getDuration()
            << " NPS " << sNPS;
    App().bout(-1) << ss.str();
    App().bout.endl();
  } else {
    AppEI()->sendError("Expectation missed",
            "perft " + args + " -> " + sNodes + " instead of <- "
            + Game()->getExpecting());
  }
  // clear expect flag
  Game()->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)
{
  belofte::stringList sParams = belofte::stringSplit(args, " ");
  epdTest_t typeOfTest = tEpdTestType::EPD_GENERIC;
 
  // remove any modifier flags, -sts overrides -perf
  if (std::any_of(sParams.begin(), sParams.end(),
            [](std::string const& s)
            { return s == "-perf"; })) {
    sParams.erase(sParams.begin() + 1);
    typeOfTest = tEpdTestType::EPD_PERF;
  } else 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.empty()) {
    AppEI()->sendError("Parameter missing", "");
  } else if (sParams[0] == "pos") {
    sParams.erase(sParams.begin());
    bEpdPos epd(sParams, typeOfTest);
    epd.parse();
  } else if (sParams[0] == "file") {
    sParams.erase(sParams.begin());
    bEpdFile epd(sParams, typeOfTest);
    epd.parse();
  } else {
    // same as epd file
    bEpdFile epd(args, typeOfTest);
    epd.parse();
  }
}
 
/** Parse epd position
 * e.g. epdpos fen-epd fen-params
 */
void cmd_epdpos::execute(std::string const& args)
{
  bEpdPos epd(args, tEpdTestType::EPD_GENERIC);
  epd.parse();
}
 
void cmd_go::execute(std::string const& args)
{
  belofte::stringList const goOptions = belofte::stringSplit(args, " ");
  bLevel level;
  int nDepth, nInf, nTime, nInc, nMoves, nMoveTime, nMate, nPonder;
  int64_t nNodes;
 
  nDepth = 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 = belofte::positionParamValue(goOptions, "mate", 1);
  nPonder = belofte::positionParamIndex(goOptions, "ponder");
 
  if (belofte::positionParamIndex(goOptions, "searchmoves") != -1) {
    // TODO: add searchmoves
  }
 
  if (nDepth != -1) {
    level.setDepthCommand(static_cast<depth_t>(nDepth));
  } else 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(static_cast<depth_t>(nMate));
  }
 
  if (nNodes != -1) level.setNodes(nNodes);
  if (nPonder != -1) level.setPondering();
 
  if (args != "") Game()->setLevel(level);
  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)
{
  if (!Game()->playGameMoveSeries(args)) {
    AppEI()->sendInvalidMove(args, "");
    return;
  }
  bBoard const& b = Game()->getCurrentPosition();
  AppEI()->sendResult(b, Game()->getResult());
 
  if (App().getMode() == "xboard") {
    // xboard requires an update to number of moves remaining
    if (AppEI()->isRunning()) {
      // only decrease moves when about to move
      Game()->getLevel().setMovePlayed();
      AppEI()->execute("go", "");
    } else if (b.whiteToMove()) {
      // or decrease moves when white to move
      Game()->getLevel().setMovePlayed();
    }
  }
}
 
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)
{
  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_ls::execute(std::string const& args)
{
  DIR *hDir;
  std::string curdir = ".";
  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
#if !defined(NODIRENT)
        << (hFile->d_type == DT_DIR ? "/" : "")
#endif
        << std::endl;
    }
    closedir(hDir);
  }
}
 
void cmd_expect::execute(std::string const& args)
{
  Game()->setExpecting(args);
}
 
void cmd_new::execute(std::string const& args UNUSED)
{
  Game()->newGame();
  Game()->setFENInitialPos();
  AppEI()->setRunning(true);
}
 
void cmd_setboard::execute(std::string const& args)
{
  Game()->setFEN(args);
}
 
void cmd_random::execute(std::string const& args UNUSED)
{
  // toggle random setting, off by default
  App().setConfig("random", App().getConfig("random", 0) ? 0 : 1);
}
 
void cmd_computer::execute(std::string const& args UNUSED)
{
  App().setConfig("computer", "computer");
}
 
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");
  AppEI()->sendResponse("feature usermove=1 playother=1 colors=0 time=1");
  AppEI()->sendResponse("feature draw=0 nps=0 memory=0 smp=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 reuse=0 pause=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_playother::execute(std::string const& args UNUSED)
{
  AppEI()->setRunning(true);
}
 
void cmd_force::execute(std::string const& args UNUSED)
{
  AppEI()->setRunning(false);
}
 
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_EngineAbout::execute(std::string const& args UNUSED)
{
}
 
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_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 !defined(BELOFTE_NORANDOM)
  if (App().getConfig("random", 0)) ss << " +-Rnd";
  #endif
 
  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 cp " << belofte::scoreAsStr(sc);
 
  if (!App().getConfig("random", 0)) {
    b.invertColours();
    bScore isc = Game()->EvalForPlayer(b);
    if (isc != sc) {
      ss << " (inbalanced eval: "
              << belofte::scoreAsStr(isc)
              << ")";
    }
    b.invertColours();
  }
 
  App().bout << ss.str();
  App().bout.endl();
}
 
//-----------------------------------------------------------------------
// xboard implementation
 
void cmd_sd::execute(std::string const& args)
{
  Game()->getLevel().setDepthCommand(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().flagLevelChanged();
  if (levelOptions.size() == 3) {
    nMovesPerPeriod = atoi(levelOptions[0].c_str());
    nIncrement = atoi(levelOptions[2].c_str());
    belofte::stringList 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_post::execute(std::string const& args UNUSED)
{
  App().sout.setLevel(0);
}
 
void cmd_nopost::execute(std::string const& args UNUSED)
{
  App().sout.setLevel(-1);
}
 
// eof