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 const& n, std::string const& h)
  : m_name{n}
  , m_hint{h}
  , m_allowedCommands{}
{
  initCommand({new cmd_about(), new cmd_accepted(), new cmd_again(),
          new cmd_alg(), new cmd_bd(), new cmd_belofte(), new cmd_black(),
          new cmd_bench(), new cmd_computer(),
          new cmd_debug(), new cmd_dot(), new cmd_easy(),
          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_hard(), new cmd_help(), new cmd_info(),
          new cmd_playother(), new cmd_isready(), new cmd_level(), new cmd_ls(),
          new cmd_new(), new cmd_nopost(),
          new cmd_option(), new cmd_otim(), new cmd_perft(),
          new cmd_ping(), new cmd_ponderhit(), new cmd_position(),
          new cmd_post(), new cmd_protover(),
          new cmd_questionmark(), new cmd_quit(), new cmd_rejected(),
          new cmd_random(), new cmd_remove(),
          new cmd_result(), new cmd_save(), new cmd_sd(), new cmd_st(),
          new cmd_setboard(), new cmd_setoption(), new cmd_stop(),
          new cmd_time(), new cmd_uci(), new cmd_ucinewgame(), new cmd_undo(),
          new cmd_usage(), new cmd_usermove(), new cmd_white(),
          new cmd_UCI_Opponent(), new cmd_name(),
          new cmd_UCI_EngineAbout(),
          new cmd_xboard()});
}
 
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 {
      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_INFINITE) return BE_INF;
      if (score == SCORE_THEORETIC_DRAW) return BE_DRAW;
      return BE_UNDEFINED;
    }
    if (score > SCORE_WINNING) {
      // mate or mate in n moves
      if (score >= SCORE_MATE - SCORE_CONVERGE_BYDEPTH) return "mate";
      else return "M" + belofte::to_string((SCORE_MATE - score + 1) / 2);
    }
  } else if (score < 0) {
    if (score < -SCORE_ALMOST_NORMAL) {
      if (score == -SCORE_INFINITE) return "-" BE_INF;
      if (score == SCORE_PRACTICAL_DRAW) return BE_DRAW;
      return BE_UNDEFINED;
    }
    if (score < -SCORE_WINNING) {
      // 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);
    }
  } 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")
{
  attachCommand({"usage", "version", "exec", "ls"}, false);
  attachCommand({"about", "xboard", "uci", "help", "bench", "perft"});
}
 
void BelofteMode::sendPrompt()
{
  App().bout << MYLCNAME << "> ";
}
 
//-----------------------------------------------------------------------
 
UCIMode::UCIMode(std::string const& s)
  : engineInterface(s)
{
  attachCommand({"belofte"}, false);
  attachCommand({"uci", "setoption", "isready", "position", "go",
          "stop", "ucinewgame", "ponderhit"});
}
 
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::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)
{
  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, int64_t nodes, int nps)
{
  if (depth <= App().sout.getLevel()) {
    std::stringstream sOut;
    sOut << "info depth " << belofte::to_string(depth)
         << " seldepth " << belofte::to_string(seldepth)
         << " nodes " << belofte::to_string(nodes)
#if defined(NPS_LOG)
         << " nps " << nps
#endif
            ;
    App().sout << sOut.str();
    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());
  std::stringstream sOut;
  sOut << "info depth " << belofte::to_string(nLogDepth);
  if (nMaxDepth > nLogDepth)
    sOut << " seldepth " << belofte::to_string(static_cast<int16_t>(nMaxDepth));
#if defined(NPS_LOG)
  sOut << " time " << belofte::to_string(timems);
#endif
  if (timems > 10) {
    sOut  << " nodes " << belofte::to_string(nodes)
#if defined(NPS_LOG)
          << " nps " << belofte::to_string((nodes * 1000)/ timems)
#endif
          ;
  }
  sOut << scoreString(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;
    }
  }
  App().sout << sOut.str();
  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());
  std::stringstream sOut;
  if (nLogDepth) {
    // not called from root
    sOut << "info depth " << belofte::to_string(nLogDepth);
    if (nMaxDepth > nLogDepth)
      sOut << " seldepth " << belofte::to_string(static_cast<int16_t>(nMaxDepth));
  } else if (nVariationDepth) {
    // called from root, UCI requires us to send a depth
    sOut << "info depth " << belofte::to_string(nVariationDepth);
    if (nMaxDepth > nVariationDepth)
      sOut << " seldepth " << belofte::to_string(static_cast<int16_t>(nMaxDepth));
  } else {
    // other cases
    sOut << "info";
  }
#if defined(NPS_LOG)
  sOut << " time " << belofte::to_string(timems);
  if (nodes && (timems > 10))
    sOut << " nodes " << belofte::to_string(nodes)
            << " nps " << belofte::to_string((nodes * 1000)/ timems);
#else
  if (nodes)
  sOut << " nodes " << belofte::to_string(nodes);
#endif
  sOut << scoreString(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;
  App().sout << sOut.str();
  App().sout.endl();
}
 
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());
  std::stringstream sOut;
  sOut << "info depth " << belofte::to_string(nCurDepth);
  if (nVariationDepth > nCurDepth)
    sOut << " seldepth " << belofte::to_string(nVariationDepth);
  sOut << " nodes " << belofte::to_string(nodes);
  sOut << " currmovenumber " << belofte::to_string(moveid);
  sOut << " currmove ";
  sOut << mv;
  App().sout << sOut.str();
  App().sout.endl();
}
 
std::string UCIMode::scoreString(bScore const score) const
{
  bScore mateinx = 0;
  if ((score < SCORE_ALMOST_NORMAL) && (score > SCORE_WINNING)) {
    mateinx = SCORE_MATE + 1 - score;
  } else if ((score > -SCORE_ALMOST_NORMAL) && (score < -SCORE_WINNING)) {
    mateinx = SCORE_MATE - 1 + score;
  }
  if (mateinx) {
    return " score mate " + belofte::to_string(mateinx);
  } else if (bSearchScore::isUndefinedScore(score)) {
    // skip output
  } else if (score == -SCORE_INFINITE) {
    return " score lowerbound";
  } else if (score == SCORE_INFINITE) {
    return " score upperbound";
  } else if (bSearchScore::isDrawScore(score)) {
    return " score 0";
  } else {
    return " score cp " + belofte::to_string(score);
  }
  return "";
}
 
//-----------------------------------------------------------------------
 
XboardMode::XboardMode(std::string const& s)
  : engineInterface(s, "No xboard prompt")
{
  attachCommand({"accepted", "belofte", "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 XboardMode::sendInfo(std::string const& info)
{
  App().sout << "# "; /// @todo check if 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; /// @bug why do we need to split in 2 lines?
  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 ? " " : "&");
          App().sout << " " << std::setw(8) << scoreString(sc);
          App().sout << " " << std::setw(6) << (t / 10);
          App().sout << " " << std::setw(8) << nodes;
          App().sout << 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 (localscore >= SCORE_WINNING && localscore <= SCORE_MATE) {
    localscore = (-localscore + SCORE_MATE) + 100000;
  } else if (localscore <= -SCORE_WINNING && localscore >= -SCORE_MATE) {
    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