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"
 
//-----------------------------------------------------------------------
 
void engineUserCommand::execute(std::string const& args)
{
  AppEI()->sendError("unimplemented command, not executing",
          m_name + (args.size() ? " <" + args + ">" : ""));
}
 
//-----------------------------------------------------------------------
// 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";
  App().bout.endl();
  throw quitCommandException();
}
 
void cmd_about::execute(std::string const& args UNUSED)
{
  App().bout << App().getConfig("enginename", "") << '\n'
          << App().getConfig("author", "");
  App().bout.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\t\tUse Xboard/Winboard/CECP interface\n"
          << "\t@script\t\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("");
  AppEI()->sendResponse("option name alg type combo default AB "
                        "var Random var StaticEval var BruteForce var MiniMax "
                        "var SearchIterativeBF var AB var ABFS var ABFH");
  AppEI()->sendResponse("option name evaltype type combo default PositionalBoard "
                        "var None 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)
{
  if (App().getMode() != "uci") App().setMode("uci");
  Game()->newGame();
  Game()->setFENInitialPos();
}
 
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], belofte::alltrim(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, " ");
  depth_t perftdepth = 0;
  if (!goOptions.empty()) perftdepth = static_cast<depth_t>(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);
#if !defined(NO_NPS_LOG)
  std::string sNPS = "0";
  if ((nNodes + nNonLeafNodes) > 0LL) {
    sNPS = belofte::to_string(static_cast<int64_t>(
            (nNodes + nNonLeafNodes) * 1000000LL / search.getDurationMicroSec()));
  }
#endif
 
  if (Game()->isExpecting(sNodes)) {
    App().bout(-1) << "perft " << args << " -> " << sNodes
            << " (Total: " << sTotalNodes
            << ") <- Execution time = " << search.getDuration()
#if !defined(NO_NPS_LOG)
            << " NPS " << sNPS
#endif
            ;
    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
 * @note use `epd pos` instead (with space)
 */
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(Game()->getLevel());
  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("again");
  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)
{
  std::string sFileName = App().getName() + ".pgn";
  if (!args.empty()) { sFileName = args; }
 
  Game()->setStandardPgn(false);
  std::ofstream ofGameSave(sFileName);
  ofGameSave << Game()->operator std::string() << "\n";
  ofGameSave.close();
}
 
void cmd_export::execute(std::string const& args)
{
  std::string sFileName = App().getName() + ".pgn";
  if (!args.empty()) { sFileName = args; }
 
  Game()->setStandardPgn(true);
  std::ofstream ofGameExport(sFileName);
  ofGameExport << Game()->operator std::string() << "\n";
  ofGameExport.close();
}
 
void cmd_game::execute(std::string const& args)
{
  Game()->setStandardPgn(!args.empty());
  App().bout << Game()->operator std::string();
  App().bout.endl();
}
 
void cmd_load::execute(std::string const& args)
{
  std::string sFileName = App().getName() + ".pgn";
  if (!args.empty()) { sFileName = args; }
 
  std::ifstream ifGameLoad(sFileName);
  if (ifGameLoad.is_open()) {
    std::string sPgnMoves;
    Game()->newGame();
    Game()->setFENInitialPos();
    AppEI()->setRunning(false);
    std::string line;
    while(getline(ifGameLoad,line)) {
      if ((line.length() < 2)
              || (line.substr(0,1) == ";")
              || (line.substr(0,1) == "%")
              || (line.substr(0,1) == "#")
              || (line.substr(0,2) == "//")) {
        // skip, 0 or 1 character lines or lines starting with
        // any of ; # % //
      } else if (line.substr(0,1) == "[") {
        /// process a pgn tag
      } else {
        /// add a single line to movelist
        sPgnMoves += line + " ";
      }
    }
    ifGameLoad.close();
    Game()->playPGNMoves(sPgnMoves);
  } else {
    AppEI()->sendError("cannot load game in file", args);
  }
}
 
void cmd_bd::execute(std::string const& args UNUSED)
{
  bBoard const& b = Game()->getCurrentPosition();
  App().bout << b.operator std::string();
  App().bout.endl();
}
 
void cmd_undo::execute(std::string const& args UNUSED)
{
  Game()->revertGameMove("undo");
}
 
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) {
    const struct dirent *hFile;
    while ((hFile = readdir(hDir)) != nullptr) {
      std::string sFile(hFile->d_name);
      if (sFile[0] == '.') continue;
      App().bout << sFile;
#if !defined(NODIRENT)
      App().bout << (hFile->d_type == DT_DIR ? "/" : "");
#endif
      App().bout.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("remove");
  Game()->revertGameMove("remove");
}
 
void cmd_protover::execute(std::string const& args UNUSED)
{
  if (App().getMode() != "xboard") {
    App().setMode("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 /// MiniMax /// SearchIterativeBF /// ABFS /// ABFH\"");
  AppEI()->sendResponse("feature option=\"evaltype -combo "
                        "PositionalBoard /// None /// 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)
{
  bBoard& b = Game()->getCurrentPosition();
 
  App().bout << "# Eval: (" << (b.minimizing() == 1 ? "maximizing) white" : "minimizing) black")
          << " to move - " << Game()->getEval()->operator std::string();
  #if !defined(BELOFTE_NORANDOM)
  if (App().getConfig("random", 0)) App().bout << " +-Rnd";
  #endif
 
  if (b.getGameStageName() != "") App().bout << " - " << b.getGameStageName();
 
  b.calcMinorPieces(true);
  gameResult_t gr = bPositionEvaluation::gameEndedResult(b);
  if (gr != GR_UNKNOWN) {
    if (bPositionEvaluation::isDrawResult(gr)) {
      App().bout << "\ninfo cp 0 string " << AppEI()->engineGameResultString(gr);
    } else {
      App().bout << "\ninfo string " << AppEI()->engineGameResultString(gr);
    }
  } else {
    bScore sc = Game()->EvalForPlayer(b, gr);
    App().bout << "\ninfo cp " << engineInterface::scoreAsString(sc);
 
    #if !defined(BELOFTE_NORANDOM)
    if (!App().getConfig("random", 0)) {
    #endif
      // either random defined or not disabled
      b.invertColours();
      bScore isc = Game()->EvalForPlayer(b, GR_UNSET);
      if (isc != sc) {
        App().bout << " (inbalanced eval: "
                << engineInterface::scoreAsString(isc)
                << ")";
      }
      b.invertColours();
    #if !defined(BELOFTE_NORANDOM)
    }
    #endif
  }
 
  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