engineinterface.cpp

Go to the documentation of this file.

/*---------------------------------------------------------------------+
 * File: engineinterface.cpp
 * Project: part of belofte - A Promising Chess Program
 * Author: yves
 * SPDX-License-Identifier: GPL-2.0-only
+----------------------------------------------------------------------*/
 
#include "belofte.h"
 
//-----------------------------------------------------------------------
 
/**
 * Common commands to all modes
 * this ctor is called for each iface
 */
engineInterface::engineInterface(std::string&& n, std::string&& h)
  : m_name{std::move(n)}
  , m_hint{std::move(h)}
  , m_allowedCommands{}
{
}
 
engineInterface::~engineInterface()
{
  m_allowedCommands.clear();
  engineCommands_t::iterator itr = getEngineCommands().begin();
  while (itr != getEngineCommands().end()) {
    delete itr->second;
    itr = getEngineCommands().erase(itr);
  }
  getEngineCommands().clear();
}
 
//-----------------------------------------------------------------------
// global verbs valid in all cases
//-----------------------------------------------------------------------
 
void engineInterface::execute(std::string const& command, std::string const& params)
{
  if (command != "") {
    if (getEngineCommands().find(command) != getEngineCommands().end()) {
      engineUserCommand *v = getEngineCommands()[command];
      v->execute(params);
    } else {
      if (App().getMode() != "xboard"
              || !Game()->playGameMoveSeries(command)) {
        /// @note in xboard mode, try to match command with list of possible moves
        /// before raising unknown command
        /// normally, accepting usermoves should only be done after
        /// feature usermove=0 has been issued, this requirement is relaxed
        sendError("unknown command, not executing",
                command + (params.size() ? " <" + params + ">" : ""));
      }
    }
  }
}
 
void engineInterface::initCommand(std::vector<engineUserCommand *> cmds)
{
  for (size_t i = 0; i < cmds.size(); ++i) {
    if (getEngineCommands().find(cmds[i]->m_name) == getEngineCommands().end()) {
      // do not initialize twice
      getEngineCommands().insert(std::make_pair(cmds[i]->m_name, cmds[i]));
    }
  }
}
 
void engineInterface::attachCommand(belofte::stringList const& sCommands,
        bool const published)
{
  if (published) {
    /// @todo fix: if not published, add command to list anyway
    for (size_t i = 0; i < sCommands.size(); ++i) {
      m_allowedCommands[sCommands[i]] = published;
    }
  }
}
 
