ScreenEntity.cpp

Go to the documentation of this file.

#include "Ui/ScreenEntity.hpp"
 
#include <VoltMod/Core/Log.hpp>
#include <VoltMod/Engine/GameData/Bindings.hpp>
#include <VoltMod/Entities/Entity.hpp>
#include <VoltMod/Entities/KeyValues.hpp>
#include <VoltMod/Schema/Api.hpp>
#include <format>
#include <tier1/utlstring.h>
#include <tier1/utlvector.h>
#include <utility>
 
namespace VoltMod
{
 
using StringTable = CUtlVector<CUtlString>;
 
/** EHudPanelClassStatus_t values. */
static constexpr int32_t ClassAbsent = 0;
static constexpr int32_t ClassPresent = 1;
 
/** CS2 refuses to intern past this many entries per table; stop short so a runaway caller cannot fill them. */
static constexpr int StringTableCap = 1024;
static constexpr int StringTableHeadroom = 64;
 
/** Assigned in place: CUtlString allocates inside tier0, the allocator the engine frees with. */
static void SetStr(CUtlString& out, std::string_view text)
{
    out.SetDirect(text.data(), static_cast<int>(text.size()));
}
 
ScreenEntity::ScreenEntity(EntitySystem& entities, SlotEvents& slots, Visibility& visibility, LayoutPath layout,
                           int owner)
    : _entities(entities), _visibility(visibility), _layout(std::move(layout)), _owner(owner)
{
    _slotChanges = slots.Changed += [this](int slot) {
        _playersChangedSinceSpawn = true;
        if (slot == _owner)  // a player screen leaves with its owner
        {
            Remove();
        }
        else
        {
            _written.RemoveSlot(slot);
        }
    };
    // The game resets the slot's per-player state as its client finishes loading, so resend it.
    _fullConnects = slots.FullyConnected += [this](int slot) {
        _playersChangedSinceSpawn = true;
        _written.RemoveSlot(slot);
    };
}
 
ScreenEntity::~ScreenEntity()
{
    Remove();
}
 
bool ScreenEntity::Exists() const
{
    return static_cast<bool>(_entities.Get(_entity));
}
 
bool ScreenEntity::EnsureSpawned(int slot)
{
    if (slot != EveryoneSlot && !IsValidSlot(slot))
    {
        return false;
    }
 
    const auto target = CacheSlotFor(slot);
    if (!target)
    {
        return false;
    }
 
    if (!Exists() && !SpawnOrWarn())
    {
        return false;
    }
 
    if (*target == EveryoneSlot || Covers(*target))
    {
        return true;
    }
 
    // Respawning for any other reason would retry a hopeless spawn every frame.
    if (!_playersChangedSinceSpawn)
    {
        return false;
    }
 
    return SpawnOrWarn() && Covers(*target);
}
 
void ScreenEntity::Remove()
{
    if (IsForPlayer())
    {
        _visibility.ShowToEveryone(_entity);
    }
    _entities.Get(_entity).Remove();
 
    _entity = {};
    _written.Clear();
}
 
void ScreenEntity::WriteText(int slot, std::string_view variable, std::string_view value)
{
    const auto target = CacheSlotFor(slot);
    // One entity holds one layout, so the variable alone names the text.
    if (!target || !_written.Changed(*target, WriteKind::Text, {}, variable, value))
    {
        return;
    }
 
    CheckWrite(*target, SendText(ContentSlotFor(*target), variable, value), variable);
}
 
void ScreenEntity::WriteClass(int slot, std::string_view elementId, std::string_view className, bool on)
{
    const auto target = CacheSlotFor(slot);
    if (!target || !_written.Changed(*target, WriteKind::Class, elementId, className, on ? "1" : "0"))
    {
        return;
    }
 
    CheckWrite(*target, SendClass(ContentSlotFor(*target), elementId, className, on), elementId);
}
 
void ScreenEntity::WriteCursor(int slot, bool shown)
{
    const auto target = CacheSlotFor(slot);
    if (!target || !_written.CursorChanged(*target, shown))
    {
        return;
    }
 
    CheckWrite(*target, SendCursor(*target, shown), "the cursor");
}
 
Result<int> ScreenEntity::CacheSlotFor(int slot) const
{
    if (!IsForPlayer())
    {
        return slot;
    }
 
    if (slot != EveryoneSlot && slot != _owner)
    {
        return std::unexpected(Error::Invalid(std::format("this screen belongs to slot {}", _owner)));
    }
 
    return _owner;
}
 
int ScreenEntity::ContentSlotFor(int cacheSlot) const noexcept
{
    return IsForPlayer() ? EveryoneSlot : cacheSlot;
}
 
Status ScreenEntity::Spawn()
{
    _playersChangedSinceSpawn = false;
    Remove();
 
    if (Status available = _entities.Available(); !available)
    {
        return available;
    }
 
    KeyValues values;
    values.Set("layout", _layout.Resource());
 
    const Entity spawned = _entities.Spawn("custom_hud_layout", values);
    if (!spawned)
    {
        return std::unexpected(Error::Engine("the engine refused to spawn custom_hud_layout"));
    }
 
    _entity = spawned.Ref();
    if (IsForPlayer())
    {
        _visibility.ShowOnlyTo(_entity, _owner);
    }
    return {};
}
 
bool ScreenEntity::SpawnOrWarn()
{
    const Status spawned = Spawn();
    if (!spawned)
    {
        Log::Warn("Screen '{}': spawn failed ({}).", _layout.Name(), spawned.error().Detail);
    }
    return spawned.has_value();
}
 
int ScreenEntity::PlayerStateCount() const
{
    // The embedded vector keeps its count first, which is what the engine itself reads before indexing.
    const Schema::CCSCustomHudLayout layout{_entities.Get(_entity).Raw()};
    return layout ? layout.PlayerLayoutStates() : -1;
}
 
bool ScreenEntity::Covers(int slot) const
{
    return IsValidSlot(slot) && PlayerStateCount() > slot;
}
 
Result<CEntityInstance*> ScreenEntity::EntityForWrite(int engineSlot) const
{
    Entity entity = _entities.Get(_entity);
    if (!entity)
    {
        return std::unexpected(Error::NotFound("the custom_hud_layout entity no longer exists"));
    }
 
    const Schema::CCSCustomHudLayout layout{entity.Raw()};
    for (const auto& [name, table] :
         {std::pair{"element id", layout.PanelIds()}, std::pair{"class name", layout.ClassNames()},
          std::pair{"text variable", layout.DialogVariableNames()}})
    {
        const int count = table ? static_cast<const StringTable*>(table)->Count() : -1;
        if (count >= StringTableCap - StringTableHeadroom)
        {
            return std::unexpected(
                Error::Failed(std::format("the {} table is nearly full ({}/{})", name, count, StringTableCap)));
        }
    }
 
    if (engineSlot == EveryoneSlot)
    {
        return entity.Raw();
    }
 
    // The engine's per-player setters return silently for a slot past the state count.
    if (const int states = PlayerStateCount(); states <= engineSlot)
    {
        return std::unexpected(Error::Failed(
            std::format("slot {} has no per-player layout state (the entity holds {})", engineSlot, states)));
    }
 
    return entity.Raw();
}
 
Status ScreenEntity::SendText(int engineSlot, std::string_view variable, std::string_view value)
{
    auto entity = EntityForWrite(engineSlot);
    if (!entity)
    {
        return std::unexpected(entity.error());
    }
 
    CUtlString root, name, text;
    SetStr(root, _layout.Name());
    SetStr(name, variable);
    SetStr(text, value);
 
    const Bindings& bindings = _entities.Bindings();
    if (engineSlot == EveryoneSlot)
    {
        if (!bindings.CustomHudSetDialogVariable)
        {
            return std::unexpected(Error::Unsupported("the custom HUD text setter did not bind"));
        }
        bindings.CustomHudSetDialogVariable(*entity, &root, &name, &text);
        return {};
    }
 
    if (!bindings.CustomHudSetDialogVariableForPlayer)
    {
        return std::unexpected(Error::Unsupported("the custom HUD per-player text setter did not bind"));
    }
    bindings.CustomHudSetDialogVariableForPlayer(*entity, engineSlot, &root, &name, &text);
    return {};
}
 
Status ScreenEntity::SendClass(int engineSlot, std::string_view elementId, std::string_view className, bool on)
{
    auto entity = EntityForWrite(engineSlot);
    if (!entity)
    {
        return std::unexpected(entity.error());
    }
 
    CUtlString element, name;
    SetStr(element, elementId);
    SetStr(name, className);
    const int32_t state = on ? ClassPresent : ClassAbsent;
 
    const Bindings& bindings = _entities.Bindings();
    if (engineSlot == EveryoneSlot)
    {
        if (!bindings.CustomHudSetHasClass)
        {
            return std::unexpected(Error::Unsupported("the custom HUD class setter did not bind"));
        }
        bindings.CustomHudSetHasClass(*entity, &element, &name, state);
        return {};
    }
 
    if (!bindings.CustomHudSetHasClassForPlayer)
    {
        return std::unexpected(Error::Unsupported("the custom HUD per-player class setter did not bind"));
    }
    bindings.CustomHudSetHasClassForPlayer(*entity, engineSlot, &element, &name, state);
    return {};
}
 
Status ScreenEntity::SendCursor(int engineSlot, bool shown)
{
    auto entity = EntityForWrite(engineSlot);
    if (!entity)
    {
        return std::unexpected(entity.error());
    }
 
    if (engineSlot != EveryoneSlot)
    {
        const auto& set = _entities.Bindings().CustomHudSetInputCapture;
        if (!set)
        {
            return std::unexpected(Error::Unsupported("the custom HUD input capture setter did not bind"));
        }
        set(*entity, engineSlot, shown);
        return {};
    }
 
    // No engine setter takes the global state; this plain bool has no container or index behind it.
    Schema::CCSCustomHudLayout{*entity}.GlobalLayoutState().SetInputCaptureEnabled(shown);
    return {};
}
 
void ScreenEntity::CheckWrite(int cacheSlot, const Status& status, std::string_view what)
{
    if (status || !IsValidSlot(cacheSlot))
    {
        return;
    }
 
    _written.Invalidate(cacheSlot);
    if (_written.IsFirstFailure(cacheSlot))
    {
        Log::Warn("Screen '{}': writing {} for slot {} failed ({}).", _layout.Name(), what, cacheSlot,
                  status.error().Detail);
    }
}
 
}  // namespace VoltMod