Runtime.hpp

Go to the documentation of this file.

#pragma once
 
#include <VoltMod/App/Internal/ClientLanguage.hpp>
#include <VoltMod/App/ServiceExchange.hpp>
#include <VoltMod/App/StatusService.hpp>
#include <VoltMod/Commands/CommandManager.hpp>
#include <VoltMod/Core/LoadReport.hpp>
#include <VoltMod/Core/Signals/Subscription.hpp>
#include <VoltMod/Core/Slots/SlotEvents.hpp>
#include <VoltMod/Core/Text/Translations.hpp>
#include <VoltMod/Core/Time/Scheduler.hpp>
#include <VoltMod/Engine/ConVars/ConVar.hpp>
#include <VoltMod/Engine/EngineTypes.hpp>
#include <VoltMod/Engine/Net/NetChannel.hpp>
#include <VoltMod/Engine/Server/Clock.hpp>
#include <VoltMod/Engine/Server/Map.hpp>
#include <VoltMod/Engine/Server/Precache.hpp>
#include <VoltMod/Entities/EntitySystem.hpp>
#include <VoltMod/Entities/Rounds.hpp>
#include <VoltMod/Entities/Trace.hpp>
#include <VoltMod/Events/GameEvents.hpp>
#include <VoltMod/Hooks/ClientConVars.hpp>
#include <VoltMod/Hooks/Damage.hpp>
#include <VoltMod/Hooks/Movement.hpp>
#include <VoltMod/Hooks/Teleport.hpp>
#include <VoltMod/Hooks/TextMessages.hpp>
#include <VoltMod/Hooks/Visibility.hpp>
#include <VoltMod/Hooks/Vote.hpp>
#include <VoltMod/Hooks/WeaponDrop.hpp>
#include <VoltMod/Host/IPluginContext.hpp>
#include <VoltMod/Http/HttpClient.hpp>
#include <VoltMod/Menu/CenterHtmlMenu.hpp>
#include <VoltMod/Menu/ChatInput.hpp>
#include <VoltMod/Menu/MenuRouter.hpp>
#include <VoltMod/Menu/PanoramaMenuLayout.hpp>
#include <VoltMod/Messaging/Messages.hpp>
#include <VoltMod/Players/PlayerManager.hpp>
#include <VoltMod/Players/Policy.hpp>
#include <VoltMod/Ui/ScreenManager.hpp>
#include <VoltMod/Unsafe/UnsafeServices.hpp>
#include <VoltMod/Workshop/MultiAddonManager.hpp>
#include <memory>
#include <string>
#include <string_view>
 
namespace VoltMod
{
 
/**
 * @brief Framework services for one load and unload cycle.
 *
 * Members are declared in dependency order, and each engine service does its setup when built;
 * a feature that did not bind says why in its `Available()` and in @ref LoadReport. Screens follow
 * the hook tiers so their hooks are removed first.
 */
class Runtime
{
public:
    /** @p host, @p unsafe and @p languages outlive the runtime; the plugin module opened @p unsafe first. */
    Runtime(IPluginContext& host, UnsafeServices& unsafe, PlayerLanguages& languages);
    ~Runtime();
    Runtime(const Runtime&) = delete;
    Runtime& operator=(const Runtime&) = delete;
 
    /** Drive the scheduler. Called once per frame from the GameFrame hook. */
    void OnGameFrame();
 
    /** The plugin's `plugin.json` name and directory under `addons/voltmod/plugins/`. */
    const std::string PluginName;
    /** The plugin's `plugin.json` version. */
    const std::string Version;
 
    /** "addons/voltmod/plugins/<PluginName>/<relative>". */
    std::string PluginFile(std::string_view relative) const;
 
    /**
     * Draw menus on @p layout for players who have it, center HTML for the rest, while the
     * returned Subscription lives. Hold it below @p layout, which the menu refers to. A player still
     * downloading a required addon gets center HTML.
     */
    [[nodiscard]] Subscription UsePanorama(PanoramaMenuLayout& layout);
 
    VoltMod::LoadReport LoadReport;
 
    StatusService Status;
 
    SlotEvents Slots;
 
    /**
     * Per-frame delivery, timers, and delayed work. Pending timers are discarded on destruction;
     * their callbacks may capture only members declared above Scheduler.
     */
    VoltMod::Scheduler Scheduler;
 