/**
 * 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 : getEngineCommands()) {
      engineUserCommand *v = getEngineCommands()[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 <<  " (u)\n";
      } else if ((bUnpublished || bAllowed) && v->m_isImplemented) {
        App().bout << std::left << std::setw(10) << v->m_name
              << " - " << v->m_hint << (bAllowed ? "\n" : " (h)\n");
      }
    }
    if (bUnsupported) App().bout << "\nu: Unsupported.";
    if (bUnpublished) App().bout << "\nh: Hidden";
  } else {
    App().bout << "Help for " MYNAME << "\n";
    if (getEngineCommands().find(args) != getEngineCommands().end()) {
      engineUserCommand const *v = getEngineCommands()[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::sendInfoSearchStart(std::string const& info)
{
  sendInfo(info);
}
 
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 engineInterface::sendMove(bBoard& b, bMove const& m)
{
  App().sout(-2) << "move " << bPgnMove(b, m.getBMoveT());
  App().sout.endl();
}
 
void engineInterface::sendResult(bBoard const& b UNUSED, gameResult_t const gr) const
{
  if (gr != GR_UNKNOWN) {
    // end of game, so stop running
    AppEI()->setRunning(false);
    App().sout(-2) << Game()->getResult(gr);
    App().sout.endl();
  }
}
 
//-----------------------------------------------------------------------
 
std::string engineInterface::scoreAsString(bScore const score)
{
  if (score > 0) {
    if (score > SCORE_ALMOST_NORMAL) {
      if (score == SCORE_THEORETIC_DRAW) return BE_DRAW;
      if (score > SCORE_INFINITE) {
        // mate or mate in n moves
        if (score >= SCORE_MATE - SCORE_CONVERGE_BYDEPTH) return "mate";
        else return "M" + belofte::to_string((SCORE_MATE - score) / 2);
      }
      if (score == SCORE_UNDEFINED) return BE_UNDEFINED;
      if (score == SCORE_INFINITE) return BE_INF;
    }
  } else if (score < 0) {
    if (score < -SCORE_ALMOST_NORMAL) {
      if (score == SCORE_PRACTICAL_DRAW) return BE_DRAW;
      if (score < -SCORE_INFINITE) {
        // mate or mate in n moves
        if (score <= -SCORE_MATE + SCORE_CONVERGE_BYDEPTH) return "mate";
        else return "-M" + belofte::to_string((SCORE_MATE + score) / 2);
      }
      if (score == -SCORE_INFINITE) return "-" BE_INF;
      if (score == -SCORE_UNDEFINED) return BE_UNDEFINED;
    }
  } else {
    return "0";
  }
  return belofte::to_string(score);
}
 
std::string engineInterface::engineGameResultString(gameResult_t const gr) const
{
  if (gr == GR_UNKNOWN) {
    return "";
  } else if (gr == GR_DRAW_STALEMATE) {
    return "Stalemate";
  } else if (gr == GR_DRAW_LACKMATERIAL) {
    return "Draw by insufficient material";
  } else if (gr == GR_DRAW_THREEFOLD) {
    return "Draw by repetition";
  } else if (gr == GR_DRAW_50) {
    return "50 move rule";
  } else if (gr >= GR_DRAW_ADJ && gr <= GR_DRAW_OTHER) {
    return "Draw";
  } else if (gr == GR_WHITEMATES) {
    return "White mates";
  } else if (gr == GR_BLACKMATES) {
    return "Black mates";
  }
  /// @todo add other end of game conditions
 
  return "";
}
 
//-----------------------------------------------------------------------
 
BelofteMode::BelofteMode()
  : engineInterface("belofte", "Swith to xboard or UCI protocol")
{
  initCommand({new cmd_about(), new cmd_again(),
          new cmd_alg(), new cmd_bd(), new cmd_belofte(),
          new cmd_bench(), new cmd_computer(),
          new cmd_debug(), new cmd_dot(),
          new cmd_echo(), new cmd_epd(), new cmd_epdpos(), new cmd_eval(),
          new cmd_evaltype(), new cmd_exec(), new cmd_execat(), new cmd_exit(),
          new cmd_expect(), new cmd_export(), new cmd_fd(),
          new cmd_force(), new cmd_game(),
          new cmd_go(), new cmd_help(), new cmd_info(), new cmd_load(),
          new cmd_playother(), new cmd_level(), new cmd_ls(),
          new cmd_new(), new cmd_nopost(),
          new cmd_option(), new cmd_perft(),
          new cmd_ping(), new cmd_post(),
          new cmd_questionmark(), new cmd_quit(),
          new cmd_random(), new cmd_remove(),
          new cmd_result(), new cmd_save(), new cmd_sd(), new cmd_st(),
          new cmd_setboard(), new cmd_stop(),
          new cmd_undo(), new cmd_usage(), new cmd_usermove(),
          new cmd_name()});
 
  attachCommand({"belofte"}, false);
#if defined(BELOFTE_UCIMODE)
  initCommand({new cmd_uci()});
  attachCommand({"uci"});
#elif defined(BELOFTE_XBOARDMODE)
  initCommand({new cmd_xboard()});
  attachCommand({"xboard"});
#else
  initCommand({new cmd_uci(), new cmd_xboard()});
  attachCommand({"uci", "xboard"});
#endif
 
  attachCommand({"usage", "version", "exec", "ls", "export", "save", "load"}, false);
  attachCommand({"about", "help", "bench", "perft"});
}
 
UCIMode::UCIMode(std::string&& s)
  : engineInterface(std::move(s))
{
  initCommand({new cmd_UCI_Opponent(), new cmd_UCI_EngineAbout(),
          new cmd_setoption(), new cmd_ucinewgame(), new cmd_ponderhit(),
          new cmd_isready(), new cmd_position()});
  attachCommand({"UCI_Opponent", "UCI_EngineAbout",
          "UCI_Variant"}, false);
  attachCommand({"setoption", "isready", "position", "go",
          "stop", "ucinewgame", "ponderhit"});
}
 
XboardMode::XboardMode(std::string&& s)
  : engineInterface(std::move(s), "No xboard prompt")
{
  initCommand({new cmd_protover(), new cmd_accepted(), new cmd_rejected(),
          new cmd_easy(), new cmd_hard(), new cmd_white(), new cmd_black(),
          new cmd_time(), new cmd_otim()});
  attachCommand({"accepted", "black", "option", "otim", "ping",
          "time", "rejected", "white"}, false);
  attachCommand({"bd", "undo", "new", "setboard", "usermove", "game",
          "remove", "force", "level", "post", "nopost", "random",
          "easy", "hard", "go", "?", "result", "sd", "st", "protover"});
}
 
//-----------------------------------------------------------------------
 
void BelofteMode::sendPrompt()
{
  App().bout << MYLCNAME << "> ";
}
 
//-----------------------------------------------------------------------
 
void UCIMode::sendMove(bBoard& b UNUSED, bMove const& m)
{
   App().sout(-2) << "bestmove " << bCoordMove(m);
  //// @todo: retrieve ponder out of board
  /// if (ponder != "")   App().sout(-2) << " ponder " << ponder;
  App().sout.endl();
}
 
void UCIMode::sendResult(bBoard const& b UNUSED, gameResult_t const gr UNUSED) const
{
  /*
  if (gr != GR_UNKNOWN) {
    App().sout(-2) << "bestmove 0000";
    App().sout.endl();
  }
  */
}
 
