v1.2.0: keep CONTINUE correct when the menu is shown again

Visiting another menu screen and coming back left the CONTINUE entry
labelled "TEXT BLOCK" and unresponsive, with its separator missing.

UCrUW_MainMenuWidget::NativeConstruct is the label pass and it runs on every
menu show: it re-reads ButtonsTexts, calls UTabButton::SetButtonText per
entry, and clears the click gate while walking. Our entry has no ButtonsTexts
key -- the plugin API cannot insert into a TMap -- so a re-shown menu got the
placeholder label and a closed gate. MenuInstance::PatchNow now runs from the
construct hook after the original returns, so the label and gate are correct
in the frame the menu is built rather than corrected afterwards.

The separator had an unrelated cause: Separator::IsInstanceOfClass enumerated
live VerticalBox instances into a fixed 256-entry buffer, and a second menu
instance pushed the live count to 333. The button's root box fell past the
cut, so the check reported "not a live VerticalBox" and stood down. It now
grows past the reported total and rescans; a truncated view can no longer be
read as absence.

Also widens the settled-instance guard to compare ButtonsBox child 0, not
just the menu instance, so a genuinely new button is re-patched.

Verified in game: LOAD GAME -> ESC returns to a menu with CONTINUE labelled,
separated and focused; three constructs, each patched, separator built every
time, no truncation warnings.

Author: agentical-info

CHANGELOG.md

@@ -1,5 +1,25 @@
 # Changelog
 
+## v1.2.0 — 2026-08-07
+
+**Fixes CONTINUE breaking after you visit another menu screen.**
+
+Open `LOAD GAME` (or any other screen) and come back, and the CONTINUE entry lost its label — it read
+`TEXT BLOCK` — and stopped responding to clicks. The separator above `NEW GAME` disappeared with it. Starting the
+game again was the only way to get it back.
+
+The game rebuilds the main menu every time it is shown, relabelling each entry from its own list of button names.
+CONTINUE is not in that list, so it came back blank, and the same pass switched its click handling back off. The
+mod now re-applies the label and the click handling in the same frame the menu is rebuilt, so the entry is correct
+the first time it is drawn rather than being corrected afterwards.
+
+The separator had a second, unrelated cause: an internal check gave up once enough menu screens had been built,
+and silently concluded it had nowhere to draw. It no longer gives up.
+
+If you use auto-update, this arrives on its own. Built for game build `0.2.8.121391-S`. Requires ModLoader v1.17.3
+(plugin interface 60).
+
+
 ## v1.1.0 — 2026-08-06
 
 **The mod now updates itself.** No change to what it does in game.

install/ModLoader-Plugins/AgenticalMods-Continue.dll

@@ -73,7 +73,7 @@
     <ClCompile>
       <WarningLevel>Level3</WarningLevel>
       <SDLCheck>true</SDLCheck>
-      <PreprocessorDefinitions>_DEBUG;MODLOADER_CLIENT_BUILD;CONTINUE_EXPORTS;MODLOADER_BUILD_TAG="1.1.0";_WINDOWS;_USRDLL;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <PreprocessorDefinitions>_DEBUG;MODLOADER_CLIENT_BUILD;CONTINUE_EXPORTS;MODLOADER_BUILD_TAG="1.2.0";_WINDOWS;_USRDLL;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <ConformanceMode>true</ConformanceMode>
       <LanguageStandard>stdcpp20</LanguageStandard>
       <PrecompiledHeader>NotUsing</PrecompiledHeader>
@@ -93,7 +93,7 @@
       <FunctionLevelLinking>true</FunctionLevelLinking>
       <IntrinsicFunctions>true</IntrinsicFunctions>
       <SDLCheck>true</SDLCheck>
-      <PreprocessorDefinitions>NDEBUG;MODLOADER_CLIENT_BUILD;CONTINUE_EXPORTS;MODLOADER_BUILD_TAG="1.1.0";_WINDOWS;_USRDLL;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <PreprocessorDefinitions>NDEBUG;MODLOADER_CLIENT_BUILD;CONTINUE_EXPORTS;MODLOADER_BUILD_TAG="1.2.0";_WINDOWS;_USRDLL;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <ConformanceMode>true</ConformanceMode>
       <LanguageStandard>stdcpp20</LanguageStandard>
       <PrecompiledHeader>NotUsing</PrecompiledHeader>

src/AgenticalMods-Continue.vcxproj

@@ -1,4 +1,5 @@
 #include "construct_hook.h"
+#include "menu_instance.h"
 #include "plugin_config.h"
 #include "plugin_helpers.h"
 #include "save_discovery.h"
@@ -157,6 +158,23 @@ namespace ConstructHook
 
 			if (g_original)
 				g_original(widget);
