usercmd.h

Go to the documentation of this file.

/*---------------------------------------------------------------------+
 * File: usercmd.h
 * Project: part of belofte - A Promising Chess Program
 * Author: yves
 * SPDX-License-Identifier: GPL-2.0-only
+----------------------------------------------------------------------*/
 
#if !defined(USERCMD_H)
#define USERCMD_H
 
/**
 * basic format for single command
 */
class engineUserCommand {
public:
  engineUserCommand(std::string const& s, std::string const& h)
    : m_name(s)
    , m_hint(h)
    {}
  virtual ~engineUserCommand()
    {}
 
  // no copy or move ctor nor assignment defined
  engineUserCommand(engineUserCommand const&) = delete;
  engineUserCommand(engineUserCommand&&) = delete;
  engineUserCommand& operator=(engineUserCommand const&) = delete;
  engineUserCommand& operator=(engineUserCommand&&) = delete;
 
  virtual void execute(std::string const& args);
 
  // declared public as there is not much logic and to avoid getter/setter
  std::string m_name;
  std::string m_hint;
  bool m_isImplemented = true;
  bool m_isHidden = false;
};
 
/**
 * command and parameters
 */
class cmdParam {
public:
  cmdParam()
    : m_command("")
    , m_args("")
    {}
  ~cmdParam()
    {}
 
  cmdParam(cmdParam&&) = default;
 
  // no copy or move ctor nor assignment defined
  cmdParam(cmdParam const&) = delete;
  cmdParam& operator=(cmdParam const&) = delete;
  cmdParam& operator=(cmdParam&&) = delete;
 
  // declared public as there is not much logic and to avoid getter/setter
  std::string m_command;
  std::string m_args;
};
 
//-----------------------------------------------------------------------
 
/**
 * Sub-class to react uniformly on UCI interface specific stuff
 */
class UCIengineCommand : public engineUserCommand {
public:
  UCIengineCommand(std::string const& s, std::string const& h)
    : engineUserCommand(s, h)
    {}
  ~UCIengineCommand() override
    {}
};
 
class UCIengineOption : public UCIengineCommand {
public:
  UCIengineOption(std::string const& s, std::string const& h)
    : UCIengineCommand(s, h)
    {}
  ~UCIengineOption() override
    {}
};
 
/**
 * Sub-class to react uniformly on Xboard v1 interface specific stuff
 */
class Xboard1engineCommand : public engineUserCommand {
public:
  Xboard1engineCommand(std::string const& s, std::string const& h)
    : engineUserCommand(s, h)
    {}
  ~Xboard1engineCommand() override
    {}
};
 
/**
 * Sub-class to react uniformly on Xboard v2 interface specific stuff
 */
class Xboard2engineCommand : public engineUserCommand {
public:
  Xboard2engineCommand(std::string const& s, std::string const& h)
    : engineUserCommand(s, h)
    {}
  ~Xboard2engineCommand() override
    {}
};
 
/**
 * Do not react to command
 */
class dummyEngineCommand : public engineUserCommand {
public:
  dummyEngineCommand(std::string const& s, std::string const& h)
    : engineUserCommand(s, h)
    { m_isImplemented = false; }
  ~dummyEngineCommand() override
    {}
 
  void execute(std::string const& args UNUSED) override {}
};
 
//-----------------------------------------------------------------------
 
/**
 * implementation of single command
 */
class cmd_help : public engineUserCommand {
public:
  cmd_help() : engineUserCommand("help", "show help, ['command'] [--all/all] [unsupported] [hidden] for more complete lists")
    {}
  void execute(std::string const& args) override;
};
 
class cmd_quit : public engineUserCommand {
public:
  cmd_quit() : engineUserCommand("quit", "exit application")
    {}
  void execute(std::string const& args) override;
};
 
class cmd_echo : public engineUserCommand {
public:
  cmd_echo() : engineUserCommand("echo", "print line, mainly for batch operation")
    {}
  void execute(std::string const& args) override;
};
 
class cmd_belofte : public engineUserCommand {
public:
  cmd_belofte() : engineUserCommand("belofte", "go back to belofte mode")
    {}
  void execute(std::string const& args) override;
};
 
