belofte.h

Go to the documentation of this file.

/**
 * @file belofte.h
 * @brief This is the main include file, needs to be included before any other include.
 * @copyright This program is distributed under the GNU GPL Version 2,
 * June 1991 General Public License. See COPYING.md for more
 * information. SPDX-License-Identifier: GPL-2.0-only
 * Part of belofte - A Promising Chess Program
 * @author Yves De Billoëz
 */
 
#if !defined(BELOFTE_H)
#define BELOFTE_H
 
// --------------------------------------------------------------------
 
#define BELOFTE_NOUNICODE 1 // the system does not support unicode, selected by default on _WIN32
//#define INCOMPLETE_C11 // incomplete implementation of C++11, some alternative code
 
//-----------------------------------------------------------------------
 
#include "myplatform.h"
 
//-----------------------------------------------------------------------
 
//#define BELOFTE_NORANDOM 1
//#define BELOFTE_UCIMODE 1 // start with UCI interface
//#define BELOFTE_NOSIGNALS 1 // suppress default signal handling
 
// --------------------------------------------------------------------
 
#define MYNAME      "Belofte"
#define MYLCNAME    "belofte"
#define MYVERSION   "2.1.8"
#if defined(BELOFTE_NOUNICODE)
#define MYAUTHOR    "Yves De Billoez"
#else
#define MYAUTHOR    "Yves De Billoëz"
#endif
#define DEVDATES    "2004-2024"
#define MYCOPYRIGHT DEVDATES " (c)"
#define MYLICENSE   "Released under the GNU GPL v2 license"
 
#if !defined(_DEBUG)
#define MYRELEASEDATE "on 10/10/2024"
#else
#define MYRELEASEDATE __DATE__ " - " __TIME__
#endif
 
#define MYFULLNAME  MYNAME " " MYVERSION
 
#if defined(_DEBUG)
#define DEBUGFILE "debug-" MYLCNAME "-" MYVERSION ".log"
#endif
 
//-----------------------------------------------------------------------
 
#include <map>
#include <string>
#include <iostream>
#include <fstream>
#include <sstream>
#include <array>
#include <vector>
#include <numeric>
#include <memory>
#include <stdexcept>
#include <iomanip>
#include <algorithm>
#include <thread>
#include <atomic>
 
#if defined(BELOFTE_NOSIGNALS)
#include <csignal>
#endif
 
#if defined(CHRONO_MISSING)
#include <sys/time.h>
#else
#include <chrono>
#endif
 
#if !defined(_MSC_VER)
#include <dirent.h>
#endif
 
//-----------------------------------------------------------------------
 
class noCommandException : public std::exception
{
  const char * what () const noexcept override {
    return "No command";
  }
};
 
class quitCommandException : public std::exception
{
  const char * what () const noexcept override {
    return "Quit command";
  }
};
 
//-----------------------------------------------------------------------
 
typedef int8_t rank_t;
typedef int8_t column_t;
typedef uint8_t case_t;         // 0-63, 0xFF
typedef uint16_t basicmove_t;   // casefrom & caseto, 0
typedef uint16_t plynum_t;      // used to return the ply number in a position
typedef uint_fast8_t movenum_t; // used to return id of move in movelist
typedef uint8_t movenum50_t;    // moves till last capture or pawn move
typedef uint64_t boardbitmap_t; // used for king and knightmoves
typedef int_fast8_t depth_t;    // search depth
 
//-----------------------------------------------------------------------
 
#include "piece.h"
#include "usercmd.h"
#include "bel_debug.h"
#include "bel_hash.h"
#include "util.h"
#include "level.h"
#include "bestmoveinfo.h"
#include "eval.h"
#include "case.h"
#include "move.h"
#include "movelist.h"
#include "fen.h"
#include "board.h"
#include "coordmove.h"
#include "pgnmove.h"
#include "search.h"
#include "search_random.h"
#include "search_qsonly.h"
#include "search_bf.h"
#include "search_ab.h"
#include "search_perft.h"
#include "epd_testsuite.h"
#include "configurablegame.h"
#include "game.h"
 
//-----------------------------------------------------------------------
 
typedef std::map<std::string, bool> commandList_t;
typedef std::map<std::string, engineUserCommand*> engineCommands_t;
 
class commandReader final {
public:
  commandReader();
  ~commandReader();
 
