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);
  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 final {
public:
  cmdParam();
  ~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);
  ~UCIengineCommand() override;
};
 
class UCIengineOption : public UCIengineCommand {
public:
  UCIengineOption(std::string const& s, std::string const& 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);
  ~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);
  ~Xboard2engineCommand() override;
};
 
/** Do not react to command
 */
class dummyEngineCommand : public engineUserCommand {
public:
  dummyEngineCommand(std::string const& s, std::string const& h);
  ~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") {}
  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;
};
 
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:
  cmd_white() : dummyEngineCommand("white", "white to move, engine plays "
          "black, stops clocks") {}
};
 
class cmd_black : public dummyEngineCommand {
public:
  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: 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