class cmd_uci : public engineUserCommand {
public:
  cmd_uci() : engineUserCommand("uci", "go to uci mode")
    {}
  void execute(std::string const& args) override;
};
 
class cmd_xboard : public engineUserCommand {
public:
  cmd_xboard() : engineUserCommand("xboard", "go to xboard mode")
    {}
  void execute(std::string const& args) override;
};
 
class cmd_setoption : public UCIengineCommand {
public:
  cmd_setoption() : UCIengineCommand("setoption", "set various options")
    {}
  void execute(std::string const& args) override;
};
 
class cmd_isready : public UCIengineCommand {
public:
  cmd_isready() : UCIengineCommand("isready", "ask program if ready")
    {}
  void execute(std::string const& args) override;
};
 
class cmd_position : public UCIengineCommand {
public:
  cmd_position() : UCIengineCommand("position", "set-up board")
    {}
  void execute(std::string const& args) override;
};
 
class cmd_go : public UCIengineCommand {
public:
  cmd_go() : UCIengineCommand("go", "start searching uci: [wtime ms btime ms winc ms binc ms movestogo n]")
    {}
  void execute(std::string const& args) override;
};
 
class cmd_stop : public engineUserCommand {
public:
  cmd_stop() : engineUserCommand("stop", "stop searching")
    {}
  void execute(std::string const& args) override;
};
 
class cmd_ponderhit : public dummyEngineCommand {
public:
  cmd_ponderhit() : dummyEngineCommand("ponderhit", "start search from ponderhit")
    {}
};
 
class cmd_ucinewgame : public UCIengineCommand {
public:
  cmd_ucinewgame() : UCIengineCommand("ucinewgame", "initialize new game")
    {}
  void execute(std::string const& args) override;
};
 
class cmd_exit : public Xboard2engineCommand {
public:
  cmd_exit() : Xboard2engineCommand("exit", "exit analyze mode")
    {}
};
 
class cmd_debug : public engineUserCommand {
public:
  cmd_debug() : engineUserCommand("debug", "various debug commands, type 'debug help' for more information")
    {}
  void execute(std::string const& args) override;
};
 
class cmd_bench : public engineUserCommand {
public:
  cmd_bench() : engineUserCommand("bench", "run bench command")
    {}
  void execute(std::string const& args) override;
};
 
class cmd_perft : public engineUserCommand {
public:
  cmd_perft() : engineUserCommand("perft", "run perft command")
    {}
  void execute(std::string const& args) override;
};
 
class cmd_epd : public engineUserCommand {
public:
  cmd_epd() : engineUserCommand("epd", "file|pos [-sts|-perf] parse epd file or position")
    {}
  void execute(std::string const& args) override;
};
 
/**
 * Parse epd position
 * @note use `epd pos` instead (with space)
 */
class cmd_epdpos : public engineUserCommand {
public:
  cmd_epdpos() : engineUserCommand("epdpos", "parse epd position (deprecated)")
    {}
  void execute(std::string const& args) override;
};
 
class cmd_ls : public engineUserCommand {
public:
  cmd_ls() : engineUserCommand("ls", "[pattern|subdir/] list content of directory")
    {}
  void execute(std::string const& args) override;
};
 
class cmd_execat : public engineUserCommand {
public:
  cmd_execat() : engineUserCommand("@", "execute command file")
    {}
  void execute(std::string const& args) override;
};
 
class cmd_exec : public engineUserCommand {
public:
  cmd_exec() : engineUserCommand("exec", "execute command file (alternative to @)")
    {}
  void execute(std::string const& args) override;
};
 
class cmd_about : public engineUserCommand {
public:
  cmd_about() : engineUserCommand("about", "prints about message")
    {}
  void execute(std::string const& args) override;
};
 
class cmd_export : public dummyEngineCommand {
public:
  cmd_export() : dummyEngineCommand("export", "export in standard PGN format")
    {}
};
 
class cmd_save : public engineUserCommand {
public:
  cmd_save() : engineUserCommand("save", "save game and all game information "
                                 "(extended PGN)")
    {}
  void execute(std::string const& args) override;
};
 