    VoltMod::Translations Translations;
 
    /** The opt-in engine-access tier (Interfaces, Bindings), resolved before any service. */
    UnsafeServices& Unsafe;
 
    /** Schema field offsets resolve themselves, per process rather than per load - see @ref Field. */
    EntitySystem Entities{Unsafe.Interfaces, Unsafe.Bindings};
 
    PlayerManager Players{Slots, &Entities};
 
    /** Plugin-supplied permission, targeting and reply rules, and the one gate that applies
     *  them (`Policy::Authorize`). `HasPermission` asks whichever plugin publishes
     *  @ref IPermissions until a plugin sets its own. */
    VoltMod::Policy Policy{Players};
 
    VoltMod::ConVars ConVars{Unsafe.Interfaces};
 
    /** Map validation and level changes. The current map is captured from StartupServer, so it
     *  is empty after a late load until the next map change. */
    VoltMod::Map Map{Unsafe.Interfaces, ConVars};
 
    VoltMod::GameEvents GameEvents{Unsafe.Interfaces, Unsafe.Bindings};
 
    VoltMod::Messages Messages{Unsafe.Interfaces, GameEvents, Translations};
 
    VoltMod::Clock Clock{Unsafe.Interfaces};
 
    /** Resources for the next map's session manifest. */
    VoltMod::Precache Precache;
 
    /** Per-client latency and replicated userinfo cvars. */
    VoltMod::NetChannels NetChannels{Unsafe.Interfaces};
 
    /** Line and box traces for sight and reachability questions. */
    VoltMod::Trace Trace{Unsafe.Bindings};
 
    /** The round timer, and ending the current round with a winner. */
    VoltMod::Rounds Rounds{Entities, Unsafe.Bindings, Clock};
 
    /** Per-player usercmds from the host's RunCommand hook, listened to while subscribed. */
    VoltMod::Movement Movement;
 
    /** Which clients receive which entities. */
    VoltMod::Visibility Visibility{Entities, Unsafe.Bindings, Slots};
 
    /** The next chat line from a player, for menu prompts. */
    VoltMod::ChatInput ChatInput{Scheduler, Slots};
 
    VoltMod::Teleport Teleport{Entities, Unsafe.Bindings};
 
    /** Chat, center and alert lines on their way to the clients. */
    VoltMod::TextMessages TextMessages{Unsafe.Interfaces};
 
    /** Ask a client for one of its own convars. */
    VoltMod::ClientConVars ClientConVars{Unsafe.Interfaces, Unsafe.Bindings, Slots};
 
    /** The game's yes/no vote panel. */
    VoltMod::Vote Vote{Unsafe.Interfaces, Entities, Players, GameEvents, Scheduler};
 
    VoltMod::Damage Damage{Entities, Unsafe.Bindings, Unsafe.Interfaces, GameEvents};
 
    VoltMod::WeaponDrop WeaponDrop{Entities, Unsafe.Bindings};
 
    VoltMod::ScreenManager Screens;
 
    MultiAddonManager AddonManager;
 
    ServiceExchange Exchange;
 
    /** Holds players still while a menu is open. Disabled by default. */
    VoltMod::MenuFreeze Freeze{Entities, Scheduler, Slots};
 
    CenterHtmlMenu CenterHtml{CenterHtmlMenu::Services{.Scheduler = Scheduler,
                                                       .Slots = Slots,
                                                       .Entities = Entities,
                                                       .Freeze = Freeze,
                                                       .ChatInput = ChatInput,
                                                       .Translations = Translations,
                                                       .Policy = Policy,
                                                       .Messages = Messages}};
 
    /** Routes menus to center HTML or a plugin-preferred surface. */
    MenuRouter Menus{CenterHtml};
 
    VoltMod::CommandManager Commands;
 
    /** HTTP client. Completions are replayed on the game thread. */
    HttpClient Http{Scheduler};
 
private:
    /** Check every service into @ref LoadReport: Messages required, the rest optional. */
    void CheckServices();
    void AddStatusSections();
 
    Internal::ClientLanguage _clientLanguage{Players, ClientConVars, Translations};
};
 
}  // namespace VoltMod