EngineBase.hpp

Go to the documentation of this file.

/*
 * ======================================================================================
 *
 * ░▒▓███████▓▒░░▒▓████████▓▒░▒▓███████▓▒░       ░▒▓███████▓▒░ ░▒▓██████▓▒░▒▓████████▓▒░
 * ░▒▓█▓▒░░▒▓█▓▒░▒▓█▓▒░      ░▒▓█▓▒░░▒▓█▓▒░      ░▒▓█▓▒░░▒▓█▓▒░▒▓█▓▒░░▒▓█▓▒░ ░▒▓█▓▒░
 * ░▒▓█▓▒░░▒▓█▓▒░▒▓█▓▒░      ░▒▓█▓▒░░▒▓█▓▒░      ░▒▓█▓▒░░▒▓█▓▒░▒▓█▓▒░░▒▓█▓▒░ ░▒▓█▓▒░
 * ░▒▓███████▓▒░░▒▓██████▓▒░ ░▒▓█▓▒░░▒▓█▓▒░      ░▒▓███████▓▒░░▒▓█▓▒░░▒▓█▓▒░ ░▒▓█▓▒░
 * ░▒▓█▓▒░░▒▓█▓▒░▒▓█▓▒░      ░▒▓█▓▒░░▒▓█▓▒░      ░▒▓█▓▒░░▒▓█▓▒░▒▓█▓▒░░▒▓█▓▒░ ░▒▓█▓▒░
 * ░▒▓█▓▒░░▒▓█▓▒░▒▓█▓▒░      ░▒▓█▓▒░░▒▓█▓▒░      ░▒▓█▓▒░░▒▓█▓▒░▒▓█▓▒░░▒▓█▓▒░ ░▒▓█▓▒░
 * ░▒▓███████▓▒░░▒▓████████▓▒░▒▓█▓▒░░▒▓█▓▒░      ░▒▓███████▓▒░ ░▒▓██████▓▒░  ░▒▓█▓▒░
 *
 * ======================================================================================
 */

 
#pragma once
 
#include <array>
#include <atomic>
#include <cassert>
#include <functional>
#include <libchess/uci/CommandParsing.hpp>
#include <libchess/uci/Options.hpp>
#include <span>
#include <string>
#include <string_view>
#include <utility>
 
namespace chess::game {
struct Position;
} // namespace chess::game
 
namespace chess::uci {
 
using game::Position;
using std::string_view;

struct EngineCommand final {
    using Callback = std::function<void(string_view)>;

    string_view name;

    Callback action;

    string_view description;

    string_view argsHelp;

    [[nodiscard]] static auto void_cb(std::function<void()>&& func) -> Callback
    {
        return [callback = std::move(func)]([[maybe_unused]] const string_view args) {
            callback();
        };
    }
};

struct EngineBase {
    EngineBase() = default;
 
    virtual ~EngineBase();
 
    EngineBase(const EngineBase&)            = delete;
    EngineBase(EngineBase&&)                 = delete;
    EngineBase& operator=(const EngineBase&) = delete;
    EngineBase& operator=(EngineBase&&)      = delete;

    [[nodiscard]] virtual auto get_name() const -> std::string = 0;

    [[nodiscard]] virtual auto get_author() const -> string_view = 0;

    virtual void wait() { }

    [[nodiscard]] virtual auto is_searching() const noexcept -> bool = 0;

    virtual void new_game([[maybe_unused]] bool firstCall) { }

    virtual void abort_search() { }

    virtual void ponder_hit() { }

    virtual void set_position([[maybe_unused]] const Position& pos) { }

    virtual void go([[maybe_unused]] const GoCommandOptions& opts) = 0;

    void handle_command(string_view command);

    void loop();

    virtual void handle_registration([[maybe_unused]] const RegisterOptions& opts) { }

    using CommandList = std::span<const EngineCommand>;

    [[nodiscard]] auto get_standard_uci_commands() const noexcept -> CommandList
    {
        return standardUCICommands;
    }

    [[nodiscard]] virtual auto get_custom_uci_commands() const noexcept -> CommandList
    {
        return { };
    }

    using OptionList = std::span<Option*>;

    [[nodiscard]] virtual auto get_custom_uci_options() noexcept -> OptionList
    {
        return { };
    }

