feat/dual menu backend

.github/workflows/msbuild.yml

@@ -2,16 +2,6 @@ name: MSBuild
 
 on:
   workflow_dispatch:
-  push:
-    branches: [ "master" ]
-    paths:
-      - 'Internal/**'
-      - 'Launcher/**'
-  pull_request:
-    branches: [ "master" ]
-    paths:
-      - 'Internal/**'
-      - 'Launcher/**'
 
 env:
   SOLUTION_FILE_PATH: .
@@ -24,16 +14,16 @@ jobs:
     runs-on: windows-latest
 
     steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v7
       with:
         submodules: recursive
-    - uses: actions/setup-python@v5
+    - uses: actions/setup-python@v7
       id: cpy
       with:
         python-version: '3.14'
 
     - name: Add MSBuild to PATH
-      uses: microsoft/setup-msbuild@v2
+      uses: microsoft/setup-msbuild@v3
 
     - name: Install vcpkg
       run: |
@@ -60,7 +50,7 @@ jobs:
       run: Tools/build.bat
 
     - name: Upload Release Artifact
-      uses: actions/upload-artifact@v4
+      uses: actions/upload-artifact@v7
       with:
         name: Release
         path: ${{env.SOLUTION_FILE_PATH}}/x64/Release

Internal/Internal.vcxproj

@@ -69,6 +69,7 @@
   <ItemGroup>
     <ClInclude Include="cache\ActorCache.h" />
     <ClInclude Include="cache\ClassCache.h" />
+    <ClInclude Include="cache\FontCache.h" />
     <ClInclude Include="cache\NameCache.h" />
     <ClInclude Include="render\Vec2.h" />
     <ClInclude Include="render\Color.h" />
@@ -242,6 +243,7 @@
     <ClInclude Include="ue\sdk\UWorld.h" />
     <ClInclude Include="ue\sdk\Values.h" />
     <ClInclude Include="hook\Hook.h" />
+    <ClInclude Include="hook\GuardHook.h" />
     <ClInclude Include="features\Features.h" />
     <ClInclude Include="features\FeatureRunner.h" />
     <ClInclude Include="discord\handlers.h" />
@@ -264,6 +266,28 @@
     <ClInclude Include="memory\Memory.h" />
     <ClInclude Include="utils\Rgb.h" />
     <ClInclude Include="menu\Menu.h" />
+    <ClInclude Include="menu\canvas\Colors.h" />
+    <ClInclude Include="menu\canvas\UCanvasGUI.h" />
+    <ClInclude Include="menu\canvas\components\Core.h" />
+    <ClInclude Include="menu\canvas\components\Window.h" />
+    <ClInclude Include="menu\canvas\components\Text.h" />
+    <ClInclude Include="menu\canvas\components\Tab.h" />
+    <ClInclude Include="menu\canvas\components\Button.h" />
+    <ClInclude Include="menu\canvas\components\Checkbox.h" />
+    <ClInclude Include="menu\canvas\components\Slider.h" />
+    <ClInclude Include="menu\canvas\components\Combobox.h" />
+    <ClInclude Include="menu\canvas\components\Hotkey.h" />
+    <ClInclude Include="menu\canvas\components\ColorPicker.h" />
+    <ClInclude Include="menu\canvas\components\TextField.h" />
+    <ClInclude Include="menu\canvas\components\Selectable.h" />
+    <ClInclude Include="menu\canvas\components\CollapsingHeader.h" />
+    <ClInclude Include="menu\canvas\components\Combo.h" />
+    <ClInclude Include="menu\canvas\components\Child.h" />
+    <ClInclude Include="menu\ui\UI.h" />
+    <ClInclude Include="menu\backend\Backend.h" />
+    <ClInclude Include="menu\backend\ImGuiBackend.h" />
+    <ClInclude Include="menu\backend\CanvasBackend.h" />
+    <ClInclude Include="menu\backend\Backends.h" />
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="dllmain.cpp" />

Internal/cache/FontCache.h

@@ -0,0 +1,60 @@
+#pragma once
+
+/// @file
+/// @brief Lazily-built, shared list of every UFont in GObjects (short name + pointer), so the UE-canvas
+/// renderer can draw text in a chosen game font instead of the default Roboto. Mirrors ClassCache: fonts
+/// load once and rarely change, so the walk is done on demand and reused; Rebuild() (a Refresh button)
+/// picks up newly-loaded fonts.
+
+#include <string>
+#include <vector>
+
+#include "../ue/Engine.h"
+
+namespace FontCache
+{
+	/// One cached font: its short name (for display / the setting) and the object pointer.
+	struct Entry
+	{
+		std::string name;
+		UFont* font;
+	};
+
+	inline std::vector<Entry> fonts;
+	inline bool built = false;
+
+	/// Walk GObjects once and collect every UFont instance (skipping the class default object).
+	inline void Rebuild()
+	{
+		fonts.clear();
+		built = true;
+		if (!Engine::GObjects) return;
+
+		UObject* fontClass = Engine::GObjects->FindObject("Class Engine.Font");
+		if (!fontClass) return;
+
+		const auto count = Engine::GObjects->NumElements;
+		for (auto i = 0u; i < count; i++)
+		{
+			auto* obj = Engine::GObjects->GetObjectPtr(i);
+			if (!obj || obj->IsDefaultObject() || !obj->IsA(fontClass)) continue;
+			fonts.push_back({obj->GetName(), reinterpret_cast<UFont*>(obj)});
+		}
+	}
+
+	/// The cached fonts, building them on first use.
+	inline const std::vector<Entry>& Get()
+	{
+		if (!built) Rebuild();
+		return fonts;
+	}
+
+	/// Resolve a font by its short name; nullptr for an empty/unknown name (→ the renderer's default).
+	inline UFont* Find(const std::string& name)
+	{
+		if (name.empty()) return nullptr;
+		for (const Entry& e : Get())
+			if (e.name == name) return e.font;
+		return nullptr;
+	}
+} // namespace FontCache

