Rejection code mith077, rework patch, read data handle manager from game, terminate game if out of entries

Author: Perchik71

.Build/F4SE/Plugins/Addictol.toml

@@ -159,7 +159,8 @@ bImageSpaceAdapter = true
 # Warns if you have two AddonNode forms with the same index in your load order, which will cause errors with visual effects.
 bDuplicateAddonNodeIndex = true
 
-# Warns if you are approaching the reference handle limoit or exceed the reference handle limit, which can cause CTDs.
+# Warns if you are approaching the reference handle limit or exceed the reference handle limit.
+# Terminate process if out of entries!
 bReferenceHandleLimit = true
 
 

Addictol/Include/AdGameUtils.h

@@ -3,13 +3,14 @@
 #include <string_view>
 #include <string>
 
+#include <F4SE/F4SE.h>
+
 namespace RE
 {
 	class TESForm;
 	class TESObjectREFR;
 }
 
-
 namespace Addictol
 {
 	using namespace std::literals;
@@ -19,4 +20,6 @@ namespace Addictol
 	// easy + formatted way to log form details like formid, editorid (if loaded), and plugin:
 	//	{FormID: 0x123456, EditorID: "ExampleForm", Plugin: "Example.esp"}
 	std::string GetFormInfo(RE::TESForm* a_form);
+
+	std::string GetMessagingInterfaceString(F4SE::MessagingInterface::Message* a_msg) noexcept;
 }

Addictol/Source/AdGameUtils.cpp

@@ -9,7 +9,6 @@
 // Causes crashes if put above RE/S/Script.h
 #include <RE/C/ConsoleLog.h>
 
-
 namespace Addictol
 {
 	bool ExecuteCommand(std::string_view a_command, RE::TESObjectREFR *a_targetRef, bool a_silent)
@@ -59,4 +58,14 @@ namespace Addictol
 						   (editorID != ""sv) ? editorID : "EDITORID_NOT_LOADED"sv,
 						   file ? file->GetFilename() : "PLUGIN_NOT_FOUND"sv);
 	}
+
+	extern std::array<std::string_view, 11> g_msgName;
+
+	std::string GetMessagingInterfaceString(F4SE::MessagingInterface::Message* a_msg) noexcept
+	{
+		if (!a_msg)
+			return "ERROR_NULL_MESSAGE";
+
+		return g_msgName.size() > a_msg->type ? g_msgName[a_msg->type].data() : "ERROR_NO_TYPE";
+	}
 }

Addictol/Source/AdRegisterModules.cpp

@@ -180,7 +180,6 @@ void AdRegisterModules()
 	modules.Register(sModuleActorCauseSaveBloat);
 	//modules.Register(sModuleAnimSignedCrash);
 	//modules.Register(sModuleBethesdaNetCrash);
-	//modules.Register(sModuleReferenceHandleLimitWarning);
 
 	// Registers other patches
 	modules.Register(sModuleThreads,						kGameDataReady);
@@ -204,5 +203,5 @@ void AdRegisterModules()
 
 	// Profiler - registered at load stage, listener at GameDataReady for report generation
 	modules.Register(sModuleProfiler);
-	modules.Register(sModuleProfiler,					kGameDataReady);
+	modules.Register(sModuleProfiler,						kGameDataReady);
 }

Addictol/Source/Modules/AdModuleReferenceHandleLimitWarning.cpp

@@ -3,105 +3,79 @@
 #include <AdGameUtils.h>
 
 #include <RE/C/ConsoleLog.h>