class cmd_game : public engineUserCommand {
public:
  cmd_game() : engineUserCommand("game", "display game and all game information "
                                 "(extended PGN)")
    {}
  void execute(std::string const& args) override;
};
 
class cmd_bd : public engineUserCommand {
public:
  cmd_bd() : engineUserCommand("bd", "show board")
    {}
  void execute(std::string const& args) override;
};
 
class cmd_undo : public Xboard2engineCommand {
public:
  cmd_undo() : Xboard2engineCommand("undo", "undo last move, switches colour player to move")
    {}
  void execute(std::string const& args) override;
};
 
class cmd_usage : public engineUserCommand {
public:
  cmd_usage() : engineUserCommand("usage", "shows how to call the application")
    {}
  void execute(std::string const& args) override;
};
 
class cmd_expect : public engineUserCommand {
public:
  cmd_expect() : engineUserCommand("expect", "run next command in expect mode")
    {}
  void execute(std::string const& args) override;
};
 
class cmd_new : public Xboard2engineCommand {
public:
  cmd_new() : Xboard2engineCommand("new", "new game")
    {}
  void execute(std::string const& args) override;
};
 
class cmd_setboard : public Xboard2engineCommand {
public:
  cmd_setboard() : Xboard2engineCommand("setboard", "configure board")
    {}
  void execute(std::string const& args) override;
};
 
class cmd_usermove : public Xboard2engineCommand {
public:
  cmd_usermove() : Xboard2engineCommand("usermove", "apply coordmove to position")
    {}
  void execute(std::string const& args) override;
};
 
class cmd_remove : public Xboard2engineCommand {
public:
  cmd_remove() : Xboard2engineCommand("remove", "undo last 2 moves")
    {}
  void execute(std::string const& args) override;
};
 
class cmd_again : public engineUserCommand {
public:
  cmd_again() : engineUserCommand("again", "undo move and search again")
    {}
  void execute(std::string const& args) override;
};
 
class cmd_protover : public Xboard2engineCommand {
public:
  cmd_protover() : Xboard2engineCommand("protover", "switch to xboard v2 mode")
    {}
  void execute(std::string const& args) override;
};
 
class cmd_accepted : public dummyEngineCommand {
public:
  cmd_accepted() : dummyEngineCommand("accepted", "notify acceptance of feature")
    {}
};
 
class cmd_rejected : public dummyEngineCommand {
public:
  cmd_rejected() : dummyEngineCommand("rejected", "reject acceptance of feature")
    {}
};
 
class cmd_option : public Xboard2engineCommand {
public:
  cmd_option() : Xboard2engineCommand("option", "allow to set various options eg. option alg=AB")
    {}
  void execute(std::string const& args) override;
};
 
class cmd_playother : public Xboard2engineCommand {
public:
  cmd_playother() : Xboard2engineCommand("playother", "start engine for opponent side")
    {}
  void execute(std::string const& args) override;
};
 
class cmd_force : public Xboard2engineCommand {
public:
  cmd_force() : Xboard2engineCommand("force", "stop engine for both sides")
    {}
  void execute(std::string const& args) override;
};
 
class cmd_level : public Xboard2engineCommand {
public:
  cmd_level() : Xboard2engineCommand("level", "set level: moves time[:sec] increment")
    {}
  void execute(std::string const& args) override;
};
 
class cmd_sd : public Xboard2engineCommand {
public:
  cmd_sd() : Xboard2engineCommand("sd", "set depth")
    {}
  void execute(std::string const& args) override;
};
 
class cmd_fd : public Xboard2engineCommand {
public:
  cmd_fd() : Xboard2engineCommand("fd", "set fixed depth (e.g. mate in x)")
    {}
  void execute(std::string const& args) override;
};
 
class cmd_st : public Xboard2engineCommand {
public:
  cmd_st() : Xboard2engineCommand("st", "set exact time per move")
    {}
  void execute(std::string const& args) override;
};
 
class cmd_time : public Xboard2engineCommand {
public:
  cmd_time() : Xboard2engineCommand("time", "set remaining time")
    {}
  void execute(std::string const& args) override;
};
 
