engineinterface.h

Go to the documentation of this file.

/*---------------------------------------------------------------------+
 * File: engineinterface.h
 * Project: part of belofte - A Promising Chess Program
 * Author: yves
 * SPDX-License-Identifier: GPL-2.0-only
+----------------------------------------------------------------------*/
 
#if !defined(ENGINEINTERFACE_H)
#define ENGINEINTERFACE_H
 
//-----------------------------------------------------------------------
 
class quitCommandException : public std::exception
{
  const char * what () const noexcept override
    { return "Quit command"; }
};
 
//-----------------------------------------------------------------------
 
typedef std::map<std::string, bool> commandList_t;
typedef std::map<std::string, engineUserCommand*> engineCommands_t;
 
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wunused-parameter"
#endif
 
/**
 * implementation of user interface
 */
class engineInterface {
public:
  explicit engineInterface(std::string&& n, std::string&& h = "");
  virtual ~engineInterface();
 
  // deny creation of copy/move constructor because of pointer members
  engineInterface(engineInterface const&) = delete;
  engineInterface(engineInterface&&) = delete;
  engineInterface& operator=(engineInterface const&) = delete;
  engineInterface& operator=(engineInterface&&) = delete;
 
  void execute(std::string const& command, std::string const& params);
 
  virtual void setRunning(bool const r)
    { m_running = r; }
  virtual bool isRunning() const
    { return m_running; }
 
  virtual void sendPrompt()
    {}
  virtual void sendResponse(std::string const& response);
  virtual void sendInvalidMove(std::string const& mv, std::string const& reason)
    { sendError("Illegal move", mv); }
  virtual void sendError(std::string const& error, std::string const& description);
  virtual void sendHelp(std::string const& args);
  virtual void sendInfo(std::string const& info)
    {}
  virtual void sendDebug(int const l, std::string const& info)
    {}
 
  virtual void sendMove(bBoard& b, bMove const& m);
  virtual void sendResult(bBoard const& b, gameResult_t const gr) const;
  virtual void sendInfoSearchStart(std::string const& info);
 
  virtual void sendInfoDepth(int depth, int seldepth,
          int64_t nodes, int nps)
    {}
  virtual void sendInfoSearching(bBoard const& b, int const nLogDepth,
          depth_t const nMaxDepth,
          bScore const sc, int64_t const t, int64_t const nodes) const
    {}
  virtual void sendInfoSearching(bBoard const& b, int const nLogDepth,
          depth_t const nMaxDepth, std::string const& comment,
          bScore const sc, int64_t const t, int64_t const nodes) const
    {}
  virtual void sendInfoCurrMove(bBoard const& b,
          depth_t const nCurDepth,
          bMove const& m, movenum_t const moveid,
          int64_t const nodes) const
    {}
 
  std::string const& getHint() const
    { return m_hint; }
 
  operator std::string() const&
    { return const_cast<std::string const&>(m_name); }
 
public:
  static std::string scoreAsString(bScore const score);
  virtual std::string engineGameResultString(gameResult_t const gr) const;
 
protected:
  static void initCommand(std::vector<engineUserCommand *> cmds);
  void attachCommand(belofte::stringList const& sCommands,
          bool const published = true);
  virtual std::string scoreString(bScore const score) const
    { return engineInterface::scoreAsString(score); }
 
  static engineCommands_t& getEngineCommands() {
    static engineCommands_t* instance = new engineCommands_t();
    return *instance;
  }
 
private:
  std::string m_name;
  std::string m_hint;
  commandList_t m_allowedCommands;
  bool m_running = false;
};
 
//-----------------------------------------------------------------------
 
/**
 * implementation of specific implementation
 */
class BelofteMode : public engineInterface {
public:
  BelofteMode();
  ~BelofteMode() override
    {}
 
  void sendPrompt() override;
};
 
//-----------------------------------------------------------------------
 
class UCIMode : public engineInterface {
public:
  explicit UCIMode(std::string&& s = "uci");
  ~UCIMode() override
    {}
 
  // UCI mode does not have a persistent running state
  bool isRunning() const override
    { return false; }
 
  void sendInfo(std::string const& info) override;
  void sendDebug(int const l, std::string const& info) override;
  void sendMove(bBoard& b, bMove const& m) override;
  void sendResult(bBoard const& b, gameResult_t const gr) const override;
  void sendInfoDepth(int depth, int seldepth, int64_t nodes,
          int nps) override;
  void sendInfoSearching(bBoard const& b, int const nLogDepth,
          depth_t const nMaxDepth,
          bScore const sc, int64_t const t,
          int64_t const nodes) const override;
  void sendInfoSearching(bBoard const& b, int const nLogDepth,
          depth_t const nMaxDepth, std::string const& comment,
          bScore const sc, int64_t const t,
          int64_t const nodes) const override;
  void sendInfoCurrMove(bBoard const& b,
          depth_t const nCurDepth,
          bMove const& m, movenum_t const moveid,
          int64_t const nodes) const override;
 
protected:
  std::string scoreString(bScore const score) const override;
 
private:
  inline static void printPV(bBoard const& b,
          int const nLogDepth,
          int const nVariationDepth);
};
 
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
 
//-----------------------------------------------------------------------
 
class XboardMode : public engineInterface {
public:
  explicit XboardMode(std::string&& s = "xboard");
  ~XboardMode() override
    {}
 
  void sendInfo(std::string const& info) override;
  void sendDebug(int const l, std::string const& info) override;
  void sendResult(bBoard const& b, gameResult_t const gr) const override;
  void sendInvalidMove(std::string const& mv,
          std::string const& reason) override;
  void sendInfoSearching(bBoard const& b, int const nLogDepth,
          depth_t const nMaxDepth,
          bScore const sc, int64_t const t,
          int64_t const nodes) const override;
 
  std::string engineGameResultString(gameResult_t const gr) const override;
 
protected:
  std::string scoreString(bScore const score) const override;
};
 
//-----------------------------------------------------------------------
 
typedef std::map<std::string, engineInterface*> engineInterfaces_t;
 
//-----------------------------------------------------------------------
 
#endif // defined ENGINEINTERFACE_H
 
// eof