ConVar.cpp

Go to the documentation of this file.

#include "Engine/ConVars/ConVarTypes.hpp"
 
#include <VoltMod/Engine/ConVars/ConVar.hpp>
#include <format>
#include <string>
#include <string_view>
#include <tier1/convar.h>
#include <type_traits>
 
namespace VoltMod
{
 
// Keep the SDK-independent type mirror aligned with the engine.
static_assert(static_cast<int>(ConVarType::Invalid) == EConVarType_Invalid);
static_assert(static_cast<int>(ConVarType::Bool) == EConVarType_Bool);
static_assert(static_cast<int>(ConVarType::Int16) == EConVarType_Int16);
static_assert(static_cast<int>(ConVarType::UInt16) == EConVarType_UInt16);
static_assert(static_cast<int>(ConVarType::Int32) == EConVarType_Int32);
static_assert(static_cast<int>(ConVarType::UInt32) == EConVarType_UInt32);
static_assert(static_cast<int>(ConVarType::Int64) == EConVarType_Int64);
static_assert(static_cast<int>(ConVarType::UInt64) == EConVarType_UInt64);
static_assert(static_cast<int>(ConVarType::Float32) == EConVarType_Float32);
static_assert(static_cast<int>(ConVarType::Float64) == EConVarType_Float64);
static_assert(static_cast<int>(ConVarType::String) == EConVarType_String);
static_assert(static_cast<int>(ConVarType::Color) == EConVarType_Color);
static_assert(static_cast<int>(ConVarType::Vector2) == EConVarType_Vector2);
static_assert(static_cast<int>(ConVarType::Vector3) == EConVarType_Vector3);
static_assert(static_cast<int>(ConVarType::Vector4) == EConVarType_Vector4);
static_assert(static_cast<int>(ConVarType::QAngle) == EConVarType_Qangle);
static_assert(static_cast<int>(ConVarType::VectorWS) == EConVarType_VectorWS);
 
template <ConVarValue T>
Result<ConVar<T>> ConVars::Find(std::string_view name)
{
    const std::string owned(name);
    ConVarRefAbstract ref(owned.c_str());
    if (!ref.IsValidRef() || !ref.IsConVarDataAvailable())
    {
        return std::unexpected(Error::NotFound(std::format("no convar '{}'", owned)));
    }
 
    const auto type = static_cast<ConVarType>(ref.GetType());
    if (!ConVarTypeMatches<T>(type))
    {
        return std::unexpected(Error::Invalid(
            std::format("convar '{}' is engine type {}, not the requested one", owned, static_cast<int>(type))));
    }
 
    // Prefer shared storage; some convars expose only slot 0.
    CVValue_t* storage = ref.GetConVarData()->Value(CSplitScreenSlot(-1));
    if (!storage)
    {
        storage = ref.GetConVarData()->Value(CSplitScreenSlot(0));
    }
    if (!storage)
    {
        return std::unexpected(Error::Engine(std::format("convar '{}' has no value storage", owned)));
    }
 
    ConVar<T> handle;
    handle._service = this;
    handle._name = owned;
    handle._storage = storage;
    handle._type = ref.GetType();
    return handle;
}
 
template <class T>
T ConVar<T>::Get() const
{
    if (!_storage)
    {
        return T{};
    }
 
    const auto type = static_cast<ConVarType>(_type);
 
    if constexpr (std::is_same_v<T, bool>)
    {
        return _storage->m_bValue;
    }
    else if constexpr (std::is_same_v<T, std::string>)
    {
        const char* text = _storage->m_StringValue.Get();
        return text ? std::string(text) : std::string{};
    }
    else if constexpr (std::is_same_v<T, float>)
    {
        return _storage->m_fl32Value;
    }
    else
    {
        // Read the declared width to avoid adjacent bytes.
        switch (type)
        {
        case ConVarType::Int16:
            return _storage->m_i16Value;
        case ConVarType::UInt16:
            return _storage->m_u16Value;
        default:
            return _storage->m_i32Value;
        }
    }
}
 
template <class T>
Status ConVar<T>::Set(const T& value)
{
    if (!_storage || !_service)
    {
        return std::unexpected(Error::NotReady("convar handle is unresolved"));
    }
 
    // ConVarText renders unquoted: the console path quotes in SetByConsole, while the
    // replicated payload at SendToClient below must stay unquoted.
    _service->SetByConsole(_name, ConVarText(value));
    return {};
}
 
template <class T>
void ConVar<T>::SetRaw(const T& value)
    requires RawConVarValue<T>
{
    if (!_storage)
    {
        return;
    }
 
    const auto type = static_cast<ConVarType>(_type);
    if constexpr (std::is_same_v<T, bool>)
    {
        _storage->m_bValue = value;
    }
    else if constexpr (std::is_same_v<T, float>)
    {
        _storage->m_fl32Value = value;
    }
    else
    {
        switch (type)
        {
        case ConVarType::Int16:
            _storage->m_i16Value = static_cast<int16_t>(value);
            break;
        case ConVarType::UInt16:
            _storage->m_u16Value = static_cast<uint16_t>(value);
            break;
        default:
            _storage->m_i32Value = value;
            break;
        }
    }
}
 
template <class T>
void ConVar<T>::SetFor(int slot, const T& value) const
{
    if (_storage && _service)
    {
        _service->SendToClient(slot, _name, ConVarText(value));
    }
}
 
template <class T>
ConVarRawScope<T>::ConVarRawScope(ConVar<T>& cvar, const T& value)
    requires RawConVarValue<T>
    : _cvar(cvar ? &cvar : nullptr), _previous(cvar.Get())
{
    cvar.SetRaw(value);
}
 
template <class T>
ConVarRawScope<T>::~ConVarRawScope()
{
    if (_cvar)
    {
        _cvar->SetRaw(_previous);
    }
}
 
// The templates above are defined only here, so these instantiations are what makes the handles
// exist. The lists mirror the ConVarValue and RawConVarValue concepts; a type in a concept but not
// here is a link error at the consumer rather than a silently different handle.
template class ConVar<bool>;
template class ConVar<int>;
template class ConVar<float>;
template class ConVar<std::string>;
template class ConVarRawScope<bool>;
template class ConVarRawScope<int>;
template class ConVarRawScope<float>;
template Result<ConVar<bool>> ConVars::Find<bool>(std::string_view);
template Result<ConVar<int>> ConVars::Find<int>(std::string_view);
template Result<ConVar<float>> ConVars::Find<float>(std::string_view);
template Result<ConVar<std::string>> ConVars::Find<std::string>(std::string_view);
 
}  // namespace VoltMod