tweak(game/five): revive removed natives

Allowing reimplemented natives to be referenced via its crossmap.

Fixes #2328

code/components/rage-scripting-five/include/scrEngine.h

@@ -70,6 +70,9 @@ class
 	// queues the registration of a custom native function handler with an identifier
 	static void RegisterNativeHandler(uint64_t nativeIdentifier, NativeHandler handler);
 
+	// queues the registration of a custom native function handler that revives a removed identifier
+	static void ReviveNativeHandler(uint64_t nativeIdentifier, NativeHandler handler);
+
 public:
 	static fwEvent<> OnScriptInit;
 

code/components/rage-scripting-five/src/TableBuilder.cpp

@@ -13,8 +13,14 @@
 
 #include <CrossBuildRuntime.h>
 
+struct CrossMappingEntry
+{
+	uint64_t entries[28];
+};
+
 static std::unordered_map<uint64_t, uint64_t> g_mappingTable;
 static std::shared_ptr<DeferredInitializer> g_mappingInitializer;
+static std::unordered_map<uint64_t, const CrossMappingEntry*> g_unmappedTable;
 
 namespace rage
 {
@@ -32,17 +38,33 @@ namespace rage
 
 		return it->second;
 	}
+
+	void ReviveNative(uint64_t inNative)
+	{
+		g_mappingInitializer->Wait();
+
+		if (auto it = g_unmappedTable.find(inNative); it != g_unmappedTable.end())
+		{
+			for (uint64_t hash : it->second->entries)
+			{
+				if (hash != 0 && hash != inNative)
+				{
+					g_mappingTable.insert({ hash, inNative });
+				}
+			}
+		}
+	}
 }
 
 extern "C" DLL_EXPORT uint64_t MapNative(uint64_t inNative)
 {
 	return rage::MapNative(inNative);
 }
 
-struct CrossMappingEntry
+extern "C" DLL_EXPORT void ReviveNative(uint64_t inNative)
 {
-	uint64_t entries[28];
-};
+	rage::ReviveNative(inNative);
+}
 
 static void DoMapping()
 {
@@ -208,11 +230,21 @@ static void DoMapping()
 	{
 		for (auto& nativeEntry : crossMapping_universal)
 		{
+			bool hasNative = nativeEntry.entries[maxVersion] != 0;
 			for (int i = 0; i < maxVersion; i++)
 			{
-				if (nativeEntry.entries[i] != 0 && nativeEntry.entries[maxVersion] != 0)
+				if (uint64_t hash = nativeEntry.entries[i])
 				{
-					g_mappingTable.insert({ nativeEntry.entries[i], nativeEntry.entries[maxVersion] });
+					if (hasNative)
+					{
+						g_mappingTable.insert({ hash, nativeEntry.entries[maxVersion] });
+					}
+					else
+					{
+						// Native was removed this version: add it to a separate table
+						// so it can potentially be revived by custom implementations.
+						g_unmappedTable.insert({ hash, &nativeEntry });
+					}
 				}
 			}
 		}

code/components/rage-scripting-five/src/scrEngine.cpp

@@ -311,6 +311,7 @@ void scrEngine::CreateThread(GtaThread* thread)
 }
 
 uint64_t MapNative(uint64_t inNative);
+void ReviveNative(uint64_t inNative);
 
 template<typename TReg>
 bool RegisterNativeOverride(uint64_t hash, scrEngine::NativeHandler handler)
@@ -406,6 +407,18 @@ void scrEngine::RegisterNativeHandler(uint64_t nativeIdentifier, NativeHandler h
 	g_nativeHandlers.push_back(std::make_pair(nativeIdentifier, handler));
 }
 
+void scrEngine::ReviveNativeHandler(uint64_t nativeIdentifier, NativeHandler handler)
+{
+	RegisterNativeHandler(nativeIdentifier, handler);
+	if (MapNative(nativeIdentifier) == nativeIdentifier)
+	{
+		// If two builds share the same maxVersion index, e.g., 2545 and 2612,
+		// and a script command was removed, then the native may be found in the
+		// mapping table instead of the unmapped table.
+		ReviveNative(nativeIdentifier);
+	}
+}
+
 static InitFunction initFunction([] ()
 {
 	scrEngine::OnScriptInit.Connect([] ()
@@ -548,19 +561,22 @@ static InitFunction initFunction([]
 	if (xbr::IsGameBuildOrGreater<2612>())
 	{
 		// IS_BIT_SET is missing in b2612+, re-adding for compatibility
-		rage::scrEngine::RegisterNativeHandler(0xE2D0C323A1AE5D85 /* 2545 hash */, [](rage::scrNativeCallContext* ctx)
+		rage::scrEngine::OnScriptInit.Connect([]()
 		{
-			bool result = false;
+			rage::scrEngine::ReviveNativeHandler(0xE2D0C323A1AE5D85 /* 2545 hash */, [](rage::scrNativeCallContext* ctx)
+			{
+				bool result = false;
 
-			auto value = ctx->GetArgument<uint32_t>(0);
-			auto offset = ctx->GetArgument<int>(1);
+				auto value = ctx->GetArgument<uint32_t>(0);
+				auto offset = ctx->GetArgument<int>(1);
 
-			if (offset < 32)
-			{
-				result = (value & (1 << offset)) != 0;
-			}
+				if (offset < 32)
+				{
+					result = (value & (1 << offset)) != 0;
+				}
 
-			ctx->SetResult<int>(0, result);
+				ctx->SetResult<int>(0, result);
+			});
 		});
 	}
 });