void UCIMode::sendInfo(std::string const& info)
{
  if (App().getConfig("UCIdebug", 0)) {
    App().sout << "info string " << info;
    App().sout.endl();
  }
}
 
void UCIMode::sendDebug(int const l, std::string const& info)
{
  App().bout(l) << "info string " << info;
  App().bout.endl();
}
 
void UCIMode::sendInfoDepth(int depth, int seldepth, int64_t nodes, int nps)
{
  if (depth <= App().sout.getLevel()) {
    App().sout << "info depth " << belofte::to_string(depth)
            << " seldepth " << belofte::to_string(seldepth)
            << " nodes " << belofte::to_string(nodes)
#if !defined(NO_NPS_LOG)
            << " nps " << nps
#endif
            ;
    App().sout.endl();
  }
}
 
void UCIMode::sendInfoSearching(bBoard const& b, int const nLogDepth,
        depth_t const nMaxDepth,
        bScore const sc, int64_t const timems,
        int64_t const nodes) const
{
  int nVariationDepth = static_cast<int>(b.getVariation().size());
  App().sout << "info depth " << belofte::to_string(nLogDepth);
  if (nMaxDepth > nLogDepth)
    App().sout << " seldepth " << belofte::to_string(static_cast<int16_t>(nMaxDepth));
#if !defined(NO_NPS_LOG)
  App().sout << " time " << belofte::to_string(timems);
#endif
  if (timems > 10) {
    App().sout  << " nodes " << belofte::to_string(nodes)
#if !defined(NO_NPS_LOG)
            << " nps " << belofte::to_string((nodes * 1000)/ timems)
#endif
            ;
  }
  App().sout << scoreString(sc);
  if (!bSearchScore::isUndefinedScore(sc)) printPV(b, nLogDepth, nVariationDepth);
  App().sout.endl();
}
 
/**
 * Called from root search, can also be called with comments
 * from other depths
 */
void UCIMode::sendInfoSearching(bBoard const& b, int const nLogDepth,
        depth_t const nMaxDepth, std::string const& comment,
        bScore const sc, int64_t const timems,
        int64_t const nodes) const
{
  int nVariationDepth = static_cast<int>(b.getVariation().size());
  if (nLogDepth) {
    // not called from root
    App().sout << "info depth " << belofte::to_string(nLogDepth);
    if (nMaxDepth > nLogDepth)
      App().sout << " seldepth " << belofte::to_string(static_cast<int16_t>(nMaxDepth));
  } else if (nVariationDepth) {
    // called from root, UCI requires us to send a depth
    App().sout << "info depth " << belofte::to_string(nVariationDepth);
    if (nMaxDepth > nVariationDepth)
      App().sout << " seldepth " << belofte::to_string(static_cast<int16_t>(nMaxDepth));
  } else {
    // other cases
    App().sout << "info";
  }
#if !defined(NO_NPS_LOG)
  App().sout << " time " << belofte::to_string(timems);
  if (nodes && (timems > 10))
    App().sout << " nodes " << belofte::to_string(nodes)
            << " nps " << belofte::to_string((nodes * 1000)/ timems);
#else
  if (nodes)
    App().sout << " nodes " << belofte::to_string(nodes);
#endif
  App().sout << scoreString(sc);
  printPV(b, nLogDepth, nVariationDepth);
  if (comment != "") App().sout << " string " << comment;
  App().sout.endl();
}
 