-
-// the ratio at which we start warning in console log.
-// this can be set to anything, i just set it to 80% for right now
-#define WARNING_MIN_RATIO 0.80f
+#include <RE/B/BSSpinLock.h>
+#include <RE/B/BSPointerHandle.h>
 
 namespace Addictol
 {
-	// credit: Warnings::ReferenceHandleCap in Daytripper 4 by mith077 under MIT
-	// https://www.nexusmods.com/fallout4/mods/91141?tab=files
-
-	// data
-	static inline constexpr uint32_t MAX_HANDLE_LIMIT = 1 << 21;	// 21 bits for handle, 5 for age, 1 for active = 26 bit test
-	static const std::string WarningMessage_ReferenceHandleLimitExceeded = "Addictol::ReferenceHandleLimitWarning: "
-		"Reference Handle Limit Exceeded! This can cause CTDs. Consider trimming your load order for your next save.";
-	static const std::string WarningMessage_ReferenceHandleLimitAlmostExceeded = "Addictol::ReferenceHandleLimitWarning: "
-		"TODO";
+	// the ratio at which we start warning in console log.
+	// this can be set to anything, i just set it to 90% for right now
+	constexpr auto WARNING_MIN_RATIO = 0.90f;
 
+	// 21 bits for handle, 5 for age, 1 for active = 26 bit test
+	static constexpr uint32_t MAX_HANDLE_LIMIT = 1 << 21;	
 	// cached values
 	static uint32_t lastCount = 0;
-	static float lastRatio = 0.0f;
-
-	// tested on AE, but should be fine on OG/NG since daytripper's addresses work on OG/NG
-	static const auto ReferenceHandleArray_addresses = REL::VariantID(1103816, 2688744).address();
-	static const auto ReferenceHandleArray = reinterpret_cast<uint64_t*>(ReferenceHandleArray_addresses);
+	static double lastRatio = 0.0f;
 
 	static REX::TOML::Bool<> bWarningsReferenceHandleLimit{ "Warnings"sv, "bReferenceHandleLimit"sv, true };
 
+	struct HandleManager :
+		public RE::BSPointerHandleManagerInterface<RE::TESObjectREFR>
+	{
+		struct Entries
+		{
+			RE::BSPointerHandle<RE::TESObjectREFR>	handle;
+			void*									addressPointerInREFR;
+		};
+
+		uint32_t freeListHead;
+		uint32_t freeListTail;
+		RE::BSReadWriteLock handleManagerLock;
+		Entries* handleEntries;
+		const RE::BSPointerHandle<RE::TESObjectREFR> nullHandle{};
+	};
+
 	ModuleReferenceHandleLimitWarning::ModuleReferenceHandleLimitWarning() :
 		Module("Reference Handle Limit Warning", &bWarningsReferenceHandleLimit)
 	{}
 
-	// note: could be useful to have in AdGameUtils but compiler was being annoying
-	std::string GetMessagingInterfaceString(F4SE::MessagingInterface::Message* a_msg)
+	static uint32_t GetReferenceHandleCount() noexcept
 	{
-		if (!a_msg)
-			return "ERROR_NULL_MESSAGE";
-		
-		switch (a_msg->type) {
-			case F4SE::MessagingInterface::kPostLoad:
-				return "kPostLoad";
-			case F4SE::MessagingInterface::kPostPostLoad:
-				return "kPostPostLoad";
-			case F4SE::MessagingInterface::kPreLoadGame:
-				return "kPreLoadGame";
-			case F4SE::MessagingInterface::kPostLoadGame:
-				return "kPostLoadGame";
-			case F4SE::MessagingInterface::kPreSaveGame:
-				return "kPreSaveGame";
-			case F4SE::MessagingInterface::kPostSaveGame:
-				return "kPostSaveGame";
-			case F4SE::MessagingInterface::kDeleteGame:
-				return "kDeleteGame";
-			case F4SE::MessagingInterface::kInputLoaded:
-				return "kInputLoaded";
-			case F4SE::MessagingInterface::kNewGame:
-				return "kNewGame";
-			case F4SE::MessagingInterface::kGameLoaded:
-				return "kGameLoaded";
-			case F4SE::MessagingInterface::kGameDataReady:
-				return "kGameDataReady";
-			default:
-				return "ERROR_NO_TYPE";
-		}
-
-		return "ERROR_IDEK_HONESTLY";
+		auto manager = reinterpret_cast<HandleManager*>(REL::VariantID(665313, 2688741, 4796005).address());
+		if (!manager || (manager->freeListHead == manager->freeListTail == MAX_HANDLE_LIMIT - 1)) return 0;
+		return manager ? manager->freeListHead : 0;
 	}
 
-	uint32_t GetReferenceHandleCount() noexcept
-	{
-		uint32_t count = 0;
-		for (uint32_t i = 0; i < MAX_HANDLE_LIMIT; i++) {
-			if ((ReferenceHandleArray[i] >> 26) & 1) {
-				count++;
-			}
-		}
-
-		return count;
-	}
-
-	void CheckReferenceHandleLimit(std::string_view eventName, bool cacheResults = true) noexcept
+	static void CheckReferenceHandleLimit(std::string_view eventName, bool cacheResults = true) noexcept
 	{
 		uint32_t count = GetReferenceHandleCount();
-		float ratio = static_cast<float>(count) / static_cast<float>(MAX_HANDLE_LIMIT);
+		double ratio = static_cast<double>(count) / static_cast<float>(MAX_HANDLE_LIMIT);
 
-		if (cacheResults) {
+		if (cacheResults)
+		{
 			// we can cache it so we dont have to iterate again unless we need to measure it again
 			lastCount = count;
 			lastRatio = ratio;
 		}
 
-		REX::INFO("Reference Handle Count ({}): {}. Ratio: {:.4}%"sv, eventName, count, ratio);
+		REX::INFO("Reference Handle Count ({}): {}. Ratio: {:.1f}%"sv, eventName, count, ratio * 100.f);
 
 		// warn if needed
-		if (ratio >= WARNING_MIN_RATIO) {
-			REX::WARN(std::string_view(WarningMessage_ReferenceHandleLimitExceeded));
+		if (ratio >= WARNING_MIN_RATIO)
+		{
+			if (ratio >= 0.999f)
+			{
+				REX::CRITICAL("OUT OF HANDLE ARRAY ENTRIES!TERMINATE GAME FORCIBLY!"sv);
+				REX::W32::TerminateProcess(REX::W32::GetCurrentProcess(), ERANGE);
+			}
+			else
+			{
+				REX::WARN("HANDLE ARRAY ENTRIES ALMOST EXCEEDED"sv);
 
-			auto* consoleLog = RE::ConsoleLog::GetSingleton();
-			if (consoleLog) {
-				consoleLog->AddString(WarningMessage_ReferenceHandleLimitExceeded.c_str());
+				auto* consoleLog = RE::ConsoleLog::GetSingleton();
+				if (consoleLog)
+					consoleLog->AddString("Addictol::ReferenceHandleLimitWarning: HANDLE ARRAY ENTRIES ALMOST EXCEEDED");
 			}
 		}
 	}
@@ -118,6 +92,8 @@ namespace Addictol
 
 		std::string eventName = GetMessagingInterfaceString(a_msg);
 		CheckReferenceHandleLimit(eventName);
+
+		// FIXME: Add check to CreateHandle function
 
 		return true;
 	}

VC/Addictol.vcxproj.filters

@@ -217,6 +217,9 @@
     <ClCompile Include="..\Addictol\Source\Modules\AdModuleUtilityShader.cpp">
       <Filter>Source\Modules</Filter>
     </ClCompile>
+    <ClCompile Include="..\Addictol\Source\Modules\AdModuleReferenceHandleLimitWarning.cpp">
+      <Filter>Source\Modules</Filter>
+    </ClCompile>
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="..\Version\resource_version2.h" />
@@ -427,6 +430,9 @@
     <ClInclude Include="..\Addictol\Include\Modules\AdModuleUtilityShader.h">
       <Filter>Include\Modules</Filter>
     </ClInclude>
+    <ClInclude Include="..\Addictol\Include\Modules\AdModuleReferenceHandleLimitWarning.h">
+      <Filter>Include\Modules</Filter>
+    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <ResourceCompile Include="..\Version\resource_version.rc" />

Version/build_version.txt

@@ -10,7 +10,7 @@
 #define STRINGIZE(s) STRINGIZE2(s)
 
 #define VERSION_MAJOR             1
-#define VERSION_MINOR             3
+#define VERSION_MINOR             4
 #define VERSION_REVISION          0
 #define VERSION_BUILD             <BUILD>