+
+			// NativeConstruct IS the label pass: it reads ButtonsTexts and calls
+			// UTabButton::SetButtonText on every entry, and clears the click gate
+			// while walking. It runs again every time the menu is shown, and our
+			// entry has no ButtonsTexts key, so a menu returned to from a submenu
+			// is re-labelled with the placeholder and re-gated shut. Patching in
+			// this frame, after the game has finished, is what keeps the wrong
+			// label from ever reaching the screen.
+			__try
+			{
+				if (g_armed)
+					MenuInstance::PatchNow(widget);
+			}
+			__except (EXCEPTION_EXECUTE_HANDLER)
+			{
+				LOG_ERROR("ConstructHook: post-construct patch raised; the entry may be unlabelled.");
+			}
 		}
 	}
 

src/construct_hook.cpp

@@ -39,6 +39,7 @@ namespace MenuInstance
 
 		void*  g_patchedInstance = nullptr;   // identity only -- never dereferenced after the frame it was validated in
 		void*  g_continueButton  = nullptr;
+		void*  g_decidedChild0   = nullptr;   // child 0 as it stood when this instance was last decided
 		float  g_pollTimer       = 0.0f;
 		bool   g_loggedNoSubst   = false;
 		bool   g_worldIsMenu     = true;   // unknown until the first world event -- poll
@@ -63,6 +64,30 @@ namespace MenuInstance
 			return nullptr;
 		}
 
+		// ButtonsBox child 0 right now, or null. The label lives on the BUTTON, not
+		// on the menu widget: leaving LOAD GAME rebuilds ButtonsBox under a live
+		// instance, so the instance pointer alone cannot tell a fresh button apart.
+		void* CurrentChild0(void* instance)
+		{
+			IPluginObjectProperties* props = Props();
+			if (!props || !instance)
+				return nullptr;
+
+			PluginPropertyHandle pButtonsBox = props->FindPropertyOnObject(instance, "ButtonsBox");
+			if (!pButtonsBox)
+				return nullptr;
+
+			void* buttonsBox = nullptr;
+			if (!props->GetObjectProperty(instance, pButtonsBox, &buttonsBox) || !buttonsBox)
+				return nullptr;
+
+			P_GetChildAt child{};
+			child.Index = 0;
+			if (!Walker()->InvokeUFunctionByName(buttonsBox, kPanelClass, "GetChildAt", &child))
+				return nullptr;
+			return child.ReturnValue;
+		}
+
 		// Builds the label through the engine rather than fabricating an FText.
 		// The FString points at a static literal: input params are read-only and
 		// ZeroConstructor, which is the standard Dumper-7 SDK pattern.
@@ -228,6 +253,23 @@ namespace MenuInstance
 		}
 	}
 
+	void PatchNow(void* widget)
+	{
+		if (!widget)
+			return;
+
+		IPluginObjectWalker* walker = Walker();
+		IPluginObjectProperties* props = Props();
+		if (!walker || !props || !walker->IsReady() || !props->IsReady())
+			return;
+
+		if (TryPatchInstance(widget))
+		{
+			g_patchedInstance = widget;
+			g_decidedChild0 = CurrentChild0(widget);
+		}
+	}
+
 	void* GetContinueButton() { return g_continueButton; }
 	void* GetMenuInstance()   { return g_patchedInstance; }
 
@@ -240,6 +282,7 @@ namespace MenuInstance
 			// new. Pointers are identity-only and never dereferenced here.
 			g_patchedInstance = nullptr;
 			g_continueButton = nullptr;
+			g_decidedChild0 = nullptr;
 		}
 		SaveDiscovery::InvalidateCache(); // the save set can change while playing
 	}
@@ -270,15 +313,23 @@ namespace MenuInstance
 			// again. Pointers are identity-only and never dereferenced here.
 			g_patchedInstance = nullptr;
 			g_continueButton = nullptr;
+			g_decidedChild0 = nullptr;
 			return;
 		}
 
-		if (instance == g_patchedInstance)
+		// Re-decide when child 0 is not the button this instance was decided on.
+		// Comparing instances alone misses the rebuild that leaving LOAD GAME does:
+		// same widget, fresh button, label gone (it shows UMG's "Text Block").
+		// Recording the child for refusals too keeps a terminal refusal from
+		// re-warning every poll.
+		void* child0 = CurrentChild0(instance);
+		if (instance == g_patchedInstance && child0 == g_decidedChild0)
 			return;
 
 		if (TryPatchInstance(instance))
 		{
 			g_patchedInstance = instance;
+			g_decidedChild0 = child0;
 			seenAMenu = true; // race is over for this menu; stop per-frame walking
 		}
 	}

src/menu_instance.cpp