class cmd_otim : public dummyEngineCommand {
public:
  cmd_otim() : dummyEngineCommand("otim", "set remaining time opponent")
    {}
};
 
class cmd_ping : public Xboard2engineCommand {
public:
  cmd_ping() : Xboard2engineCommand("ping", "keep alive message")
    {}
  void execute(std::string const& args) override;
};
 
class cmd_post : public Xboard2engineCommand {
public:
  cmd_post() : Xboard2engineCommand("post", "activate search output")
    {}
  void execute(std::string const& args) override;
};
 
class cmd_nopost : public Xboard2engineCommand {
public:
  cmd_nopost() : Xboard2engineCommand("nopost", "deactivate search output")
    {}
  void execute(std::string const& args) override;
};
 
class cmd_easy : public Xboard1engineCommand {
public:
  cmd_easy() : Xboard1engineCommand("easy", "set ponder off")
    {}
  void execute(std::string const& args) override;
};
 
class cmd_hard : public Xboard1engineCommand {
public:
  cmd_hard() : Xboard1engineCommand("hard", "set ponder on (unsupported)")
    {}
  void execute(std::string const& args) override;
};
 
class cmd_random : public Xboard2engineCommand {
public:
  cmd_random() : Xboard2engineCommand("random", "toggle random mode")
    {}
  void execute(std::string const& args) override;
};
 
class cmd_computer : public Xboard1engineCommand {
public:
  cmd_computer() : Xboard1engineCommand("computer", "indicate opponent is computer")
    {}
  void execute(std::string const& args) override;
};
 
class cmd_questionmark : public Xboard2engineCommand {
public:
  cmd_questionmark() : Xboard2engineCommand("?", "stop searching")
    {}
  void execute(std::string const& args) override;
};
 
class cmd_white : public dummyEngineCommand {
public:
  /// @note white command is only valid for winboard 1 modes
  cmd_white() : dummyEngineCommand("white", "white to move, engine plays "
          "black, stops clocks")
    {}
};
 
class cmd_black : public dummyEngineCommand {
public:
  /// @note black command is only valid for winboard 1 modes
  cmd_black() : dummyEngineCommand("black", "black to move, engine plays "
          "white, stops clocks")
    {}
};
 
class cmd_dot : public dummyEngineCommand {
public:
  cmd_dot() : dummyEngineCommand(".", "end edit command")
    {}
};
 
class cmd_result : public dummyEngineCommand {
public:
  cmd_result() : dummyEngineCommand("result", "inform engine of result")
    {}
};
 
class cmd_alg : public engineUserCommand {
public:
  /// @todo get values dynamically
  cmd_alg() : engineUserCommand("alg",
          "set algorithm: Random|StaticEval|BruteForce|SearchIterativeBF|"
          "AB|ABFS|ABFH")
    {}
  void execute(std::string const& args) override;
};
 
class cmd_UCI_Opponent : public UCIengineOption {
public:
  cmd_UCI_Opponent(): UCIengineOption("UCI_Opponent",
          "give name of opponent")
    {}
  void execute(std::string const& args) override;
};
 
class cmd_UCI_EngineAbout : public UCIengineOption {
public:
  cmd_UCI_EngineAbout(): UCIengineOption("UCI_EngineAbout",
          "return info about engine")
    {}
  void execute(std::string const& args) override;
};
 
class cmd_name : public Xboard2engineCommand {
public:
  cmd_name(): Xboard2engineCommand("name",
          "give name of opponent")
    {}
  void execute(std::string const& args) override;
};
 
class cmd_info : public engineUserCommand {
public:
  cmd_info() : engineUserCommand("info", "print info on program")
    {}
  void execute(std::string const& args) override;
};
 
class cmd_evaltype : public engineUserCommand {
public:
  /// @todo get values dynamically
  cmd_evaltype() : engineUserCommand("evaltype",
          "set evaluation type: None|PiecesOnly|StaticBoard|PositionalBoard")
    {}
  void execute(std::string const& args) override;
};
 
class cmd_eval : public engineUserCommand {
public:
  cmd_eval() : engineUserCommand("eval", "return position evaluation")
    {}
  void execute(std::string const& args) override;
};
 
#endif // defined USERCMD_H
 
// eof