add KeyValues class (#303)

1 files changed, 1316 insertions, 132 deletions

diff --git a/NorthstarDLL/keyvalues.cpp b/NorthstarDLL/keyvalues.cpp
index 98a9ce66..afb7ae30 100644
--- a/NorthstarDLL/keyvalues.cpp
+++ b/NorthstarDLL/keyvalues.cpp
@@ -1,132 +1,1316 @@
-#include "pch.h"
-#include "modmanager.h"
-#include "filesystem.h"
-
-#include <fstream>
-
-AUTOHOOK_INIT()
-
-void ModManager::TryBuildKeyValues(const char* filename)
-{
-	spdlog::info("Building KeyValues for file {}", filename);
-
-	std::string normalisedPath = g_pModManager->NormaliseModFilePath(fs::path(filename));
-	fs::path compiledPath = GetCompiledAssetsPath() / filename;
-	fs::path compiledDir = compiledPath.parent_path();
-	fs::create_directories(compiledDir);
-
-	fs::path kvPath(filename);
-	std::string ogFilePath = "mod_original_";
-	ogFilePath += kvPath.filename().string();
-
-	std::string newKvs = "// AUTOGENERATED: MOD PATCH KV\n";
-
-	int patchNum = 0;
-
-	// copy over patch kv files, and add #bases to new file, last mods' patches should be applied first
-	// note: #include should be identical but it's actually just broken, thanks respawn
-	for (int64_t i = m_LoadedMods.size() - 1; i > -1; i--)
-	{
-		if (!m_LoadedMods[i].m_bEnabled)
-			continue;
-
-		size_t fileHash = STR_HASH(normalisedPath);
-		auto modKv = m_LoadedMods[i].KeyValues.find(fileHash);
-		if (modKv != m_LoadedMods[i].KeyValues.end())
-		{
-			// should result in smth along the lines of #include "mod_patch_5_mp_weapon_car.txt"
-
-			std::string patchFilePath = "mod_patch_";
-			patchFilePath += std::to_string(patchNum++);
-			patchFilePath += "_";
-			patchFilePath += kvPath.filename().string();
-
-			newKvs += "#base \"";
-			newKvs += patchFilePath;
-			newKvs += "\"\n";
-
-			fs::remove(compiledDir / patchFilePath);
-
-			fs::copy_file(m_LoadedMods[i].m_ModDirectory / "keyvalues" / filename, compiledDir / patchFilePath);
-		}
-	}
-
-	// add original #base last, #bases don't override preexisting keys, including the ones we've just done
-	newKvs += "#base \"";
-	newKvs += ogFilePath;
-	newKvs += "\"\n";
-
-	// load original file, so we can parse out the name of the root obj (e.g. WeaponData for weapons)
-	std::string originalFile = R2::ReadVPKOriginalFile(filename);
-
-	if (!originalFile.length())
-	{
-		spdlog::warn("Tried to patch kv {} but no base kv was found!", ogFilePath);
-		return;
-	}
-
-	char rootName[64];
-	memset(rootName, 0, sizeof(rootName));
-
-	// iterate until we hit an ascii char that isn't in a # command or comment to get root obj name
-	int i = 0;
-	while (!(originalFile[i] >= 65 && originalFile[i] <= 122))
-	{
-		// if we hit a comment or # thing, iterate until end of line
-		if (originalFile[i] == '/' || originalFile[i] == '#')
-			while (originalFile[i] != '\n')
-				i++;
-
-		i++;
-	}
-
-	int j = 0;
-	for (int j = 0; originalFile[i] >= 65 && originalFile[i] <= 122; j++)
-		rootName[j] = originalFile[i++];
-
-	// empty kv, all the other stuff gets #base'd
-	newKvs += rootName;
-	newKvs += "\n{\n}\n";
-
-	std::ofstream originalFileWriteStream(compiledDir / ogFilePath, std::ios::binary);
-	originalFileWriteStream << originalFile;
-	originalFileWriteStream.close();
-
-	std::ofstream writeStream(compiledPath, std::ios::binary);
-	writeStream << newKvs;
-	writeStream.close();
-
-	ModOverrideFile overrideFile;
-	overrideFile.m_pOwningMod = nullptr;
-	overrideFile.m_Path = normalisedPath;
-
-	if (m_ModFiles.find(normalisedPath) == m_ModFiles.end())
-		m_ModFiles.insert(std::make_pair(normalisedPath, overrideFile));
-	else
-		m_ModFiles[normalisedPath] = overrideFile;
-}
-
-// clang-format off
-AUTOHOOK(KeyValues__LoadFromBuffer, engine.dll + 0x426C30,
-char, __fastcall, (void* self, const char* resourceName, const char* pBuffer, void* pFileSystem, void* a5, void* a6, int a7))
-// clang-format on
-{
-	static void* pSavedFilesystemPtr = nullptr;
-
-	// this is just to allow playlists to get a valid pFileSystem ptr for kv building, other functions that call this particular overload of
-	// LoadFromBuffer seem to get called on network stuff exclusively not exactly sure what the address wanted here is, so just taking it
-	// from a function call that always happens before playlists is loaded
-
-	// note: would be better if we could serialize this to disk for playlists, as this method breaks saving playlists in demos
-	if (pFileSystem != nullptr)
-		pSavedFilesystemPtr = pFileSystem;
-	if (!pFileSystem && !strcmp(resourceName, "playlists"))
-		pFileSystem = pSavedFilesystemPtr;
-
-	return KeyValues__LoadFromBuffer(self, resourceName, pBuffer, pFileSystem, a5, a6, a7);
-}
-
-ON_DLL_LOAD("engine.dll", KeyValues, (CModule module))
-{
-	AUTOHOOK_DISPATCH()
-}
+#include "pch.h"

+#include "keyvalues.h"

+#include <winnt.h>

+

+// implementation of the ConVar class

+// heavily based on https://github.com/Mauler125/r5sdk/blob/master/r5dev/vpc/keyvalues.cpp

+

+typedef int HKeySymbol;

+#define INVALID_KEY_SYMBOL (-1)

+

+#define MAKE_3_BYTES_FROM_1_AND_2(x1, x2) ((((uint16_t)x2) << 8) | (uint8_t)(x1))

+#define SPLIT_3_BYTES_INTO_1_AND_2(x1, x2, x3)                                                                                             \

+	do                                                                                                                                     \

+	{                                                                                                                                      \

+		x1 = (uint8_t)(x3);                                                                                                                \

+		x2 = (uint16_t)((x3) >> 8);                                                                                                        \

+	} while (0)

+

+struct CKeyValuesSystem

+{

+  public:

+	struct __VTable

+	{

+		char pad0[8 * 3]; // 2 methods

+		HKeySymbol (*GetSymbolForString)(CKeyValuesSystem* self, const char* name, bool bCreate);

+		const char* (*GetStringForSymbol)(CKeyValuesSystem* self, HKeySymbol symbol);

+		char pad1[8 * 5];

+		HKeySymbol (*GetSymbolForStringCaseSensitive)(

+			CKeyValuesSystem* self, HKeySymbol& hCaseInsensitiveSymbol, const char* name, bool bCreate);

+	};

+

+	const __VTable* m_pVtable;

+};

+

+int (*V_UTF8ToUnicode)(const char* pUTF8, wchar_t* pwchDest, int cubDestSizeInBytes);

+int (*V_UnicodeToUTF8)(const wchar_t* pUnicode, char* pUTF8, int cubDestSizeInBytes);

+CKeyValuesSystem* (*KeyValuesSystem)();

+

+KeyValues::KeyValues() {} // default constructor for copying and such

+

+//-----------------------------------------------------------------------------

+// Purpose: Constructor

+// Input  : *pszSetName -

+//-----------------------------------------------------------------------------

+KeyValues::KeyValues(const char* pszSetName)

+{

+	Init();

+	SetName(pszSetName);

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: Constructor

+// Input  : *pszSetName -

+//			*pszFirstKey -

+//			*pszFirstValue -

+//-----------------------------------------------------------------------------

+KeyValues::KeyValues(const char* pszSsetName, const char* pszFirstKey, const char* pszFirstValue)

+{

+	Init();

+	SetName(pszSsetName);

+	SetString(pszFirstKey, pszFirstValue);

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: Constructor

+// Input  : *pszSetName -

+//			*pszFirstKey -

+//			*pwszFirstValue -

+//-----------------------------------------------------------------------------

+KeyValues::KeyValues(const char* pszSetName, const char* pszFirstKey, const wchar_t* pwszFirstValue)

+{

+	Init();

+	SetName(pszSetName);

+	SetWString(pszFirstKey, pwszFirstValue);

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: Constructor

+// Input  : *pszSetName -

+//			*pszFirstKey -

+//			iFirstValue -

+//-----------------------------------------------------------------------------

+KeyValues::KeyValues(const char* pszSetName, const char* pszFirstKey, int iFirstValue)

+{

+	Init();

+	SetName(pszSetName);

+	SetInt(pszFirstKey, iFirstValue);

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: Constructor

+// Input  : *pszSetName -

+//			*pszFirstKey -

+//			*pszFirstValue -

+//			*pszSecondKey -

+//			*pszSecondValue -

+//-----------------------------------------------------------------------------

+KeyValues::KeyValues(

+	const char* pszSetName, const char* pszFirstKey, const char* pszFirstValue, const char* pszSecondKey, const char* pszSecondValue)

+{

+	Init();

+	SetName(pszSetName);

+	SetString(pszFirstKey, pszFirstValue);

+	SetString(pszSecondKey, pszSecondValue);

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: Constructor

+// Input  : *pszSetName -

+//			*pszFirstKey -

+//			iFirstValue -

+//			*pszSecondKey -

+//			iSecondValue -

+//-----------------------------------------------------------------------------

+KeyValues::KeyValues(const char* pszSetName, const char* pszFirstKey, int iFirstValue, const char* pszSecondKey, int iSecondValue)

+{

+	Init();

+	SetName(pszSetName);

+	SetInt(pszFirstKey, iFirstValue);

+	SetInt(pszSecondKey, iSecondValue);

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: Destructor

+//-----------------------------------------------------------------------------

+KeyValues::~KeyValues(void)

+{

+	RemoveEverything();

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: Initialize member variables

+//-----------------------------------------------------------------------------

+void KeyValues::Init(void)

+{

+	m_iKeyName = 0;

+	m_iKeyNameCaseSensitive1 = 0;

+	m_iKeyNameCaseSensitive2 = 0;

+	m_iDataType = TYPE_NONE;

+

+	m_pSub = nullptr;

+	m_pPeer = nullptr;

+	m_pChain = nullptr;

+

+	m_sValue = nullptr;

+	m_wsValue = nullptr;

+	m_pValue = nullptr;

+

+	m_bHasEscapeSequences = 0;

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: Clear out all subkeys, and the current value

+//-----------------------------------------------------------------------------

+void KeyValues::Clear(void)

+{

+	delete m_pSub;

+	m_pSub = nullptr;

+	m_iDataType = TYPE_NONE;

+}

+

+//-----------------------------------------------------------------------------

+// for backwards compat - we used to need this to force the free to run from the same DLL

+// as the alloc

+//-----------------------------------------------------------------------------

+void KeyValues::DeleteThis(void)

+{

+	delete this;

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: remove everything

+//-----------------------------------------------------------------------------

+void KeyValues::RemoveEverything(void)

+{

+	KeyValues* dat;

+	KeyValues* datNext = nullptr;

+	for (dat = m_pSub; dat != nullptr; dat = datNext)

+	{

+		datNext = dat->m_pPeer;

+		dat->m_pPeer = nullptr;

+		delete dat;

+	}

+

+	for (dat = m_pPeer; dat && dat != this; dat = datNext)

+	{

+		datNext = dat->m_pPeer;

+		dat->m_pPeer = nullptr;

+		delete dat;

+	}

+

+	delete[] m_sValue;

+	m_sValue = nullptr;

+	delete[] m_wsValue;

+	m_wsValue = nullptr;

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: Find a keyValue, create it if it is not found.

+//			Set bCreate to true to create the key if it doesn't already exist

+//			(which ensures a valid pointer will be returned)

+// Input  : *pszKeyName -

+//			bCreate -

+// Output : *KeyValues

+//-----------------------------------------------------------------------------

+KeyValues* KeyValues::FindKey(const char* pszKeyName, bool bCreate)

+{

+	assert(this, "Member function called on NULL KeyValues");

+

+	if (!pszKeyName || !*pszKeyName)

+		return this;

+

+	const char* pSubStr = strchr(pszKeyName, '/');

+

+	HKeySymbol iSearchStr = KeyValuesSystem()->m_pVtable->GetSymbolForString(KeyValuesSystem(), pszKeyName, bCreate);

+	if (iSearchStr == INVALID_KEY_SYMBOL)

+	{

+		// not found, couldn't possibly be in key value list

+		return nullptr;

+	}

+

+	KeyValues* pLastKVs = nullptr;

+	KeyValues* pCurrentKVs;

+	// find the searchStr in the current peer list

+	for (pCurrentKVs = m_pSub; pCurrentKVs != NULL; pCurrentKVs = pCurrentKVs->m_pPeer)

+	{

+		pLastKVs = pCurrentKVs; // record the last item looked at (for if we need to append to the end of the list)

+

+		// symbol compare

+		if (pLastKVs->m_iKeyName == (uint32_t)iSearchStr)

+			break;

+	}

+

+	if (!pCurrentKVs && m_pChain)

+		pCurrentKVs = m_pChain->FindKey(pszKeyName, false);

+

+	// make sure a key was found

+	if (!pCurrentKVs)

+	{

+		if (bCreate)

+		{

+			// we need to create a new key

+			pCurrentKVs = new KeyValues(pszKeyName);

+			//			Assert(dat != NULL);

+

+			// insert new key at end of list

+			if (pLastKVs)

+				pLastKVs->m_pPeer = pCurrentKVs;

+			else

+				m_pSub = pCurrentKVs;

+

+			pCurrentKVs->m_pPeer = NULL;

+

+			// a key graduates to be a submsg as soon as it's m_pSub is set

+			// this should be the only place m_pSub is set

+			m_iDataType = TYPE_NONE;

+		}

+		else

+		{

+			return NULL;

+		}

+	}

+

+	// if we've still got a subStr we need to keep looking deeper in the tree

+	if (pSubStr)

+	{

+		// recursively chain down through the paths in the string

+		return pCurrentKVs->FindKey(pSubStr + 1, bCreate);

+	}

+

+	return pCurrentKVs;

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: Locate last child.  Returns NULL if we have no children

+// Output : *KeyValues

+//-----------------------------------------------------------------------------

+KeyValues* KeyValues::FindLastSubKey(void) const

+{

+	// No children?

+	if (m_pSub == nullptr)

+		return nullptr;

+

+	// Scan for the last one

+	KeyValues* pLastChild = m_pSub;

+	while (pLastChild->m_pPeer)

+		pLastChild = pLastChild->m_pPeer;

+	return pLastChild;

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: Adds a subkey. Make sure the subkey isn't a child of some other keyvalues

+// Input  : *pSubKey -

+//-----------------------------------------------------------------------------

+void KeyValues::AddSubKey(KeyValues* pSubkey)

+{

+	// Make sure the subkey isn't a child of some other keyvalues

+	assert(pSubkey != nullptr);

+	assert(pSubkey->m_pPeer == nullptr);

+

+	// add into subkey list

+	if (m_pSub == nullptr)

+	{

+		m_pSub = pSubkey;

+	}

+	else

+	{

+		KeyValues* pTempDat = m_pSub;

+		while (pTempDat->GetNextKey() != nullptr)

+		{

+			pTempDat = pTempDat->GetNextKey();

+		}

+

+		pTempDat->SetNextKey(pSubkey);

+	}

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: Remove a subkey from the list

+// Input  : *pSubKey -

+//-----------------------------------------------------------------------------

+void KeyValues::RemoveSubKey(KeyValues* pSubKey)

+{

+	if (!pSubKey)

+		return;

+

+	// check the list pointer

+	if (m_pSub == pSubKey)

+	{

+		m_pSub = pSubKey->m_pPeer;

+	}

+	else

+	{

+		// look through the list

+		KeyValues* kv = m_pSub;

+		while (kv->m_pPeer)

+		{

+			if (kv->m_pPeer == pSubKey)

+			{

+				kv->m_pPeer = pSubKey->m_pPeer;

+				break;

+			}

+

+			kv = kv->m_pPeer;

+		}

+	}

+

+	pSubKey->m_pPeer = nullptr;

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: Insert a subkey at index

+// Input  : nIndex -

+//			*pSubKey -

+//-----------------------------------------------------------------------------

+void KeyValues::InsertSubKey(int nIndex, KeyValues* pSubKey)

+{

+	// Sub key must be valid and not part of another chain

+	assert(pSubKey && pSubKey->m_pPeer == nullptr);

+

+	if (nIndex == 0)

+	{

+		pSubKey->m_pPeer = m_pSub;

+		m_pSub = pSubKey;

+		return;

+	}

+	else

+	{

+		int nCurrentIndex = 0;

+		for (KeyValues* pIter = GetFirstSubKey(); pIter != nullptr; pIter = pIter->GetNextKey())

+		{

+			++nCurrentIndex;

+			if (nCurrentIndex == nIndex)

+			{

+				pSubKey->m_pPeer = pIter->m_pPeer;

+				pIter->m_pPeer = pSubKey;

+				return;

+			}

+		}

+		// Index is out of range if we get here

+		assert(0);

+		return;

+	}

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: Checks if key contains a subkey

+// Input  : *pSubKey -

+// Output : true if contains, false otherwise

+//-----------------------------------------------------------------------------

+bool KeyValues::ContainsSubKey(KeyValues* pSubKey)

+{

+	for (KeyValues* pIter = GetFirstSubKey(); pIter != nullptr; pIter = pIter->GetNextKey())

+	{

+		if (pSubKey == pIter)

+		{

+			return true;

+		}

+	}

+	return false;

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: Swaps existing subkey with another

+// Input  : *pExistingSubkey -

+//			*pNewSubKey -

+//-----------------------------------------------------------------------------

+void KeyValues::SwapSubKey(KeyValues* pExistingSubkey, KeyValues* pNewSubKey)

+{

+	assert(pExistingSubkey != nullptr && pNewSubKey != nullptr);

+

+	// Make sure the new sub key isn't a child of some other keyvalues

+	assert(pNewSubKey->m_pPeer == nullptr);

+

+	// Check the list pointer

+	if (m_pSub == pExistingSubkey)

+	{

+		pNewSubKey->m_pPeer = pExistingSubkey->m_pPeer;

+		pExistingSubkey->m_pPeer = nullptr;

+		m_pSub = pNewSubKey;

+	}

+	else

+	{

+		// Look through the list

+		KeyValues* kv = m_pSub;

+		while (kv->m_pPeer)

+		{

+			if (kv->m_pPeer == pExistingSubkey)

+			{

+				pNewSubKey->m_pPeer = pExistingSubkey->m_pPeer;

+				pExistingSubkey->m_pPeer = nullptr;

+				kv->m_pPeer = pNewSubKey;

+				break;

+			}

+

+			kv = kv->m_pPeer;

+		}

+		// Existing sub key should always be found, otherwise it's a bug in the calling code.

+		assert(kv->m_pPeer != nullptr);

+	}

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: Elides subkey

+// Input  : *pSubKey -

+//-----------------------------------------------------------------------------

+void KeyValues::ElideSubKey(KeyValues* pSubKey)

+{

+	// This pointer's "next" pointer needs to be fixed up when we elide the key

+	KeyValues** ppPointerToFix = &m_pSub;

+	for (KeyValues* pKeyIter = m_pSub; pKeyIter != nullptr; ppPointerToFix = &pKeyIter->m_pPeer, pKeyIter = pKeyIter->GetNextKey())

+	{

+		if (pKeyIter == pSubKey)

+		{

+			if (pSubKey->m_pSub == nullptr)

+			{

+				// No children, simply remove the key

+				*ppPointerToFix = pSubKey->m_pPeer;

+				delete pSubKey;

+			}

+			else

+			{

+				*ppPointerToFix = pSubKey->m_pSub;

+				// Attach the remainder of this chain to the last child of pSubKey

+				KeyValues* pChildIter = pSubKey->m_pSub;

+				while (pChildIter->m_pPeer != nullptr)

+				{

+					pChildIter = pChildIter->m_pPeer;

+				}

+				// Now points to the last child of pSubKey

+				pChildIter->m_pPeer = pSubKey->m_pPeer;

+				// Detach the node to be elided

+				pSubKey->m_pSub = nullptr;

+				pSubKey->m_pPeer = nullptr;

+				delete pSubKey;

+			}

+			return;

+		}

+	}

+	// Key not found; that's caller error.

+	assert(0);

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: Check if a keyName has no value assigned to it.

+// Input  : *pszKeyName -

+// Output : true on success, false otherwise

+//-----------------------------------------------------------------------------

+bool KeyValues::IsEmpty(const char* pszKeyName)

+{

+	KeyValues* pKey = FindKey(pszKeyName, false);

+	if (!pKey)

+		return true;

+

+	if (pKey->m_iDataType == TYPE_NONE && pKey->m_pSub == nullptr)

+		return true;

+

+	return false;

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: gets the first true sub key

+// Output : *KeyValues

+//-----------------------------------------------------------------------------

+KeyValues* KeyValues::GetFirstTrueSubKey(void) const

+{

+	assert(this, "Member function called on NULL KeyValues");

+	KeyValues* pRet = this ? m_pSub : nullptr;

+	while (pRet && pRet->m_iDataType != TYPE_NONE)

+		pRet = pRet->m_pPeer;

+

+	return pRet;

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: gets the next true sub key

+// Output : *KeyValues

+//-----------------------------------------------------------------------------

+KeyValues* KeyValues::GetNextTrueSubKey(void) const

+{

+	assert(this, "Member function called on NULL KeyValues");

+	KeyValues* pRet = this ? m_pPeer : nullptr;

+	while (pRet && pRet->m_iDataType != TYPE_NONE)

+		pRet = pRet->m_pPeer;

+

+	return pRet;

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: gets the first value

+// Output : *KeyValues

+//-----------------------------------------------------------------------------

+KeyValues* KeyValues::GetFirstValue(void) const

+{

+	assert(this, "Member function called on NULL KeyValues");

+	KeyValues* pRet = this ? m_pSub : nullptr;

+	while (pRet && pRet->m_iDataType == TYPE_NONE)

+		pRet = pRet->m_pPeer;

+

+	return pRet;

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: gets the next value

+// Output : *KeyValues

+//-----------------------------------------------------------------------------

+KeyValues* KeyValues::GetNextValue(void) const

+{

+	assert(this, "Member function called on NULL KeyValues");

+	KeyValues* pRet = this ? m_pPeer : nullptr;

+	while (pRet && pRet->m_iDataType == TYPE_NONE)

+		pRet = pRet->m_pPeer;

+

+	return pRet;

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: Return the first subkey in the list

+//-----------------------------------------------------------------------------

+KeyValues* KeyValues::GetFirstSubKey() const

+{

+	assert(this, "Member function called on NULL KeyValues");

+	return this ? m_pSub : nullptr;

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: Return the next subkey

+//-----------------------------------------------------------------------------

+KeyValues* KeyValues::GetNextKey() const

+{

+	assert(this, "Member function called on NULL KeyValues");

+	return this ? m_pPeer : nullptr;

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: Get the name of the current key section

+// Output : const char*

+//-----------------------------------------------------------------------------

+const char* KeyValues::GetName(void) const

+{

+	return KeyValuesSystem()->m_pVtable->GetStringForSymbol(

+		KeyValuesSystem(), MAKE_3_BYTES_FROM_1_AND_2(m_iKeyNameCaseSensitive1, m_iKeyNameCaseSensitive2));

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: Get the integer value of a keyName. Default value is returned

+//			if the keyName can't be found.

+// Input  : *pszKeyName -

+//			nDefaultValue -

+// Output : int

+//-----------------------------------------------------------------------------

+int KeyValues::GetInt(const char* pszKeyName, int iDefaultValue)

+{

+	KeyValues* pKey = FindKey(pszKeyName, false);

+	if (pKey)

+	{

+		switch (pKey->m_iDataType)

+		{

+		case TYPE_STRING:

+			return atoi(pKey->m_sValue);

+		case TYPE_WSTRING:

+			return _wtoi(pKey->m_wsValue);

+		case TYPE_FLOAT:

+			return static_cast<int>(pKey->m_flValue);

+		case TYPE_UINT64:

+			// can't convert, since it would lose data

+			assert(0);

+			return 0;

+		case TYPE_INT:

+		case TYPE_PTR:

+		default:

+			return pKey->m_iValue;

+		};

+	}

+	return iDefaultValue;

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: Get the integer value of a keyName. Default value is returned

+//			if the keyName can't be found.

+// Input  : *pszKeyName -

+//			nDefaultValue -

+// Output : uint64_t

+//-----------------------------------------------------------------------------

+uint64_t KeyValues::GetUint64(const char* pszKeyName, uint64_t nDefaultValue)

+{

+	KeyValues* pKey = FindKey(pszKeyName, false);

+	if (pKey)

+	{

+		switch (pKey->m_iDataType)

+		{

+		case TYPE_STRING:

+		{

+			uint64_t uiResult = 0ull;

+			sscanf(pKey->m_sValue, "%lld", &uiResult);

+			return uiResult;

+		}

+		case TYPE_WSTRING:

+		{

+			uint64_t uiResult = 0ull;

+			swscanf(pKey->m_wsValue, L"%lld", &uiResult);

+			return uiResult;

+		}

+		case TYPE_FLOAT:

+			return static_cast<int>(pKey->m_flValue);

+		case TYPE_UINT64:

+			return *reinterpret_cast<uint64_t*>(pKey->m_sValue);

+		case TYPE_PTR:

+			return static_cast<uint64_t>(reinterpret_cast<uintptr_t>(pKey->m_pValue));

+		case TYPE_INT:

+		default:

+			return pKey->m_iValue;

+		};

+	}

+	return nDefaultValue;

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: Get the pointer value of a keyName. Default value is returned

+//			if the keyName can't be found.

+// Input  : *pszKeyName -

+//			pDefaultValue -

+// Output : void*

+//-----------------------------------------------------------------------------

+void* KeyValues::GetPtr(const char* pszKeyName, void* pDefaultValue)

+{

+	KeyValues* pKey = FindKey(pszKeyName, false);

+	if (pKey)

+	{

+		switch (pKey->m_iDataType)

+		{

+		case TYPE_PTR:

+			return pKey->m_pValue;

+

+		case TYPE_WSTRING:

+		case TYPE_STRING:

+		case TYPE_FLOAT:

+		case TYPE_INT:

+		case TYPE_UINT64:

+		default:

+			return nullptr;

+		};

+	}

+	return pDefaultValue;

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: Get the float value of a keyName. Default value is returned

+//			if the keyName can't be found.

+// Input  : *pszKeyName -

+//			flDefaultValue -

+// Output : float

+//-----------------------------------------------------------------------------

+float KeyValues::GetFloat(const char* pszKeyName, float flDefaultValue)

+{

+	KeyValues* pKey = FindKey(pszKeyName, false);

+	if (pKey)

+	{

+		switch (pKey->m_iDataType)

+		{

+		case TYPE_STRING:

+			return static_cast<float>(atof(pKey->m_sValue));

+		case TYPE_WSTRING:

+			return static_cast<float>(_wtof(pKey->m_wsValue)); // no wtof

+		case TYPE_FLOAT:

+			return pKey->m_flValue;

+		case TYPE_INT:

+			return static_cast<float>(pKey->m_iValue);

+		case TYPE_UINT64:

+			return static_cast<float>((*(reinterpret_cast<uint64_t*>(pKey->m_sValue))));

+		case TYPE_PTR:

+		default:

+			return 0.0f;

+		};

+	}

+	return flDefaultValue;

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: Get the string pointer of a keyName. Default value is returned

+//			if the keyName can't be found.

+// // Input  : *pszKeyName -

+//			pszDefaultValue -

+// Output : const char*

+//-----------------------------------------------------------------------------

+const char* KeyValues::GetString(const char* pszKeyName, const char* pszDefaultValue)

+{

+	KeyValues* pKey = FindKey(pszKeyName, false);

+	if (pKey)

+	{

+		// convert the data to string form then return it

+		char buf[64];

+		switch (pKey->m_iDataType)

+		{

+		case TYPE_FLOAT:

+			snprintf(buf, sizeof(buf), "%f", pKey->m_flValue);

+			SetString(pszKeyName, buf);

+			break;

+		case TYPE_PTR:

+			snprintf(buf, sizeof(buf), "%lld", reinterpret_cast<uint64_t>(pKey->m_pValue));

+			SetString(pszKeyName, buf);

+			break;

+		case TYPE_INT:

+			snprintf(buf, sizeof(buf), "%d", pKey->m_iValue);

+			SetString(pszKeyName, buf);

+			break;

+		case TYPE_UINT64:

+			snprintf(buf, sizeof(buf), "%lld", *(reinterpret_cast<uint64_t*>(pKey->m_sValue)));

+			SetString(pszKeyName, buf);

+			break;

+		case TYPE_COLOR:

+			snprintf(buf, sizeof(buf), "%d %d %d %d", pKey->m_Color[0], pKey->m_Color[1], pKey->m_Color[2], pKey->m_Color[3]);

+			SetString(pszKeyName, buf);

+			break;

+

+		case TYPE_WSTRING:

+		{

+			// convert the string to char *, set it for future use, and return it

+			char wideBuf[512];

+			int result = V_UnicodeToUTF8(pKey->m_wsValue, wideBuf, 512);

+			if (result)

+			{

+				// note: this will copy wideBuf

+				SetString(pszKeyName, wideBuf);

+			}

+			else

+			{

+				return pszDefaultValue;

+			}

+			break;

+		}

+		case TYPE_STRING:

+			break;

+		default:

+			return pszDefaultValue;

+		};

+

+		return pKey->m_sValue;

+	}

+	return pszDefaultValue;

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: Get the wide string pointer of a keyName. Default value is returned

+//			if the keyName can't be found.

+// // Input  : *pszKeyName -

+//			pwszDefaultValue -

+// Output : const wchar_t*

+//-----------------------------------------------------------------------------

+const wchar_t* KeyValues::GetWString(const char* pszKeyName, const wchar_t* pwszDefaultValue)

+{

+	KeyValues* pKey = FindKey(pszKeyName, false);

+	if (pKey)

+	{

+		wchar_t wbuf[64];

+		switch (pKey->m_iDataType)

+		{

+		case TYPE_FLOAT:

+			swprintf(wbuf, ARRAYSIZE(wbuf), L"%f", pKey->m_flValue);

+			SetWString(pszKeyName, wbuf);

+			break;

+		case TYPE_PTR:

+			swprintf(wbuf, ARRAYSIZE(wbuf), L"%lld", static_cast<int64_t>(reinterpret_cast<size_t>(pKey->m_pValue)));

+			SetWString(pszKeyName, wbuf);

+			break;

+		case TYPE_INT:

+			swprintf(wbuf, ARRAYSIZE(wbuf), L"%d", pKey->m_iValue);

+			SetWString(pszKeyName, wbuf);

+			break;

+		case TYPE_UINT64:

+		{

+			swprintf(wbuf, ARRAYSIZE(wbuf), L"%lld", *(reinterpret_cast<uint64_t*>(pKey->m_sValue)));

+			SetWString(pszKeyName, wbuf);

+		}

+		break;

+		case TYPE_COLOR:

+			swprintf(wbuf, ARRAYSIZE(wbuf), L"%d %d %d %d", pKey->m_Color[0], pKey->m_Color[1], pKey->m_Color[2], pKey->m_Color[3]);

+			SetWString(pszKeyName, wbuf);

+			break;

+

+		case TYPE_WSTRING:

+			break;

+		case TYPE_STRING:

+		{

+			size_t bufSize = strlen(pKey->m_sValue) + 1;

+			wchar_t* pWBuf = new wchar_t[bufSize];

+			int result = V_UTF8ToUnicode(pKey->m_sValue, pWBuf, static_cast<int>(bufSize * sizeof(wchar_t)));

+			if (result >= 0) // may be a zero length string

+			{

+				SetWString(pszKeyName, pWBuf);

+				delete[] pWBuf;

+			}

+			else

+			{

+				delete[] pWBuf;

+				return pwszDefaultValue;

+			}

+

+			break;

+		}

+		default:

+			return pwszDefaultValue;

+		};

+

+		return reinterpret_cast<const wchar_t*>(pKey->m_wsValue);

+	}

+	return pwszDefaultValue;

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: Gets a color

+// Input  : *pszKeyName -

+//			&defaultColor -

+// Output : Color

+//-----------------------------------------------------------------------------

+Color KeyValues::GetColor(const char* pszKeyName, const Color& defaultColor)

+{

+	Color color = defaultColor;

+	KeyValues* pKey = FindKey(pszKeyName, false);

+	if (pKey)

+	{

+		if (pKey->m_iDataType == TYPE_COLOR)

+		{

+			color[0] = pKey->m_Color[0];

+			color[1] = pKey->m_Color[1];

+			color[2] = pKey->m_Color[2];

+			color[3] = pKey->m_Color[3];

+		}

+		else if (pKey->m_iDataType == TYPE_FLOAT)

+		{

+			color[0] = static_cast<unsigned char>(pKey->m_flValue);

+		}

+		else if (pKey->m_iDataType == TYPE_INT)

+		{

+			color[0] = static_cast<unsigned char>(pKey->m_iValue);

+		}

+		else if (pKey->m_iDataType == TYPE_STRING)

+		{

+			// parse the colors out of the string

+			float a = 0, b = 0, c = 0, d = 0;

+			sscanf(pKey->m_sValue, "%f %f %f %f", &a, &b, &c, &d);

+			color[0] = static_cast<unsigned char>(a);

+			color[1] = static_cast<unsigned char>(b);

+			color[2] = static_cast<unsigned char>(c);

+			color[3] = static_cast<unsigned char>(d);

+		}

+	}

+	return color;

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: Get the data type of the value stored in a keyName

+// Input  : *pszKeyName -

+//-----------------------------------------------------------------------------

+KeyValuesTypes_t KeyValues::GetDataType(const char* pszKeyName)

+{

+	KeyValues* pKey = FindKey(pszKeyName, false);

+	if (pKey)

+		return static_cast<KeyValuesTypes_t>(pKey->m_iDataType);

+

+	return TYPE_NONE;

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: Get the data type of the value stored in this keyName

+//-----------------------------------------------------------------------------

+KeyValuesTypes_t KeyValues::GetDataType(void) const

+{

+	return static_cast<KeyValuesTypes_t>(m_iDataType);

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: Set the integer value of a keyName.

+// Input  : *pszKeyName -

+//			iValue -

+//-----------------------------------------------------------------------------

+void KeyValues::SetInt(const char* pszKeyName, int iValue)

+{

+	KeyValues* pKey = FindKey(pszKeyName, true);

+	if (pKey)

+	{

+		pKey->m_iValue = iValue;

+		pKey->m_iDataType = TYPE_INT;

+	}

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: Set the integer value of a keyName.

+//-----------------------------------------------------------------------------

+void KeyValues::SetUint64(const char* pszKeyName, uint64_t nValue)

+{

+	KeyValues* pKey = FindKey(pszKeyName, true);

+

+	if (pKey)

+	{

+		// delete the old value

+		delete[] pKey->m_sValue;

+		// make sure we're not storing the WSTRING  - as we're converting over to STRING

+		delete[] pKey->m_wsValue;

+		pKey->m_wsValue = nullptr;

+

+		pKey->m_sValue = new char[sizeof(uint64_t)];

+		*(reinterpret_cast<uint64_t*>(pKey->m_sValue)) = nValue;

+		pKey->m_iDataType = TYPE_UINT64;

+	}

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: Set the float value of a keyName.

+// Input  : *pszKeyName -

+//			flValue -

+//-----------------------------------------------------------------------------

+void KeyValues::SetFloat(const char* pszKeyName, float flValue)

+{

+	KeyValues* pKey = FindKey(pszKeyName, true);

+	if (pKey)

+	{

+		pKey->m_flValue = flValue;

+		pKey->m_iDataType = TYPE_FLOAT;

+	}

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: Set the name value of a keyName.

+// Input  : *pszSetName -

+//-----------------------------------------------------------------------------

+void KeyValues::SetName(const char* pszSetName)

+{

+	HKeySymbol hCaseSensitiveKeyName = INVALID_KEY_SYMBOL, hCaseInsensitiveKeyName = INVALID_KEY_SYMBOL;

+	hCaseSensitiveKeyName =

+		KeyValuesSystem()->m_pVtable->GetSymbolForStringCaseSensitive(KeyValuesSystem(), hCaseInsensitiveKeyName, pszSetName, false);

+

+	m_iKeyName = hCaseInsensitiveKeyName;

+	SPLIT_3_BYTES_INTO_1_AND_2(m_iKeyNameCaseSensitive1, m_iKeyNameCaseSensitive2, hCaseSensitiveKeyName);

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: Set the pointer value of a keyName.

+// Input  : *pszKeyName -

+//			*pValue -

+//-----------------------------------------------------------------------------

+void KeyValues::SetPtr(const char* pszKeyName, void* pValue)

+{

+	KeyValues* pKey = FindKey(pszKeyName, true);

+

+	if (pKey)

+	{

+		pKey->m_pValue = pValue;

+		pKey->m_iDataType = TYPE_PTR;

+	}

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: Set the string value (internal)

+// Input  : *pszValue -

+//-----------------------------------------------------------------------------

+void KeyValues::SetStringValue(char const* pszValue)

+{

+	// delete the old value

+	delete[] m_sValue;

+	// make sure we're not storing the WSTRING  - as we're converting over to STRING

+	delete[] m_wsValue;

+	m_wsValue = nullptr;

+

+	if (!pszValue)

+	{

+		// ensure a valid value

+		pszValue = "";

+	}

+

+	// allocate memory for the new value and copy it in

+	size_t len = strlen(pszValue);

+	m_sValue = new char[len + 1];

+	memcpy(m_sValue, pszValue, len + 1);

+

+	m_iDataType = TYPE_STRING;

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: Sets this key's peer to the KeyValues passed in

+// Input  : *pDat -

+//-----------------------------------------------------------------------------

+void KeyValues::SetNextKey(KeyValues* pDat)

+{

+	m_pPeer = pDat;

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: Set the string value of a keyName.

+// Input  : *pszKeyName -

+//			*pszValue -

+//-----------------------------------------------------------------------------

+void KeyValues::SetString(const char* pszKeyName, const char* pszValue)

+{

+	if (KeyValues* pKey = FindKey(pszKeyName, true))

+	{

+		pKey->SetStringValue(pszValue);

+	}

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: Set the string value of a keyName.

+// Input  : *pszKeyName -

+//			*pwszValue -

+//-----------------------------------------------------------------------------

+void KeyValues::SetWString(const char* pszKeyName, const wchar_t* pwszValue)

+{

+	KeyValues* pKey = FindKey(pszKeyName, true);

+	if (pKey)

+	{

+		// delete the old value

+		delete[] pKey->m_wsValue;

+		// make sure we're not storing the STRING  - as we're converting over to WSTRING

+		delete[] pKey->m_sValue;

+		pKey->m_sValue = nullptr;

+

+		if (!pwszValue)

+		{

+			// ensure a valid value

+			pwszValue = L"";

+		}

+

+		// allocate memory for the new value and copy it in

+		size_t len = wcslen(pwszValue);

+		pKey->m_wsValue = new wchar_t[len + 1];

+		memcpy(pKey->m_wsValue, pwszValue, (len + 1) * sizeof(wchar_t));

+

+		pKey->m_iDataType = TYPE_WSTRING;

+	}

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: Sets a color

+// Input  : *pszKeyName -

+//			color -

+//-----------------------------------------------------------------------------

+void KeyValues::SetColor(const char* pszKeyName, Color color)

+{

+	KeyValues* pKey = FindKey(pszKeyName, true);

+

+	if (pKey)

+	{

+		pKey->m_iDataType = TYPE_COLOR;

+		pKey->m_Color[0] = color[0];

+		pKey->m_Color[1] = color[1];

+		pKey->m_Color[2] = color[2];

+		pKey->m_Color[3] = color[3];

+	}

+}

+

+//-----------------------------------------------------------------------------

+// Purpose:

+// Input  : &src -

+//-----------------------------------------------------------------------------

+void KeyValues::RecursiveCopyKeyValues(KeyValues& src)

+{

+	// garymcthack - need to check this code for possible buffer overruns.

+

+	m_iKeyName = src.m_iKeyName;

+	m_iKeyNameCaseSensitive1 = src.m_iKeyNameCaseSensitive1;

+	m_iKeyNameCaseSensitive2 = src.m_iKeyNameCaseSensitive2;

+

+	if (!src.m_pSub)

+	{

+		m_iDataType = src.m_iDataType;

+		char buf[256];

+		switch (src.m_iDataType)

+		{

+		case TYPE_NONE:

+			break;

+		case TYPE_STRING:

+			if (src.m_sValue)

+			{

+				size_t len = strlen(src.m_sValue) + 1;

+				m_sValue = new char[len];

+				strncpy(m_sValue, src.m_sValue, len);

+			}

+			break;

+		case TYPE_INT:

+		{

+			m_iValue = src.m_iValue;

+			snprintf(buf, sizeof(buf), "%d", m_iValue);

+			size_t len = strlen(buf) + 1;

+			m_sValue = new char[len];

+			strncpy(m_sValue, buf, len);

+		}

+		break;

+		case TYPE_FLOAT:

+		{

+			m_flValue = src.m_flValue;

+			snprintf(buf, sizeof(buf), "%f", m_flValue);

+			size_t len = strlen(buf) + 1;

+			m_sValue = new char[len];

+			strncpy(m_sValue, buf, len);

+		}

+		break;

+		case TYPE_PTR:

+		{

+			m_pValue = src.m_pValue;

+		}

+		break;

+		case TYPE_UINT64:

+		{

+			m_sValue = new char[sizeof(uint64_t)];

+			memcpy(m_sValue, src.m_sValue, sizeof(uint64_t));

+		}

+		break;

+		case TYPE_COLOR:

+		{

+			m_Color[0] = src.m_Color[0];

+			m_Color[1] = src.m_Color[1];

+			m_Color[2] = src.m_Color[2];

+			m_Color[3] = src.m_Color[3];

+		}

+		break;

+

+		default:

+		{

+			// do nothing . .what the heck is this?

+			assert(0);

+		}

+		break;

+		}

+	}

+

+	// Handle the immediate child

+	if (src.m_pSub)

+	{

+		m_pSub = new KeyValues;

+

+		m_pSub->Init();

+		m_pSub->SetName(nullptr);

+

+		m_pSub->RecursiveCopyKeyValues(*src.m_pSub);

+	}

+

+	// Handle the immediate peer

+	if (src.m_pPeer)

+	{

+		m_pPeer = new KeyValues;

+

+		m_pPeer->Init();

+		m_pPeer->SetName(nullptr);

+

+		m_pPeer->RecursiveCopyKeyValues(*src.m_pPeer);

+	}

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: Make a new copy of all subkeys, add them all to the passed-in keyvalues

+// Input  : *pParent -

+//-----------------------------------------------------------------------------

+void KeyValues::CopySubkeys(KeyValues* pParent) const

+{

+	// recursively copy subkeys

+	// Also maintain ordering....

+	KeyValues* pPrev = nullptr;

+	for (KeyValues* pSub = m_pSub; pSub != nullptr; pSub = pSub->m_pPeer)

+	{

+		// take a copy of the subkey

+		KeyValues* pKey = pSub->MakeCopy();

+

+		// add into subkey list

+		if (pPrev)

+		{

+			pPrev->m_pPeer = pKey;

+		}

+		else

+		{

+			pParent->m_pSub = pKey;

+		}

+		pKey->m_pPeer = nullptr;

+		pPrev = pKey;

+	}

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: Makes a copy of the whole key-value pair set

+// Output : KeyValues*

+//-----------------------------------------------------------------------------

+KeyValues* KeyValues::MakeCopy(void) const

+{

+	KeyValues* pNewKeyValue = new KeyValues;

+

+	pNewKeyValue->Init();

+	pNewKeyValue->SetName(GetName());

+

+	// copy data

+	pNewKeyValue->m_iDataType = m_iDataType;

+	switch (m_iDataType)

+	{

+	case TYPE_STRING:

+	{

+		if (m_sValue)

+		{

+			size_t len = strlen(m_sValue);

+			assert(!pNewKeyValue->m_sValue);

+			pNewKeyValue->m_sValue = new char[len + 1];

+			memcpy(pNewKeyValue->m_sValue, m_sValue, len + 1);

+		}

+	}

+	break;

+	case TYPE_WSTRING:

+	{

+		if (m_wsValue)

+		{

+			size_t len = wcslen(m_wsValue);

+			pNewKeyValue->m_wsValue = new wchar_t[len + 1];

+			memcpy(pNewKeyValue->m_wsValue, m_wsValue, len + 1 * sizeof(wchar_t));

+		}

+	}

+	break;

+

+	case TYPE_INT:

+		pNewKeyValue->m_iValue = m_iValue;

+		break;

+

+	case TYPE_FLOAT:

+		pNewKeyValue->m_flValue = m_flValue;

+		break;

+

+	case TYPE_PTR:

+		pNewKeyValue->m_pValue = m_pValue;

+		break;

+

+	case TYPE_COLOR:

+		pNewKeyValue->m_Color[0] = m_Color[0];

+		pNewKeyValue->m_Color[1] = m_Color[1];

+		pNewKeyValue->m_Color[2] = m_Color[2];

+		pNewKeyValue->m_Color[3] = m_Color[3];

+		break;

+

+	case TYPE_UINT64:

+		pNewKeyValue->m_sValue = new char[sizeof(uint64_t)];

+		memcpy(pNewKeyValue->m_sValue, m_sValue, sizeof(uint64_t));

+		break;

+	};

+

+	// recursively copy subkeys

+	CopySubkeys(pNewKeyValue);

+	return pNewKeyValue;

+}

+

+ON_DLL_LOAD("vstdlib.dll", KeyValues, (CModule module))

+{

+	V_UTF8ToUnicode = module.GetExport("V_UTF8ToUnicode").As<int (*)(const char*, wchar_t*, int)>();

+	V_UnicodeToUTF8 = module.GetExport("V_UnicodeToUTF8").As<int (*)(const wchar_t*, char*, int)>();

+	KeyValuesSystem = module.GetExport("KeyValuesSystem").As<CKeyValuesSystem* (*)()>();

+}

+

+AUTOHOOK_INIT()

+

+// clang-format off

+AUTOHOOK(KeyValues__LoadFromBuffer, engine.dll + 0x426C30,

+char, __fastcall, (KeyValues* self, const char* pResourceName, const char* pBuffer, void* pFileSystem, void* a5, void* a6, int a7))

+// clang-format on

+{

+	static void* pSavedFilesystemPtr = nullptr;

+

+	// this is just to allow playlists to get a valid pFileSystem ptr for kv building, other functions that call this particular overload of

+	// LoadFromBuffer seem to get called on network stuff exclusively not exactly sure what the address wanted here is, so just taking it

+	// from a function call that always happens before playlists is loaded

+

+	// note: would be better if we could serialize this to disk for playlists, as this method breaks saving playlists in demos

+	if (pFileSystem != nullptr)

+		pSavedFilesystemPtr = pFileSystem;

+	if (!pFileSystem && !strcmp(pResourceName, "playlists"))

+		pFileSystem = pSavedFilesystemPtr;

+

+	return KeyValues__LoadFromBuffer(self, pResourceName, pBuffer, pFileSystem, a5, a6, a7);

+}

+

+ON_DLL_LOAD("engine.dll", EngineKeyValues, (CModule module))

+{

+	AUTOHOOK_DISPATCH()

+}