Internal/features/AnnounceToggles.h

@@ -48,7 +48,7 @@ class AnnounceToggles : public Feature
 	AnnounceToggles()
 	{
 		Name = "AnnounceToggles";
-		Event = Events::Type::SettingsChanged; // driven by menu changes, not per-frame
+		Triggers = {Events::Type::SettingsChanged}; // driven by menu changes, not per-frame
 		UpdateEnabled();
 		Log("Created");
 	};

Internal/features/DiscordPresence.h

@@ -2,23 +2,22 @@
 
 /// @file
 /// The DiscordPresence feature: refreshes the Discord Rich Presence with live game state (map +
-/// K/D) on a throttle, so the presence stays current without spamming Discord every frame.
+/// K/D). Event-driven rather than per-frame — it runs on the in-game/in-lobby transitions
+/// (EnteredGame / EnteredLobby) and on each kill (PlayerKilled) so the K/D stays current.
+/// UpdateGameState only pushes to Discord when the string actually changes, so PlayerKilled
+/// (which fires for every kill in the match) effectively updates only on the local player's
+/// own kills/deaths.
 
 #include "Feature.h"
 #include "../discord/rpc.h"
 
-#include <chrono>
-
 class DiscordPresence : public Feature
 {
-  private:
-	std::chrono::steady_clock::time_point lastUpdate{};
-	static constexpr int IntervalSeconds = 5;
-
   public:
 	DiscordPresence()
 	{
 		Name = "DiscordPresence";
+		Triggers = {Events::Type::EnteredGame, Events::Type::EnteredLobby, Events::Type::PlayerKilled};
 		UpdateEnabled();
 		Log("Created");
 	};
@@ -42,12 +41,10 @@ class DiscordPresence : public Feature
 	void Destroy() {
 	};
 
-	void Run()
+	/// Push the current game state to Discord on the event that fired us (a state transition or a
+	/// kill). UpdateGameState no-ops when the resulting presence string is unchanged.
+	void Run() override
 	{
-		const auto now = std::chrono::steady_clock::now();
-		if (std::chrono::duration_cast<std::chrono::seconds>(now - lastUpdate).count() < IntervalSeconds) return;
-
-		lastUpdate = now;
 		DiscordRPC::UpdateGameState();
 	};
 };

Internal/features/Feature.h

@@ -6,6 +6,9 @@
 /// drive it. See the class comment below for the full Init/Check/Run/Destroy
 /// contract.
 
+#include <vector>
+#include <chrono>
+
 #include "../settings/Settings.h"
 #include "../utils/Logger.h"
 #include "../scripting/Events.h"
@@ -34,19 +37,33 @@ class Feature
 	bool Enabled = false;	  // toggled from settings via UpdateEnabled()
 	bool Initialized = false; ///< set true by Init() once setup succeeds; features guard on this
 	bool OneTime = false;	  // Run() fires once per enable instead of every frame
+	int ThrottleMs = 0;		  ///< minimum gap between Run() calls in ms; 0 = every tick/event
 
 	std::string Name = "BaseFeature"; ///< human-readable id, used in Log() output
-	// Which event drives this feature. Render runs every frame (the fast loop in
-	// Features::Execute); any other event subscribes it to the event bus and runs
-	// it when that event is dispatched (e.g. Events::Type::PlayerDeath).
-	Events::Type Event = Events::Type::Render;
+	// Which events drive this feature. Render runs every frame (the fast loop in
+	// Features::Execute); every other trigger subscribes it to the event bus and runs it when that
+	// event is dispatched (e.g. Events::Type::PlayerDeath). A feature may list several triggers, and
+	// may mix Render with bus events.
+	std::vector<Events::Type> Triggers{Events::Type::Render};
 
 	// Bookkeeping owned by Features::Execute; subclasses should not touch these.
-	bool applied = false; // Run() has been applied and not yet reverted by Destroy()
-	bool hasRun = false;  // a OneTime feature has already run this enable cycle
+	bool applied = false;								  // Run() has been applied and not yet reverted by Destroy()
+	bool hasRun = false;								  // a OneTime feature has already run this enable cycle
+	std::chrono::steady_clock::time_point lastRun{};  // when Run() last fired, for ThrottleMs
 
 	Feature() {};
 
