Update schema system

Author: Vauff

src/cs2_sdk/entity/cbaseplayerpawn.h

@@ -1,7 +1,7 @@
 /**
  * =============================================================================
- * CS2Fixes
- * Copyright (C) 2023 Source2ZE
+ * CS2ServerGUI
+ * Copyright (C) 2023-2025 Source2ZE
  * =============================================================================
  *
  * This program is free software; you can redistribute it and/or modify it under
@@ -19,116 +19,134 @@
 
 #include "schema.h"
 
-#include "schemasystem/schemasystem.h"
-#include "tier1/utlmap.h"
-#include "tier0/memdbgon.h"
 #include "entity/cbaseentity.h"
-#include "interfaces.h"
-#include "../utils/plat.h"
+#include "utils/plat.h"
+#include "schemasystem/schemasystem.h"
 
-extern CGlobalVars *gpGlobals;
+#include "tier0/memdbgon.h"
 
-using SchemaKeyValueMap_t = CUtlMap<uint32_t, SchemaKey>;
-using SchemaTableMap_t = CUtlMap<uint32_t, SchemaKeyValueMap_t*>;
+using SchemaKeyValueMap_t = std::map<uint32_t, SchemaKey>;
+using SchemaTableMap_t = std::map<uint32_t, SchemaKeyValueMap_t>;
 
+static constexpr uint32_t g_ChainKey = hash_32_fnv1a_const("__m_pChainEntity");
 
 static bool IsFieldNetworked(SchemaClassFieldData_t& field)
 {
-    for (int i = 0; i < field.m_nStaticMetadataCount; i++)
-    {
-        static auto networkEnabled = hash_32_fnv1a_const("MNetworkEnable");
-        if (networkEnabled == hash_32_fnv1a_const(field.m_pStaticMetadata[i].m_pszName))
-            return true;
-    }
+	for (int i = 0; i < field.m_nStaticMetadataCount; i++)
+	{
+		static auto networkEnabled = hash_32_fnv1a_const("MNetworkEnable");
+		if (networkEnabled == hash_32_fnv1a_const(field.m_pStaticMetadata[i].m_pszName))
+			return true;
+	}
+
+	return false;
+}
 
-    return false;
-}   
+// Try to recursively find __m_pChainEntity in base classes 
+// (e.g. CCSGameRules -> CTeamplayRules -> CMultiplayRules -> CGameRules, in this case it's in CGameRules)
+static void InitChainOffset(SchemaClassInfoData_t *pClassInfo, SchemaKeyValueMap_t &keyValueMap)
+{
+	short fieldsSize = pClassInfo->m_nFieldCount;
+	SchemaClassFieldData_t* pFields = pClassInfo->m_pFields;
+
+	for (int i = 0; i < fieldsSize; ++i)
+	{
+		SchemaClassFieldData_t& field = pFields[i];
+		
+		if (hash_32_fnv1a_const(field.m_pszName) != g_ChainKey)
+			continue;
+
+		std::pair<uint32_t, SchemaKey> keyValuePair;
+		keyValuePair.first = g_ChainKey;
+		keyValuePair.second.offset = field.m_nSingleInheritanceOffset;
+		keyValuePair.second.networked = IsFieldNetworked(field);
+
+		keyValueMap.insert(keyValuePair);
+		return;
+	}
+
+	// Not the base class yet, keep looking
+	if (pClassInfo->m_nBaseClassCount)
+		return InitChainOffset(pClassInfo->m_pBaseClasses[0].m_pClass, keyValueMap);
+}
 
-static bool InitSchemaFieldsForClass(SchemaTableMap_t *tableMap, const char* className, uint32_t classKey)
+static void InitSchemaKeyValueMap(SchemaClassInfoData_t *pClassInfo, SchemaKeyValueMap_t& keyValueMap)
 {
-    CSchemaSystemTypeScope* pType = Interfaces::g_pSchemaSystem2->FindTypeScopeForModule(MODULE_PREFIX "server" MODULE_EXT);
+	short fieldsSize = pClassInfo->m_nFieldCount;
+	SchemaClassFieldData_t* pFields = pClassInfo->m_pFields;
 
-    if (!pType)
-        return false;
+	for (int i = 0; i < fieldsSize; ++i)
+	{
+		SchemaClassFieldData_t& field = pFields[i];
 
-    SchemaClassInfoData_t* pClassInfo = pType->FindDeclaredClass(className).Get();
+#ifdef _DEBUG
+		Message("%s::%s found at -> 0x%X - %llx\n", pClassInfo->m_pszName, field.m_pszName, field.m_nSingleInheritanceOffset, &field);
+#endif
 
-    if (!pClassInfo)
-    {
-        SchemaKeyValueMap_t *map = new SchemaKeyValueMap_t(0, 0, DefLessFunc(uint32_t));
-        tableMap->Insert(classKey, map);
+		std::pair<uint32_t, SchemaKey> keyValuePair;
+		keyValuePair.first = hash_32_fnv1a_const(field.m_pszName);
+		keyValuePair.second.offset = field.m_nSingleInheritanceOffset;
+		keyValuePair.second.networked = IsFieldNetworked(field);
 
-        Warning("InitSchemaFieldsForClass(): '%s' was not found!\n", className);
-        return false;
-    }
+		keyValueMap.insert(keyValuePair);
+	}
 
-    short fieldsSize = pClassInfo->m_nFieldCount;
-    SchemaClassFieldData_t* pFields = pClassInfo->m_pFields;
+	// If this is a child class there might be a parent class with __m_pChainEntity
+	if (!keyValueMap.contains(g_ChainKey) && pClassInfo->m_nBaseClassCount)
+		InitChainOffset(pClassInfo->m_pBaseClasses[0].m_pClass, keyValueMap);
+}
 
-    SchemaKeyValueMap_t *keyValueMap = new SchemaKeyValueMap_t(0, 0, DefLessFunc(uint32_t));
-    keyValueMap->EnsureCapacity(fieldsSize);
-    tableMap->Insert(classKey, keyValueMap);
+static bool InitSchemaFieldsForClass(SchemaTableMap_t& tableMap, const char* className, uint32_t classKey)
+{
+	CSchemaSystemTypeScope* pType = g_pSchemaSystem->FindTypeScopeForModule(MODULE_PREFIX "server" MODULE_EXT);
 
-    for (int i = 0; i < fieldsSize; ++i)
-    {
-        SchemaClassFieldData_t& field = pFields[i];
+	if (!pType)
+		return false;
 
-#ifdef _DEBUG
-		Message("%s::%s found at -> 0x%X - %llx\n", className, field.m_pszName, field.m_nSingleInheritanceOffset, &field);
-#endif
+	SchemaClassInfoData_t* pClassInfo = pType->FindDeclaredClass(className).Get();
+
+	if (!pClassInfo)
+	{
+		SchemaKeyValueMap_t map;
+		tableMap.insert(std::make_pair(classKey, map));
+
+		Warning("InitSchemaFieldsForClass(): '%s' was not found!\n", className);
+		return false;
+	}
 
-        keyValueMap->Insert(hash_32_fnv1a_const(field.m_pszName), {field.m_nSingleInheritanceOffset, IsFieldNetworked(field)});
-    }
+	SchemaKeyValueMap_t& keyValueMap = tableMap.insert(std::make_pair(classKey, SchemaKeyValueMap_t())).first->second;
 
-    return true;
+	InitSchemaKeyValueMap(pClassInfo, keyValueMap);
+
+	return true;
 }
 
-int16_t schema::FindChainOffset(const char* className)
+int16_t schema::FindChainOffset(const char* className, uint32_t classNameHash)
 {
-    CSchemaSystemTypeScope* pType = Interfaces::g_pSchemaSystem2->FindTypeScopeForModule(MODULE_PREFIX "server" MODULE_EXT);
+	return schema::GetOffset(className, classNameHash, "__m_pChainEntity", g_ChainKey).offset;
+}
 
-    if (!pType)
-        return false;
+SchemaKey schema::GetOffset(const char* className, uint32_t classKey, const char* memberName, uint32_t memberKey)
+{
+	static SchemaTableMap_t schemaTableMap;
 
-    SchemaClassInfoData_t* pClassInfo = pType->FindDeclaredClass(className).Get();
+	if (!schemaTableMap.contains(classKey))
+	{
+		if (InitSchemaFieldsForClass(schemaTableMap, className, classKey))
+			return GetOffset(className, classKey, memberName, memberKey);
 
-    do
-    {
-        SchemaClassFieldData_t* pFields = pClassInfo->m_pFields;
-        short fieldsSize = pClassInfo->m_nFieldCount;
-        for (int i = 0; i < fieldsSize; ++i)
-        {
-            SchemaClassFieldData_t& field = pFields[i];
+		return {0, 0};
+	}
 
-            if (V_strcmp(field.m_pszName, "__m_pChainEntity") == 0)
-            {
-                return field.m_nSingleInheritanceOffset;
-            }
-        }
-    } while ((pClassInfo = pClassInfo->m_pBaseClasses->m_pClass) != nullptr);
+	SchemaKeyValueMap_t tableMap = schemaTableMap[classKey];
 
-    return 0;
-}
+	if (!tableMap.contains(memberKey))
+	{
+		if (memberKey != g_ChainKey)
+			Warning("schema::GetOffset(): '%s' was not found in '%s'!\n", memberName, className);
 
-SchemaKey schema::GetOffset(const char* className, uint32_t classKey, const char* memberName, uint32_t memberKey)
-{
-	static SchemaTableMap_t schemaTableMap(0, 0, DefLessFunc(uint32_t));
-	int16_t tableMapIndex = schemaTableMap.Find(classKey);
-    if (!schemaTableMap.IsValidIndex(tableMapIndex))
-    {
-        if (InitSchemaFieldsForClass(&schemaTableMap, className, classKey))
-            return GetOffset(className, classKey, memberName, memberKey);
-
-        return { 0, 0 };
-    }
-
-    SchemaKeyValueMap_t *tableMap = schemaTableMap[tableMapIndex];
-	int16_t memberIndex = tableMap->Find(memberKey);
-    if (!tableMap->IsValidIndex(memberIndex))
-    {
-        Warning("schema::GetOffset(): '%s' was not found in '%s'!\n", memberName, className);
-        return { 0, 0 };
-    }
-
-    return tableMap->Element(memberIndex);
+		return {0, 0};
+	}
+
+	return tableMap[memberKey];
 }