/**
 * @static Class static function
 * Print pv and currline
 */
void UCIMode::printPV(bBoard const& b,
        int const nLogDepth,
        int const nVariationDepth)
{
  if ((nLogDepth == 0) && nVariationDepth) {
    App().sout << " pv";
    for (std::string const& m : b.getPreviousMoves()) App().sout << " " << m;
    for (std::string const& m : b.getVariation()) App().sout << " " << m;
  } else {
    if (b.getPreviousMoves().size()) {
      /// @todo only print currline in case requested by UI
      App().sout << " currline";
      for (std::string const& m : b.getPreviousMoves()) App().sout << " " << m;
    }
    if (nVariationDepth) {
      App().sout << " pv";
      for (std::string const& m : b.getPreviousMoves()) App().sout << " " << m;
      for (std::string const& m : b.getVariation()) App().sout << " " << m;
    }
  }
}
 
void UCIMode::sendInfoCurrMove(bBoard const& b,
        depth_t const nCurDepth,
        bMove const& mv, movenum_t const moveid, int64_t const nodes) const
{
  int nVariationDepth = static_cast<int>(b.getVariation().size());
  App().sout << "info depth " << belofte::to_string(nCurDepth);
  if (nVariationDepth > nCurDepth)
    App().sout << " seldepth " << belofte::to_string(nVariationDepth);
  App().sout << " nodes " << belofte::to_string(nodes)
          << " currmovenumber " << belofte::to_string(moveid)
          << " currmove " << mv;
  App().sout.endl();
}
 
std::string UCIMode::scoreString(bScore const score) const
{
  if (bSearchScore::isDrawScore(score)) {
    return " score 0";
  } else if (score > SCORE_INFINITE) {
    return " score mate " + belofte::to_string((SCORE_MATE - score) / 2);
  } else if (score < -SCORE_INFINITE) {
    return " score mate -" + belofte::to_string((SCORE_MATE + score) / 2);
  } else if (bSearchScore::isUndefinedScore(score)) {
    // skip output
  } else if (score == -SCORE_INFINITE) {
    return " score lowerbound";
  } else if (score == SCORE_INFINITE) {
    return " score upperbound";
  } else {
    return " score cp " + belofte::to_string(score);
  }
  return "";
}
 
//-----------------------------------------------------------------------
 
void XboardMode::sendInfo(std::string const& info)
{
  App().sout << "# " << info;
  App().sout.endl();
}
 
void XboardMode::sendDebug(int const l, std::string const& info)
{
  App().bout(l) << "# " << info;
  App().bout.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();
}
 
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wunused-parameter"
#endif
 
void XboardMode::sendInfoSearching(bBoard const& b, int const nLogDepth,
        depth_t const nMaxDepth,
        bScore const sc, int64_t const t, int64_t const nodes) const
{
  int nVariationDepth = static_cast<int>(b.getVariation().size());
  if (!bSearchScore::isUndefinedScore(sc) && 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 ? " " : "&")
                << " " << std::setw(8) << scoreString(sc)
                << " " << std::setw(6) << (t / 10)
                << " " << std::setw(8) << nodes
                << sOld;
        App().sout.endl();
      }
    }
  }
}
 
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
 
void XboardMode::sendResult(bBoard const& b, gameResult_t const gr) const
{
  gameResult_t ngr = gr;
  if (ngr != GR_UNKNOWN) {
    // end of game, so stop running
    AppEI()->setRunning(false);
    App().sout(-2) << Game()->getResult(ngr);
    if (bPositionEvaluation::isDrawResult(ngr)) {
      ngr = bPositionEvaluation::gameEndedResult(b);
    }
    App().sout << engineGameResultString(ngr);
    App().sout.endl();
  }
}
 
std::string XboardMode::scoreString(bScore const score) const
{
  int localscore = score;
 
  if (bSearchScore::isDrawScore(score)) {
    return "0";
  } else if (localscore > SCORE_INFINITE) {
    localscore = (-localscore + SCORE_MATE) + 100000;
  } else if (localscore < -SCORE_INFINITE) {
    localscore = (-localscore - SCORE_MATE) - 100000;
  }
  return belofte::to_string(localscore);
}
 
std::string XboardMode::engineGameResultString(gameResult_t const gr) const
{
  std::string sResult = engineInterface::engineGameResultString(gr);
  if (sResult != "") return " {" + sResult + "}";
  return sResult;
}
 
//-----------------------------------------------------------------------
 
// eof