Files
SatyandClaude Opus 5.5 d339a940b4 ConsoleBase: port ConsoleVar.cpp and ConsoleCommand.cpp (52 definitions verified)
- CVar (struct per 12340 RTTI; value callback is __cdecl), its console commands,
  CVarArrayWrapper/CVarIntListWrapper; command table, help, parse, complete.
- Engine-side console interface in IConsole.h (ConsoleWrite/Printf/CommandExecute...),
  implemented by WoW's ConsoleClient later (tracked in open_items); COLOR_T/CATEGORY in
  ConsoleBase/Types.h.
- stpl.h: TSList::Prev, TSHashTable::Next/DeleteNode, HASHKEY_CONSTSTRI.
- 27 suspects reviewed against 12340 listings; fixes: read-only message prints the
  cvar name, int-list decode reads bytes unsigned.

Co-Authored-By: Claude Opus 5.5 (1M context) <[email protected]>
2026-09-26 19:20:38 +02:00

879 lines
22 KiB
C++

#include <cstdint>
#include <cstring>
#include <malloc.h>
#include "Engine/Source/ConsoleBase/ConsoleVar.h"
#include "Engine/Source/BlizzardCore/SFile2-Core.h"
#include "Engine/Source/ConsoleBase/ConsoleCommand.h"
#include "Engine/Source/ConsoleBase/IConsole.h"
#include "Engine/Source/Os/System.h"
#include "Engine/Source/Storm/H/storm.h"
// STATIC: 0x00CA19F4
const char* CVar::s_configFile;
// STATIC: 0x00CA19F8
bool CVar::m_needsSave;
// STATIC: 0x00CA19F9
bool CVar::m_initialized;
// STATIC: 0x00CA19FA
bool CVar::s_archiveCodeRegisteredOnly;
// STATIC: 0x00CA19FC
static TSHashTable<CVar, HASHKEY_STRI> s_registeredCVars;
// VERIFY: 2dc92f1f auto
// OFFSET: 0x00766320
static int32_t TryCreateDirectory(const char* path) {
int32_t result = 1;
if (!path || !*path) {
return 0;
}
const char* separator = SStrChr(path + 1, '\\');
while (separator) {
if (separator - path >= 260) {
return 0;
}
char directory[260];
memcpy(directory, path, separator - path);
directory[separator - path] = '\0';
if (!OsCreateDirectory(directory, 0)) {
uint32_t attributes = OsGetFileAttributes(directory);
if (attributes == 0xFFFFFFFF || !(attributes & OS_FILE_ATTRIBUTE_DIRECTORY)) {
return 0;
}
}
separator = SStrChr(separator + 1, '\\');
}
return result;
}
// VERIFY: afa54463 manual
// OFFSET: 0x00767220
static int32_t CvarListCommandHandler(const char* command, const char* arguments) {
for (CVar* var = s_registeredCVars.m_fulllist.Head(); var; var = s_registeredCVars.m_fulllist.Next(var)) {
char line[256];
SStrPrintf(line, sizeof(line), " \"%s\" is \"%s\"", var->m_key.m_str, var->m_stringValue.m_str);
if (var->m_defaultValue.m_str && SStrCmp(var->m_stringValue.m_str, var->m_defaultValue.m_str, STORM_MAX_STR)) {
char value[256];
SStrPrintf(value, sizeof(value), " (default \"%s\")", var->m_defaultValue.m_str);
SStrPack(line, value, sizeof(line));
}
if (var->m_resetValue.m_str && SStrCmp(var->m_stringValue.m_str, var->m_resetValue.m_str, STORM_MAX_STR)) {
char value[256];
SStrPrintf(value, sizeof(value), " (reset \"%s\")", var->m_resetValue.m_str);
SStrPack(line, value, sizeof(line));
}
ConsoleWrite(line, DEFAULT_COLOR);
}
return 1;
}
// VERIFY: 5bcbe89c manual
// OFFSET: 0x00767680
static int32_t CvarCommandHandler(const char* command, const char* arguments) {
CVar* var = CVar::Lookup(command);
const char* value = arguments;
while (*value == ' ') {
value++;
}
if (!*value) {
const char* current = var->m_stringValue.m_str;
if (current) {
ConsolePrintf("CVar \"%s\" is \"%s\"", command, current);
if (var->m_defaultValue.m_str && SStrCmp(current, var->m_defaultValue.m_str, STORM_MAX_STR)) {
ConsolePrintf(" default value \"%s\"", var->m_defaultValue.m_str);
}
if (var->m_resetValue.m_str && SStrCmp(current, var->m_resetValue.m_str, STORM_MAX_STR)) {
ConsolePrintf(" reset value \"%s\"", var->m_resetValue.m_str);
}
if (var->m_latchedValue.m_str && SStrCmp(current, var->m_latchedValue.m_str, STORM_MAX_STR)) {
ConsolePrintf(" pending value \"%s\"", var->m_latchedValue.m_str);
}
}
return 1;
}
if (var->m_flags & 0x100) {
ConsolePrintf("%s is read only.", var->m_key.m_str);
return 1;
}
var->Set(value, true, true, false, true);
return 1;
}
// VERIFY: 3aa08b50 auto
// OFFSET: 0x00767840
static int32_t CvarResetCommandHandler(const char* command, const char* arguments) {
char name[64];
SStrTokenize(&arguments, name, sizeof(name), " ,;\t\"\r\n", nullptr);
if (name[0]) {
CVar* var = CVar::Lookup(name);
if (var) {
var->Reset();
} else {
ConsoleWriteA("No such cvar \"%s\"\n", ERROR_COLOR, name);
}
return 1;
}
ConsoleWrite("Resetting all cvars\n", DEFAULT_COLOR);
for (CVar* var = s_registeredCVars.m_fulllist.Head(); var; var = s_registeredCVars.m_fulllist.Next(var)) {
var->Reset();
}
return 1;
}
// VERIFY: d7ea692e auto
// OFFSET: 0x007678F0
static int32_t CvarDefaultCommandHandler(const char* command, const char* arguments) {
char name[64];
SStrTokenize(&arguments, name, sizeof(name), " ,;\t\"\r\n", nullptr);
if (name[0]) {
CVar* var = CVar::Lookup(name);
if (var) {
var->Default();
} else {
ConsoleWriteA("No such cvar \"%s\"\n", ERROR_COLOR, name);
}
return 1;
}
ConsoleWrite("Restoring all cvars\n", DEFAULT_COLOR);
for (CVar* var = s_registeredCVars.m_fulllist.Head(); var; var = s_registeredCVars.m_fulllist.Next(var)) {
var->Default();
}
return 1;
}
// VERIFY: 4978c326 manual
// OFFSET: 0x007681F0
static int32_t SetCommandHandler(const char* command, const char* arguments) {
char name[64];
char value[2048];
SStrTokenize(&arguments, name, sizeof(name), " ,;\t\"\r\n", nullptr);
SStrTokenize(&arguments, value, sizeof(value), " ,;\t\"\r\n", nullptr);
CVar* var = CVar::Lookup(name);
if (var) {
var->Set(value, true, false, false, true);
} else {
CVar::Register(name, "", 0, value, nullptr, CATEGORY_DEFAULT, true, nullptr, false);
}
return 1;
}
// VERIFY: b7fb1761 auto
// OFFSET: 0x007663F0
void CVar::ArchiveCodeRegisteredOnly() {
CVar::s_archiveCodeRegisteredOnly = true;
}
// VERIFY: ee8d0260 manual
// OFFSET: 0x00766400
int32_t CVar::Load(HOSFILE file) {
int32_t result = 1;
uint32_t size = static_cast<uint32_t>(OsGetFileSize(file));
if (!size) {
return 1;
}
char* buffer;
bool onStack;
if (size >= 0x2000) {
buffer = static_cast<char*>(SMemAlloc(size + 1, __FILE__, __LINE__, 0));
onStack = false;
} else {
buffer = static_cast<char*>(alloca(size + 1));
onStack = true;
}
uint32_t bytesRead;
if (OsReadFile(file, buffer, size, &bytesRead)) {
buffer[size] = '\0';
const char* cur = buffer;
if (cur && bytesRead >= 3 && static_cast<uint8_t>(cur[0]) == 0xEF && static_cast<uint8_t>(cur[1]) == 0xBB && static_cast<uint8_t>(cur[2]) == 0xBF) {
cur += 3;
}
do {
char line[2048];
SStrTokenize(&cur, line, sizeof(line), "\r\n", nullptr);
if (!SStrCmpI(line, "SET ", 4)) {
ConsoleCommandExecute(line, 0);
}
} while (cur && *cur);
} else {
result = 0;
}
if (!onStack) {
SMemFree(buffer, __FILE__, __LINE__, 0);
}
return result;
}
// VERIFY: 79f447f6 auto
// OFFSET: 0x00766530
int32_t CVar::Load(const char* fileName) {
HOSFILE file = OsCreateFile(fileName, OS_GENERIC_READ, 0, OS_OPEN_EXISTING, OS_FILE_ATTRIBUTE_NORMAL, OS_FILE_TYPE_ANY);
if (file == OS_INVALID_FILE) {
char path[260];
SStrPrintf(path, sizeof(path), "WTF\\%s", fileName);
file = OsCreateFile(path, OS_GENERIC_READ, 0, OS_OPEN_EXISTING, OS_FILE_ATTRIBUTE_NORMAL, OS_FILE_TYPE_ANY);
if (file == OS_INVALID_FILE) {
return 0;
}
}
int32_t result = CVar::Load(file);
OsCloseFile(file);
return result;
}
// VERIFY: e1606f74 auto
// OFFSET: 0x007665D0
int32_t CVar::Delete(const char* fileName) {
const char* path = fileName;
char buffer[260];
if (!OsFileExists(fileName)) {
SStrPrintf(buffer, sizeof(buffer), "WTF\\%s", fileName);
if (!OsFileExists(buffer)) {
return 0;
}
path = buffer;
}
OsDeleteFile(path);
return 1;
}
// VERIFY: 158a6024 auto
// OFFSET: 0x00766640
int32_t CVar::SaveCvar(const char* name, const char* value, void* arg) {
char line[260];
SStrPrintf(line, sizeof(line), "SET %s \"%s\"\n", name, value);
uint32_t written = 0;
OsWriteFile(static_cast<HOSFILE>(arg), line, SStrLen(line), &written);
return written != 0;
}
// VERIFY: 14646b6b auto
// OFFSET: 0x007666B0
int32_t CVar::LogCvar(const char* name, const char* value, void* arg) {
char line[260];
SStrPrintf(line, sizeof(line), "SET %s \"%s\"\n", name, value);
CVarLogBuffer* log = static_cast<CVarLogBuffer*>(arg);
SStrPack(log->m_buffer, line, log->m_size);
return 1;
}
// VERIFY: 31ab5de3 auto
// OFFSET: 0x00766700
void CVar::SetReadOnly(bool readOnly) {
if (readOnly) {
this->m_flags |= 0x4;
} else {
this->m_flags &= ~0x4;
}
}
// VERIFY: e41a25fd manual
// OFFSET: 0x00766720
void CVarIntListWrapper::AddNextValue(uint32_t value) {
this->m_state = 2;
if (value <= 93 * 93 * 93 - 1 && this->m_pos < 0xFD) {
this->m_buffer[this->m_pos++] = static_cast<char>(value / (93 * 93) + 35);
this->m_buffer[this->m_pos++] = static_cast<char>(value % (93 * 93) / 93 + 35);
this->m_buffer[this->m_pos++] = static_cast<char>(value % (93 * 93) % 93 + 35);
}
}
// VERIFY: d7f3e424 manual
// OFFSET: 0x007667B0
void CVar::InternalSet(const char* value, bool setValue, bool setReset, bool setDefault, bool setNeedsSave) {
bool changed = false;
if ((this->m_flags & 0x4) || !value) {
return;
}
if (setValue) {
changed = !this->m_stringValue.m_str || SStrCmpI(value, this->m_stringValue.m_str, STORM_MAX_STR) != 0;
if (changed) {
this->m_stringValue.Copy(value);
this->m_intValue = SStrToInt(value);
this->m_floatValue = SStrToFloat(value);
}
}
if (setReset && !this->m_resetValue.m_str) {
changed = true;
this->m_resetValue.Copy(value);
}
if (setDefault && !this->m_defaultValue.m_str) {
this->m_defaultValue.Copy(value);
} else if (!changed) {
return;
}
if (setNeedsSave) {
CVar::m_needsSave = true;
}
}
// VERIFY: 910ad5c0 manual
// OFFSET: 0x00766860
bool CVarArrayWrapper::RawGetValue(uint32_t index) const {
const char* str = this->m_cvar->m_stringValue.m_str;
return *str && index < 2 * (3 * strlen(str) - 3) && (str[index / 6 + 1] & (1 << (index % 6))) != 0;
}
// VERIFY: 8db3b933 auto
// OFFSET: 0x007668C0
bool CVar::Set(const char* value, bool setValue, bool setReset, bool setDefault, bool setNeedsSave) {
if (setValue) {
if (this->m_callback) {
OsValidateFunctionPointer(reinterpret_cast<const void*>(this->m_callback));
if (!this->m_callback(this, this->m_stringValue.m_str, value, this->m_arg)) {
return true;
}
}
this->m_modified++;
if (this->m_flags & 0x2) {
this->m_latchedValue.Copy(value);
CVar::m_needsSave = true;
return true;
}
}
this->InternalSet(value, setValue, setReset, setDefault, setNeedsSave);
return true;
}
// VERIFY: fe26c079 auto
// OFFSET: 0x00766940
bool CVar::Set(int32_t value, bool setValue, bool setReset, bool setDefault, bool setNeedsSave) {
char buffer[32];
SStrPrintf(buffer, sizeof(buffer), "%d", value);
return this->Set(buffer, setValue, setReset, setDefault, setNeedsSave);
}
// VERIFY: 8aea9d36 manual
// OFFSET: 0x00766990
void CVar::Reset() {
const char* value = this->m_resetValue.m_str;
if (!value) {
value = this->m_defaultValue.m_str;
}
if (!value) {
return;
}
if (this->m_callback) {
OsValidateFunctionPointer(reinterpret_cast<const void*>(this->m_callback));
if (!this->m_callback(this, this->m_stringValue.m_str, value, this->m_arg)) {
return;
}
}
this->InternalSet(value, true, false, false, true);
}
// VERIFY: 6f2e979e manual
// OFFSET: 0x00766A20
void CVar::Default() {
const char* value = this->m_defaultValue.m_str;
if (!value) {
value = this->m_resetValue.m_str;
}
if (!value) {
return;
}
if (this->m_callback) {
OsValidateFunctionPointer(reinterpret_cast<const void*>(this->m_callback));
if (!this->m_callback(this, this->m_stringValue.m_str, value, this->m_arg)) {
return;
}
}
this->InternalSet(value, true, false, false, true);
}
// VERIFY: 0165142c manual
// OFFSET: 0x00766AB0
bool CVar::Update() {
if (!(this->m_flags & 0x2) || !this->m_latchedValue.m_str) {
return false;
}
this->InternalSet(this->m_latchedValue.m_str, true, false, false, true);
this->m_latchedValue.Copy(nullptr);
return true;
}
// VERIFY: 1e80d7be manual
// OFFSET: 0x00766B20
void CVarArrayWrapper::UpdateFromVersion(int32_t version) {
if (version != 1) {
return;
}
CVar* cvar = this->m_cvar;
char buffer[256];
uint32_t out = 1;
int32_t bits = 0;
int32_t used = 0;
const char* in = cvar->m_stringValue.m_str + 1;
buffer[0] = 2;
while (*in) {
if (out >= 0xFF) {
break;
}
if (!bits) {
buffer[out] = 0;
}
buffer[out] = static_cast<char>(((buffer[out] | ((*in & 0x7F) << (bits - used))) & 0x3F) | 0x40);
if (used > bits + 1) {
in++;
bits = bits - used + 7;
used = 0;
} else {
if (used < bits + 1) {
used += 6 - bits;
} else {
in++;
used = 0;
}
out++;
bits = 0;
}
}
if (bits) {
buffer[out + 1] = 0;
} else {
buffer[out] = 0;
}
cvar->Set(buffer, true, false, false, true);
}
// VERIFY: 69f5d46c manual
// OFFSET: 0x00766CA0
bool CVarArrayWrapper::RawSetValue(uint32_t index, bool value) {
const char* str = this->m_cvar->m_stringValue.m_str;
size_t length = strlen(str);
if (length >= 0xFF) {
return false;
}
char buffer[256];
strncpy(buffer, str, sizeof(buffer));
uint32_t pos = index / 6 + 1;
buffer[length] = 0;
buffer[0] = 2;
if (index / 6 + 2 >= sizeof(buffer)) {
return false;
}
if (value) {
if (length < pos) {
memset(&buffer[length], '@', pos - length + 1);
buffer[pos + 1] = 0;
}
buffer[pos] |= 1 << (index % 6);
} else {
if (pos > length) {
return true;
}
buffer[pos] &= ~(1 << (index % 6));
for (size_t i = length - 1; i; i--) {
if (buffer[i] != '@') {
break;
}
buffer[i] = 0;
}
}
this->m_cvar->Set(buffer, true, false, false, true);
return true;
}
// VERIFY: a08db58b manual
// OFFSET: 0x00766E80
CVar::CVar() {
}
// VERIFY: 5c888a55 manual
// OFFSET: 0x00766F00
void CVarIntListWrapper::UpdateFromVersion(int32_t version) {
if (version) {
return;
}
const uint8_t* str = reinterpret_cast<const uint8_t*>(this->m_cvar->m_stringValue.m_str);
int32_t weights[3] = { 220 * 220, 220, 1 };
int8_t digit = 0;
uint32_t value = 0;
while (*str) {
value += weights[digit++] * (*str - 35);
if (digit > 2) {
this->AddNextValue(value);
value = 0;
digit = 0;
}
str++;
}
this->WriteVersionTag();
}
// VERIFY: 39283ef7 manual
// OFFSET: 0x00766F70
uint32_t CVarIntListWrapper::GetNextValue() {
if (this->m_pos == 2) {
uint8_t version = 0;
if (this->m_cvar && this->m_cvar->m_stringValue.m_str[0] == 'v') {
version = this->m_cvar->m_stringValue.m_str[1];
}
if (version != 1) {
this->UpdateFromVersion(version);
this->m_pos = 2;
}
this->m_state = 1;
}
const char* str = this->m_cvar->m_stringValue.m_str + this->m_pos;
if (!str[0] || !str[1] || !str[2]) {
return 0;
}
this->m_pos += 3;
return 93 * (93 * (str[0] - 35) + str[1] - 35) + str[2] - 35;
}
// VERIFY: 417de4a6 manual
// OFFSET: 0x00767030
int32_t CVar::IterateForArchive(uint32_t category, uint32_t excludeFlags, int32_t (*callback)(const char* name, const char* value, void* arg), void* arg) {
for (CVar* var = s_registeredCVars.m_fulllist.Head(); var; var = s_registeredCVars.m_fulllist.Next(var)) {
if (!(var->m_flags & 0x1) || (var->m_flags & 0x80) || (var->m_flags & 0x30) != category || (var->m_flags & excludeFlags)) {
continue;
}
const char* value = var->m_latchedValue.m_str;
if (!value) {
value = var->m_stringValue.m_str;
}
if (!value) {
value = var->m_defaultValue.m_str;
}
if (!value) {
continue;
}
if ((!var->m_defaultValue.m_str || SStrCmpI(value, var->m_defaultValue.m_str, STORM_MAX_STR)) && !callback(var->m_key.m_str, value, arg)) {
return 0;
}
}
return 1;
}
// VERIFY: 1e7866dc auto
// OFFSET: 0x007670E0
int32_t CVar::SaveAll(HOSFILE file, uint32_t category, uint32_t excludeFlags) {
return CVar::IterateForArchive(category, excludeFlags, CVar::SaveCvar, file);
}
// VERIFY: d827a7c7 auto
// OFFSET: 0x00767100
int32_t CVar::SaveAll() {
if (!CVar::m_needsSave) {
return 1;
}
CVar::m_needsSave = false;
int32_t result = 0;
char path[260];
SStrCopy(path, "WTF\\", sizeof(path));
SStrPack(path, CVar::s_configFile, sizeof(path));
HOSFILE file = OsCreateFile(path, OS_GENERIC_WRITE, 0, OS_CREATE_ALWAYS, OS_FILE_ATTRIBUTE_NORMAL, OS_FILE_TYPE_ANY);
if (file != OS_INVALID_FILE) {
result = CVar::IterateForArchive(0, 0, CVar::SaveCvar, file);
OsCloseFile(file);
}
return result;
}
// VERIFY: be7badef auto
// OFFSET: 0x007671A0
int32_t CVar::LogAll(char* buffer, uint32_t size, uint32_t category, uint32_t excludeFlags) {
CVarLogBuffer log;
log.m_buffer = buffer;
log.m_size = size;
return CVar::IterateForArchive(category, excludeFlags, CVar::LogCvar, &log);
}
// VERIFY: da3d65c9 manual
// OFFSET: 0x00767350
void CVar::DeleteCharacterCVars() {
CVar* var = s_registeredCVars.m_fulllist.Head();
while (var) {
if ((var->m_flags & 0x1) && (var->m_flags & 0x30) == 0x20) {
var = s_registeredCVars.DeleteNode(var);
} else {
var = s_registeredCVars.Next(var);
}
}
}
// VERIFY: 318d83a3 manual
// OFFSET: 0x007673A0
void CVar::DeleteAccountCVars() {
CVar* var = s_registeredCVars.m_fulllist.Head();
while (var) {
if ((var->m_flags & 0x1) && (var->m_flags & 0x30) == 0x10) {
var = s_registeredCVars.DeleteNode(var);
} else {
var = s_registeredCVars.Next(var);
}
}
}
// VERIFY: 047464cf auto
// OFFSET: 0x007673F0
void CVar::Destroy() {
CVar::m_initialized = false;
CVar::SaveAll();
ConsoleCommandUnregister("set");
ConsoleCommandUnregister("cvar_reset");
ConsoleCommandUnregister("cvar_default");
ConsoleCommandUnregister("cvarlist");
s_registeredCVars.Clear();
}
// VERIFY: 917f454a auto
// OFFSET: 0x00767440
CVar* CVar::Lookup(const char* name) {
return name ? s_registeredCVars.Ptr(name) : nullptr;
}
// VERIFY: ec2acf96 manual
// OFFSET: 0x00767460
CVar* CVar::LookupRegistered(const char* name) {
if (!name) {
return nullptr;
}
CVar* var = s_registeredCVars.Ptr(name);
if (!var) {
return nullptr;
}
if (!(var->m_flags & 0x80000000) && !(var->m_flags & 0x80)) {
return nullptr;
}
return var;
}
// VERIFY: 3b3ad454 manual
// OFFSET: 0x00767FC0
CVar* CVar::Register(const char* name, const char* help, uint32_t flags, const char* value, bool (*callback)(CVar*, const char*, const char*, void*), uint32_t category, bool setCommand, void* arg, bool unk) {
if (!name || !*name || !value) {
return nullptr;
}
CVar* var = s_registeredCVars.Ptr(name);
if (var) {
bool setReset = var->m_resetValue.m_str == nullptr;
var->m_flags = flags | (var->m_flags & ~0x30);
bool setDefault = var->m_defaultValue.m_str == nullptr;
var->m_callback = callback;
var->m_arg = arg;
bool setValue = false;
if (callback && !callback(var, var->m_stringValue.m_str, var->m_stringValue.m_str, arg)) {
setValue = true;
}
var->Set(value, setValue, setReset, setDefault, false);
if (!setCommand) {
var->m_flags |= 0x80000000;
}
if (unk && !(var->m_flags & 0x80000000)) {
var->m_flags |= 0x80;
}
return var;
}
var = s_registeredCVars.New(name, 0, 0);
var->m_stringValue.Copy(nullptr);
var->m_floatValue = 0.0f;
var->m_intValue = 0;
var->m_modified = 0;
var->m_category = category;
var->m_defaultValue.Copy(nullptr);
var->m_resetValue.Copy(nullptr);
var->m_latchedValue.Copy(nullptr);
var->m_callback = callback;
var->m_flags = 0;
var->m_arg = arg;
var->m_help.Copy(help);
if (setCommand) {
var->Set(value, true, true, false, false);
} else {
var->Set(value, true, false, true, false);
}
var->m_flags = flags | 0x1;
if (!setCommand) {
var->m_flags = flags | 0x80000001;
}
if (unk && !(var->m_flags & 0x80000000)) {
var->m_flags |= 0x80;
}
ConsoleCommandRegister(var->m_key.m_str, CvarCommandHandler, static_cast<CATEGORY>(category), help);
return var;
}
// VERIFY: ff762198 auto
// OFFSET: 0x00768340
void CVar::Initialize(const char* fileName) {
CVar::s_configFile = fileName;
CVar::m_initialized = true;
char path[260];
SFile::GetBasePath(path, sizeof(path));
SStrPrintf(path, sizeof(path), "%s%s\\", path, "WTF");
TryCreateDirectory(path);
ConsoleCommandRegister("set", SetCommandHandler, CATEGORY_DEFAULT, "Set the value of a CVar");
ConsoleCommandRegister("cvar_reset", CvarResetCommandHandler, CATEGORY_DEFAULT, "Set the value of a CVar to it's startup value");
ConsoleCommandRegister("cvar_default", CvarDefaultCommandHandler, CATEGORY_DEFAULT, "Set the value of a CVar to it's coded default value");
ConsoleCommandRegister("cvarlist", CvarListCommandHandler, CATEGORY_DEFAULT, "List cvars");
CVar::Load(CVar::s_configFile);
}
// VERIFY: 23fe3f84 auto
// OFFSET: 0x005300D0
void CVarIntListWrapper::WriteVersionTag() {
this->m_buffer[1] = 1;
this->m_buffer[0] = 'v';
this->m_buffer[this->m_pos] = 0;
this->m_cvar->Set(this->m_buffer, true, false, false, true);
}