@@ -16,6 +16,18 @@ namespace MenuInstance
 	// Re-arms per instance; returning to the main menu builds a new widget.
 	void Tick(float deltaSeconds);
 
+	// Applies the patch immediately, for the construct hook to call once the
+	// game's own NativeConstruct has returned.
+	//
+	// NativeConstruct IS the label pass: it reads ButtonsTexts and calls
+	// UTabButton::SetButtonText on every entry, and it clears the click gate while
+	// walking. It re-runs each time the menu is shown again, so a menu returned to
+	// from a submenu is re-labelled from a TMap that has no key for our entry --
+	// the button reverts to the placeholder and the gate goes back to zero.
+	// Patching in the same frame is what keeps the wrong label from ever drawing;
+	// the poll would correct it a quarter-second late, on screen.
+	void PatchNow(void* widget);
+
 	// Scopes the poll to menu worlds. FindObjectsByClassNameInto walks all of
 	// GObjects and builds a std::string per candidate; the SDK header forbids
 	// calling it per tick. Called for every world, so an unrecognised name

src/menu_instance.h

@@ -4,6 +4,7 @@
 
 #include <cstdint>
 #include <cstddef>
+#include <cstdlib>
 #include <cstring>
 
 // Mechanism:
@@ -28,7 +29,7 @@ namespace Separator
 
 		constexpr float kPollIntervalSeconds = 0.25f;
 		constexpr int   kMaxColorRetries     = 40;   // ~10s -- SetColors runs shortly post-construct
-		constexpr int   kClassCheckCapacity  = 256;  // live VerticalBox count at the main menu; generous margin
+		constexpr int   kClassCheckCapacity  = 512;  // starting size only -- IsInstanceOfClass grows and rescans
 
 		// Measured from the vanilla separator, not derived at runtime. Spacing, not
 		// colour: colour must be read live (SetColors runs post-construct).
@@ -70,17 +71,57 @@ namespace Separator
 		// enumerate live instances of className and look for a match. Required
 		// before any VerticalBox-declared call touches the button's root widget.
 		// Called once per settled attempt, not per poll.
+		//
+		// The scan must be COMPLETE. A fixed cap that truncates reports "not of this
+		// class" for an object that is simply past the cut, which stands the
+		// separator down on a menu that is otherwise fine -- measured after a
+		// LOAD GAME round trip, where a second menu instance pushed live
+		// VerticalBoxes to 333 against a 256 cap. The count is a function of how
+		// many menus have been built, so no constant is safe; grow and rescan.
 		bool IsInstanceOfClass(void* obj, const char* className)
 		{
 			if (!obj) return false;
-			static PluginObjectInfo buf[kClassCheckCapacity];
-			int total = Walker()->FindObjectsByClassNameInto(className, PluginObjectLookup_InstanceOnly, buf, kClassCheckCapacity);
-			if (total > kClassCheckCapacity)
-				LOG_WARN("Separator: class-check for \"%s\" truncated (%d live, checked %d).",
-					className, total, kClassCheckCapacity);
-			const int checked = total < kClassCheckCapacity ? total : kClassCheckCapacity;
-			for (int i = 0; i < checked; ++i)
-				if (buf[i].object == obj) return true;
+
+			static PluginObjectInfo* buf = nullptr;
+			static int capacity = 0;
+
+			for (int attempt = 0; attempt < 2; ++attempt)
+			{
+				if (capacity < kClassCheckCapacity)
+				{
+					PluginObjectInfo* grown = static_cast<PluginObjectInfo*>(
+						realloc(buf, sizeof(PluginObjectInfo) * kClassCheckCapacity));
+					if (!grown)
+					{
+						LOG_WARN("Separator: class-check buffer allocation failed; standing down.");
+						return false;
+					}
+					buf = grown;
+					capacity = kClassCheckCapacity;
+				}
+
+				const int total = Walker()->FindObjectsByClassNameInto(
+					className, PluginObjectLookup_InstanceOnly, buf, capacity);
+				const int checked = total < capacity ? total : capacity;
+				for (int i = 0; i < checked; ++i)
+					if (buf[i].object == obj)
+						return true;
+
+				if (total <= capacity)
+					return false; // the scan was complete: genuinely not this class
+
+				// Truncated -- grow past the reported total and rescan once.
+				PluginObjectInfo* grown = static_cast<PluginObjectInfo*>(
+					realloc(buf, sizeof(PluginObjectInfo) * (total + 64)));
+				if (!grown)
+				{
+					LOG_WARN("Separator: class-check needs %d entries and the buffer could not grow; "
+						"standing down rather than guessing.", total);
+					return false;
+				}
+				buf = grown;
+				capacity = total + 64;
+			}
 			return false;
 		}