  // no copy or move ctor nor assignment defined
  commandReader(commandReader const&) = delete;
  commandReader(commandReader&&) = delete;
  commandReader& operator=(commandReader const&) = delete;
  commandReader& operator=(commandReader&&) = delete;
 
  bool attach(std::string const& ifile);
  void detach();
  bool isFileAttached();
  bool isBatchMode();
  void setBatchMode();
  void clearBatchMode();
 
  cmdParam getCommand();
 
  void runner(void);
 
private:
  std::string readLine();
 
  std::string m_filename;
  std::ifstream m_inputfile;
  bool m_isBatch = true;
};
 
#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 const& n, std::string const& 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;
 
  operator std::string() const& { return const_cast<std::string const&>(m_name); }
 
  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& info,
          std::string const& reason) {
      sendError("Illegal move", info); }
  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 rs) const;
  virtual void sendInfoDepth(int depth, int seldepth,
          int64_t nodes, int nps) {}
  virtual void sendInfoScore(long long timems,
          bBoard const& b, bScore const cp) {}
  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 nLogDepth,
          depth_t const nMaxDepth, std::string const& comment,
          bMove const& m, movenum_t const moveid,
          int64_t const nodes) const {}
 
  std::string const& getHint() const { return m_hint; }
 
protected:
  void attachCommand(belofte::stringList const& sCommands,
          bool const published = true);
 
private:
  void initCommand(std::vector<engineUserCommand *> cmds);
 
  std::string m_name;
  std::string m_hint;
  commandList_t m_allowedCommands;
  bool m_running = false;
 
public:
  static engineCommands_t m_engineCommands;
};
 
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
 
/** implementation of specific implementation
 */
class UCIMode : public engineInterface {
public:
  explicit UCIMode(std::string const& n = "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 UNUSED,
          gameResult_t rs UNUSED) const override {}
  void sendInfoDepth(int depth, int seldepth, int64_t nodes,
          int nps) override;
  void sendInfoScore(long long timems, bBoard const& b,
          bScore const cp) 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 nLogDepth,
          depth_t const nMaxDepth, std::string const& comment,
          bMove const& m, movenum_t const moveid,
          int64_t const nodes) const override;
};
 
class BelofteMode final : public engineInterface {
public:
  BelofteMode();
  ~BelofteMode() override;
 
  void sendPrompt() override;
};
 
class XboardMode : public engineInterface {
public:
  explicit XboardMode(std::string const& n = "xboard");
  ~XboardMode() override;
 
  void sendInfo(std::string const& info) override;
  void sendDebug(int const l, std::string const& info) override;
  void sendInvalidMove(std::string const& info,
          std::string const& reason) 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;
};
 
//-----------------------------------------------------------------------
 
typedef std::map<std::string, engineInterface*> engineInterfaces_t;
 
/** Singleton implementation of application
 */
class appInstance final {
public:
  appInstance();
  ~appInstance();
 
  // make sure we cannot accidentally copy or assign the class by deleting
  // the implementation
  appInstance(appInstance const&) = delete;
  appInstance(appInstance&&) = delete;
  appInstance& operator=(appInstance const&) = delete;
  appInstance& operator=(appInstance&&) = delete;
 
  std::string const setMode(std::string const& iName);
  std::string const& getMode() const { return m_interfaceName; }
 
  /// @remark C++17 would allow std::any to combine both
  /// we could use a template as well
  void setConfig(std::string const& s, int64_t v);
  int64_t getConfig(std::string const& s, int64_t v);
  void setConfig(std::string const& s, std::string const& v);
  std::string getConfig(std::string const& s, std::string const& v);
 
  void setName(char *sName);
  std::string getName() const;
 
  outputWriter bout; /// normal output
  outputWriter sout; /// searching output
  commandReader m_reader; /// read input
  bel_hash m_hashEngine;
  bel_debug m_debuginterface;
  engineInterface *m_ui;
  bGame *m_game;
 
private:
  /// @remark C++17 would allow std::any to combine both
  std::map<std::string, int64_t> m_settings;
  std::map<std::string, std::string> m_stringsettings;
  engineInterfaces_t m_engineInterfaces;
  std::string m_interfaceName;
};
 
appInstance& App();
engineInterface* AppEI();
bGame *Game();
 
#endif // defined BELOFTE_H
 
// eof