    [[nodiscard]] auto get_standard_uci_options() noexcept -> OptionList
    {
        return standardUCIOptions;
    }

    [[nodiscard]] auto is_debug_mode() const noexcept -> bool
    {
        return debugMode.load(std::memory_order_relaxed);
    }

    void set_debug_mode(const bool shouldDebug) noexcept
    {
        debugMode.store(shouldDebug, std::memory_order_relaxed);
    }

    void set_sanitize_positions(const bool shouldSanitize) noexcept
    {
        sanitizeIncomingPositions.store(shouldSanitize, std::memory_order_release);
    }

    virtual void resize_transposition_table([[maybe_unused]] const size_t sizeMB) { }

    virtual void set_ponder([[maybe_unused]] const bool shouldPonder) { }


    IntOption opt_Hash {
        "Hash",
        1, 2048, 16,
        "Sets the transposition table size (in MB)",
        [this](const int sizeMB) {
            assert(sizeMB >= 0);
            resize_transposition_table(static_cast<size_t>(sizeMB));
        }
    };

    BoolOption opt_Ponder {
        "Ponder",
        false,
        "Controls whether pondering is allowed.",
        [this](const bool shouldPonder) { set_ponder(shouldPonder); }
    };

 
private:
    void respond_to_uci();
    void respond_to_isready();
    void respond_to_newgame();
    void handle_quit();
    void handle_setpos(string_view arguments);
    void handle_setoption(string_view arguments);
 
    static_assert(
        std::atomic_bool::is_always_lock_free,
        "Platform doesn't support lock-free atomic operations");
 
    std::atomic_bool shouldExit { false }; // used as flag for exiting the loop() function
    std::atomic_bool initialized { false };
    std::atomic_bool debugMode { false };
    std::atomic_bool sanitizeIncomingPositions { false };
 
    Position position;
 
    std::array<EngineCommand, 11uz> standardUCICommands {
        EngineCommand {
            .name   = "uci",
            .action = EngineCommand::void_cb([this] { respond_to_uci(); }),
            .description = "Initialize UCI communication",
            .argsHelp    = { } },
        EngineCommand {
            .name   = "isready",
            .action = EngineCommand::void_cb([this] { respond_to_isready(); }),
            .description = "Wait for engine to complete background tasks",
            .argsHelp    = { } },
        EngineCommand {
            .name   = "ucinewgame",
            .action = EngineCommand::void_cb([this] { respond_to_newgame(); }),
            .description = "Initialize a new game",
            .argsHelp    = { } },
        EngineCommand {
            .name   = "quit",
            .action = EngineCommand::void_cb([this] { handle_quit(); }),
            .description = "Exit the engine as quickly as possible",
            .argsHelp    = { } },
        EngineCommand {
            .name   = "stop",
            .action = EngineCommand::void_cb([this] { abort_search(); }),
            .description = "Abort the current search, if any",
            .argsHelp    = { } },
        EngineCommand {
            .name   = "ponderhit",
            .action = EngineCommand::void_cb([this] { ponder_hit(); }),
            .description = "Indicate that the user played the ponder move",
            .argsHelp    = { } },
        EngineCommand {
            .name   = "position",
            .action = [this](const string_view args) { handle_setpos(args); },
            .description = "Set the position on the engine's internal board",
            .argsHelp    = "[startpos|fen <fen>] [moves <move...>]" },
        EngineCommand {
            .name   = "go",
            .action = [this](const string_view args) { go(parse_go_options(args, position)); },
            .description = "Start a search",
            .argsHelp    = { } },
        EngineCommand {
            .name   = "setoption",
            .action = [this](const string_view args) { handle_setoption(args); },
            .description = "Set UCI option values",
            .argsHelp    = "[name <name>] [value <value>]" },
        EngineCommand {
            .name   = "debug",
            .action = [this](const string_view args) noexcept { set_debug_mode(args == "on"); },
            .description = "Enable/disable engine debug mode",
            .argsHelp    = "[on|off]" },
        EngineCommand {
            .name   = "register",
            .action = [this](const string_view args) {
                handle_registration(parse_register_options(args));
            },
            .description = "Handle license registration",
            .argsHelp    = { } }
    };
 
    std::array<Option*, 2uz> standardUCIOptions {
        &opt_Hash, &opt_Ponder
    };
};
 
} // namespace chess::uci