+	/// Whether the throttle interval has elapsed since the last Run() (and, if so, stamps it now).
+	/// Always true when ThrottleMs <= 0. Owned by the runner; features don't call this.
+	bool ThrottleReady()
+	{
+		if (ThrottleMs <= 0) return true;
+		const auto now = std::chrono::steady_clock::now();
+		if (now - lastRun < std::chrono::milliseconds(ThrottleMs)) return false;
+		lastRun = now;
+		return true;
+	}
+
 	/// One-time setup (resolve game objects, cache originals). Must set
 	/// Initialized to reflect success; the runner calls it on first use.
 	virtual void Init() = 0;
@@ -58,8 +75,14 @@ class Feature
 	virtual bool Check() = 0;
 	/// Revert whatever Run() applied. Called once on the enabled -> disabled edge.
 	virtual void Destroy() = 0;
-	/// Apply the effect. Called every frame while enabled (or once per enable if OneTime).
-	virtual void Run() = 0;
+
+	/// Apply the effect. Called every frame while enabled (or once per enable if OneTime) for a
+	/// Render trigger, and on each dispatch of any other trigger event. The runner always calls the
+	/// (event, payload) form; the default chain lets a subclass override whichever arity it needs —
+	/// Run() to ignore the trigger, Run(event) for the event only, or Run(event, payload) for both.
+	virtual void Run() {}
+	virtual void Run(Events::Type) { Run(); }
+	virtual void Run(Events::Type event, const Events::Payload&) { Run(event); }
 
 	/// Emit a "[Name] message" line, but only when Settings.DEBUG.FeaturesLogging is on.
 	void Log(std::string message)

Internal/features/FeatureRunner.h

@@ -7,6 +7,7 @@
 
 #include <vector>
 #include <memory>
+#include <algorithm>
 
 #include "Feature.h"
 
@@ -24,10 +25,11 @@ namespace Features
 	// Drives a single feature once: init on first use, refresh Enabled, skip if
 	// idle-disabled, then Run() while enabled (once, if OneTime) or Destroy()
 	// exactly once on the enabled -> disabled edge. Used both by the per-frame
-	// render loop and by the event bus (for event-driven features). Features
-	// whose Check() still returns Enabled keep their previous behavior (they just
-	// skip on disable and never reach Destroy).
-	inline void RunFeature(Feature& feature)
+	// render loop and by the event bus (for event-driven features). The triggering
+	// @p event and @p payload are forwarded to Run() (defaulting to the Render loop's
+	// empty payload). Features whose Check() still returns Enabled keep their previous
+	// behavior (they just skip on disable and never reach Destroy).
+	inline void RunFeature(Feature& feature, Events::Type event = Events::Type::Render, const Events::Payload& payload = {})
 	{
 		try
 		{
@@ -53,9 +55,9 @@ namespace Features
 
 			if (feature.Enabled)
 			{
-				if (!feature.OneTime || !feature.hasRun)
+				if ((!feature.OneTime || !feature.hasRun) && feature.ThrottleReady())
 				{
-					feature.Run();
+					feature.Run(event, payload);
 					feature.hasRun = true;
 				}
 				feature.applied = true;
@@ -77,13 +79,14 @@ namespace Features
 	}
 
 	// Runs every render-driven feature. Called once per rendered frame from
-	// PostRender. Event-driven features (Event != "render") are skipped here and
-	// run from the event bus instead.
+	// PostRender. Features without a Render trigger are skipped here and run from
+	// the event bus instead (a feature may have both).
 	inline void Execute()
 	{
 		for (const auto& feature : Features)
 		{
-			if (feature->Event == Events::Type::Render)
+			const auto& triggers = feature->Triggers;
+			if (std::find(triggers.begin(), triggers.end(), Events::Type::Render) != triggers.end())
 			{
 				RunFeature(*feature);
 			}

Internal/features/Features.h

@@ -88,14 +88,16 @@ namespace Features
 			// Autosave: persist on every change when enabled.
 			if (Settings.MISC.AutoSave) SettingsHelper::File().Save(); });
 
-		// Subscribe event-driven features (Event != "render") to the event bus;
-		// render features run from Features::Execute each frame instead.
+		// Subscribe each non-Render trigger to the event bus, forwarding the event + payload to the
+		// feature's Run(); Render triggers run from Features::Execute each frame instead. A feature
+		// may list several triggers (e.g. DiscordPresence on EnteredGame + EnteredLobby).
 		for (auto& feature : Features)
 		{
-			if (feature->Event != Events::Type::Render)
+			for (Events::Type trigger : feature->Triggers)
 			{
-				Events::Register(feature->Event, [ptr = feature.get()]
-								 { RunFeature(*ptr); });
+				if (trigger == Events::Type::Render) continue;
+				Events::Register(trigger, [ptr = feature.get(), trigger](const Events::Payload& payload)
+								 { RunFeature(*ptr, trigger, payload); });
 			}
 		}