EngineHooks.cpp

Go to the documentation of this file.

#include "Host/EngineHooks.hpp"
 
#include "Engine/Memory/VtableLookup.hpp"
#include "Host/Plugins/PluginRegistry.hpp"
 
#include <VoltMod/Core/Log.hpp>
#include <VoltMod/Engine/GameData/BindingTypes.hpp>
#include <VoltMod/Unsafe/Hook.hpp>
#include <eiface.h>
#include <entity2/entitysystem.h>
#include <icvar.h>
#include <igamesystem.h>
#include <inetchannelinfo.h>
#include <interfaces/interfaces.h>
#include <iserver.h>
#include <string>
#include <string_view>
#include <tier1/bufferstring.h>
#include <tier1/convar.h>
#include <utility>
 
// KHook needs a complete type for this by-reference hook parameter.
class GameSessionConfiguration_t
{};
 
namespace VoltMod
{
 
/** The engine passes null for an absent string. */
static std::string_view Text(const char* text)
{
    return text != nullptr ? text : "";
}
 
/** Offer a command to the plugins, and keep it from the engine when one consumes it. */
static HookResult<void> RunCommand(PluginRegistry& registry, std::string_view name, const CCommand& arguments, int slot)
{
    // ArgS is the whole line after the command name.
    const bool consumed = registry.RaiseConsoleCommand(name, Text(arguments.ArgS()), slot);
    return consumed ? HookResult<void>::Block() : HookResult<void>{};
}
 
/** Ask the plugins about a joining client, and refuse it with the first reason one gives. */
static HookResult<bool> AdmitClient(PluginRegistry& registry, int slot, uint64_t xuid, std::string_view name,
                                    CBufferString* rejectReason)
{
    const std::string reason = registry.RaiseClientConnecting(slot, static_cast<int64_t>(xuid), name);
    if (reason.empty())
    {
        return {};
    }
    if (rejectReason != nullptr)
    {
        rejectReason->Insert(0, reason.c_str());
    }
    return HookResult<bool>::Block(false);
}
 
/** A client's address, or empty for a bot, which has no net channel. */
static std::string_view ClientAddress(IVEngineServer2* server, CPlayerSlot slot)
{
    auto* channel = server->GetPlayerNetInfo(slot);
    return channel != nullptr ? Text(channel->GetAddress()) : std::string_view{};
}
 
/** Hand every map's resource manifest to the plugins. The game rules system is in every session. */
static Result<Subscription> HookSessionManifest(PluginRegistry& registry)
{
    const VirtualFn<void(IGameSystem*, const EventBuildGameSessionManifest_t*)> build(
        KHook::GetVtableIndex(&IGameSystem::OnBuildGameSessionManifest),
        FindVirtualTable("server", "CGameRulesGameSystem"));
    const auto onBuildManifest = [&registry](IGameSystem&, const EventBuildGameSessionManifest_t* event) {
        if (event && event->m_pResourceManifest)
        {
            registry.RaiseBuildGameSessionManifest(event->m_pResourceManifest);
        }
    };
    return HookVirtual("CGameRulesGameSystem::BuildGameSessionManifest", build, nullptr, onBuildManifest);
}
 
EngineHooks::EngineHooks(PluginRegistry& registry, const EngineInterfaces& engine, std::function<void()> beforeFrame,
                         std::function<void()> beforeServerStartup, std::function<void(int64_t)> beforeClientConnected,
                         std::function<void(int64_t)> afterClientDisconnected)
    : _registry(registry),
      _beforeFrame(std::move(beforeFrame)),
      _beforeServerStartup(std::move(beforeServerStartup)),
      _beforeClientConnected(std::move(beforeClientConnected)),
      _afterClientDisconnected(std::move(afterClientDisconnected))
{
    // Registers the host's own ConCommands, `volt` among them.
    g_pCVar = engine.Cvar;
    ConVar_Register(FCVAR_RELEASE | FCVAR_CLIENT_CAN_EXECUTE | FCVAR_SERVER_CAN_EXECUTE | FCVAR_GAMEDLL);
 
    auto add = [this](Subscription hook) { _hooks.Add(std::move(hook)); };
 
    const auto onFrame = [this](IServerGameDLL&, bool, bool, bool) {
        _beforeFrame();
        _registry.RaiseFrame();
    };
    const auto onStartupServer = [this](INetworkServerService&, const GameSessionConfiguration_t&,
                                        ISource2WorldSession*, const char* mapName) {
        const std::string_view map = Text(mapName);
        Log::Info("Server startup: map '{}'.", map.empty() ? "<none>" : map);
        _beforeServerStartup();
        _registry.RaiseServerStartup(map);
        DisconnectEveryone();
    };
    const auto onClientConnect = [this](IServerGameClients&, CPlayerSlot slot, const char* name, uint64 xuid,
                                        const char*, bool, CBufferString* rejectReason) {
        return AdmitClient(_registry, slot.Get(), xuid, Text(name), rejectReason);
    };
    const auto onClientConnected = [this](IServerGameClients&, CPlayerSlot slot, const char* name, uint64 xuid,
                                          const char*, const char* address, bool) {
        // Before the call: the address is gone after it.
        ConnectClient(slot.Get(), xuid, Text(name), Text(address));
    };
    const auto onClientPutInServer = [this, server = engine.Engine](IServerGameClients&, CPlayerSlot slot,
                                                                     const char* name, int, uint64 xuid) {
        if (IsValidSlot(slot.Get()) && !_registry.IsConnected(slot.Get()))
        {
            ConnectClient(slot.Get(), xuid, Text(name), ClientAddress(server, slot));
        }
    };
    const auto onClientDisconnect = [this](IServerGameClients&, CPlayerSlot slot, ENetworkDisconnectionReason,
                                           const char*, uint64 xuid, const char*) {
        _registry.RaiseClientDisconnected(slot.Get());
        _afterClientDisconnected(static_cast<int64_t>(xuid));
    };
    const auto onClientFullyConnect = [this](IServerGameClients&, CPlayerSlot slot) {
        _registry.RaiseClientFullyConnected(slot.Get());
    };
    const auto onClientSettingsChanged = [this](IServerGameClients&, CPlayerSlot slot) {
        _registry.RaiseClientSettingsChanged(slot.Get());
    };
    const auto onConCommand = [this](ICvar&, ConCommandRef command, const CCommandContext& context,
                                     const CCommand& arguments) {
        return RunCommand(_registry, Text(command.GetName()), arguments, context.GetPlayerSlot().Get());
    };
    const auto onClientCommand = [this](IServerGameClients&, CPlayerSlot slot, const CCommand& arguments) {
        return RunCommand(_registry, Text(arguments.Arg(0)), arguments, slot.Get());
    };
    const auto onCheckTransmit = [this](ISource2GameEntities&, CCheckTransmitInfo** infoList, int infoCount,
                                        CBitVec<16384>&, CBitVec<16384>&, const Entity2Networkable_t**,
                                        const uint16*, int) { _registry.RaiseCheckTransmit(infoList, infoCount); };
 
    add(HookInterface(&IServerGameDLL::GameFrame, engine.ServerGameDll, nullptr, onFrame));
    add(HookInterface(&INetworkServerService::StartupServer, engine.NetworkServerService, nullptr, onStartupServer));
    // Before the engine admits the player, so a refusal keeps them out with a reason they see.
    add(HookInterface(&IServerGameClients::ClientConnect, engine.ServerGameClients, onClientConnect));
    add(HookInterface(&IServerGameClients::OnClientConnected, engine.ServerGameClients, onClientConnected));
    // Clients returning from a map change skip OnClientConnected.
    add(HookInterface(&IServerGameClients::ClientPutInServer, engine.ServerGameClients, nullptr, onClientPutInServer));
    // After the call, before the slot is reused.
    add(HookInterface(&IServerGameClients::ClientDisconnect, engine.ServerGameClients, nullptr, onClientDisconnect));
    add(HookInterface(&IServerGameClients::ClientFullyConnect, engine.ServerGameClients, nullptr, onClientFullyConnect));
    add(HookInterface(&IServerGameClients::ClientSettingsChanged, engine.ServerGameClients, nullptr,
                      onClientSettingsChanged));
    add(HookInterface(&ICvar::DispatchConCommand, engine.Cvar, onConCommand));
    // Client commands that are not ConCommands, `vote` among them.
    add(HookInterface(&IServerGameClients::ClientCommand, engine.ServerGameClients, onClientCommand));
    // Filter the bit vectors after the game fills them.
    add(HookInterface(&ISource2GameEntities::CheckTransmit, engine.GameEntities, nullptr, onCheckTransmit));
 
    if (auto manifest = HookSessionManifest(_registry))
    {
        add(std::move(*manifest));
    }
    else
    {
        Log::Error("Precache is off: {}", manifest.error().Detail);
    }
 
    Log::Info("Engine hooks installed.");
}
 
void EngineHooks::ConnectClient(int slot, uint64_t xuid, std::string_view name, std::string_view address)
{
    _beforeClientConnected(static_cast<int64_t>(xuid));
    _registry.RaiseClientConnected(slot, static_cast<int64_t>(xuid), name, address);
}
 
void EngineHooks::DisconnectEveryone()
{
    for (int slot = 0; slot < MaxPlayers; ++slot)
    {
        if (_registry.IsConnected(slot))
        {
            _registry.RaiseClientDisconnected(slot);
        }
    }
}
 
}  // namespace VoltMod