Development Merge (0.2.0) Fixed Restoring StoryMode state

bud3699 · web-flow · commit 60d93a444934 · 2025-10-10T17:25:37.000+01:00
* Initial work on reversing gamemode state (dev)

* Fixed Level State Restoring Plus Bug Fixes

- Added new transpiler to Restore Story mode state correctly when Switching back
- Removed Useless levelManagerType Method for custom levels (No level index so dont touch saves at all)
- Removed "currentLevelIndex" for custom levels (No level index so no need to pass a dummy - This was used at beginning of mod development to spoof story mode level to load levels that way, I have wrote a custom gamemode now so no need)
- Removed Useless Log and tweaked some
- Added Null checks on director instance for loading custom levels

* 0.2.0 Bump

Due to Fixed Major Issue with loading back into story mode from custom level. Just don't load into level editor when in custom level (You should be able to anyway unless you have a conflicting mod)
diff --git a/CustomLevels/CustomLevels.csproj b/CustomLevels/CustomLevels.csproj
@@ -317,6 +317,8 @@
     <Compile Include="LevelGameBuilderExtension.cs" />
     <Compile Include="LevelManagerPatches.cs" />
     <Compile Include="main.cs" />
+    <Compile Include="MenuButtonSandboxExtensions.cs" />
+    <Compile Include="MenuButtonSandboxPatches.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
   </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
diff --git a/CustomLevels/DirectorExtensions.cs b/CustomLevels/DirectorExtensions.cs
@@ -49,45 +49,15 @@ private static void ExecuteLoadCustomLevel(object directorInstance, string Level
                 return;
             }
 
-            int currentLevelIndex;
             object gameLevel;
-            levelBuilder.InitCustomLevelFromCode(LevelCode, out currentLevelIndex, out gameLevel);
+            levelBuilder.InitCustomLevelFromCode(LevelCode, out gameLevel);
 
             if (gameLevel == null)
             {
                 Debug.LogError("Failed to load custom level — aborting LoadCustomLevel!");
                 return;
             }
 
-            Type levelManagerType = AccessTools.TypeByName("LevelManager");
-            levelManagerType?.GetMethod("Init")?.Invoke(null, new object[] { currentLevelIndex });
-
-            var ui = UIManager.instance;
-            if (ui != null)
-            {
-                var menuLayer = AccessTools.Field(ui.GetType(), "menuLayer")?.GetValue(ui);
-                if (menuLayer != null)
-                {
-                    var levelButtons = AccessTools.Field(menuLayer.GetType(), "levelButtons")?.GetValue(menuLayer) as IEnumerable<object>;
-                    if (levelButtons != null)
-                    {
-                        foreach (var btn in levelButtons)
-                        {
-                            if (btn is Component comp)
-                            {
-                                AccessTools.Method(comp.GetType(), "Init")?.Invoke(comp, new object[] { currentLevelIndex });
-                            }
-                        }
-                    }
-                    else Debug.LogWarning("UIManager menuLayer.levelButtons is null!");
-                }
-                else Debug.LogWarning("UIManager menuLayer is null!");
-            }
-            else
-            {
-                Debug.LogError("UIManager instance still null after waiting!");
-                return;
-            }
             AccessTools.TypeByName("LevelNumber")?.GetMethod("ChangeLevelText")?.Invoke(null, new object[] { LevelCode });
 
             AccessTools.Method(directorInstance.GetType(), "InitCommonSystems")?.Invoke(directorInstance, null);
@@ -128,15 +98,13 @@ private static void ExecuteLoadCustomLevel(object directorInstance, string Level
                 Debug.LogWarning("ReplayManager is null!");
 
             AccessTools.Method(directorInstance.GetType(), "InitVisuals")?.Invoke(directorInstance, null);
-
-            Debug.Log($"<color=green>Custom level loaded successfully: Index {currentLevelIndex}</color>");
         }
 
 
         public static void SafeInitVisuals(object directorInstance)
         {
             var traverse = Traverse.Create(directorInstance);
-            var gameMode = (GameMode)traverse.Field("gameMode").GetValue();
+            var gameMode = Director.gameMode;  //(GameMode)traverse.Field("gameMode").GetValue();
 
             (float, int, bool, float) tuple;
 
@@ -145,30 +113,44 @@ public static void SafeInitVisuals(object directorInstance)
                 Debug.Log("[Patch] Using fallback tuple for GameMode 3");
                 tuple = (0.75f, 1, false, 4.5f);
             }
+            else if (SandboxStateMapping.mapping.TryGetValue(gameMode, out var mappedTuple))
+            {
+                Debug.Log("[Patch] gamemode: " + gameMode.ToString());
+                tuple = mappedTuple;
+            }
             else
             {
-                tuple = SandboxStateMapping.mapping[gameMode];
+                Debug.LogWarning($"[Patch] Unknown GameMode: {gameMode}, using default fallback");
+                tuple = (0.75f, 1, false, 4.5f);
             }
 
+
+
             CameraSizeManager.SetAdditiveSize(tuple.Item1);
 
-            var gridLines = AccessTools.Field(AccessTools.TypeByName("GridLines"), "instance")?.GetValue(null);
-            if (gridLines != null)
-            {
-                AccessTools.Method(gridLines.GetType(), "SetGameGrid")?.Invoke(gridLines, new object[] { tuple.Item2 });
+            //var gridLines = AccessTools.Field(AccessTools.TypeByName("GridLines"), "instance")?.GetValue(null);
+            GridLines.instance?.SetGameGrid(tuple.Item2);
+            //if (gridLines != null)
+            //{
+                //AccessTools.Method(gridLines.GetType(), "SetGameGrid")?.Invoke(gridLines, new object[] { tuple.Item2 });
 
                 if (tuple.Item3)
                 {
-                    var selectedButton = AccessTools.Field(AccessTools.TypeByName("LayerSandbox"), "selectedButton")?.GetValue(null);
-                    bool willPlaceOut = selectedButton is SandboxButtonEntity entity && entity.willPlaceOut;
-                    AccessTools.Method(gridLines.GetType(), "ShowCantPlace")?.Invoke(gridLines, new object[] { willPlaceOut });
+                    //var selectedButton = AccessTools.Field(AccessTools.TypeByName("LayerSandbox"), "selectedButton")?.GetValue(null);
+                    //bool willPlaceOut = selectedButton is SandboxButtonEntity entity && entity.willPlaceOut;
+                    //AccessTools.Method(gridLines.GetType(), "ShowCantPlace")?.Invoke(gridLines, new object[] { willPlaceOut });
+                    GridLines.instance?.ShowCantPlace(LayerSandbox.selectedButton is SandboxButtonEntity sandboxButtonEntity && sandboxButtonEntity.willPlaceOut);
                 }
                 else
                 {
-                    AccessTools.Method(gridLines.GetType(), "ResetCantPlace")?.Invoke(gridLines, null);
-                }
-            }
-
+                    //AccessTools.Method(gridLines.GetType(), "ResetCantPlace")?.Invoke(gridLines, null);
+                    GridLines.instance?.ResetCantPlace();
+                } 
+                (UIManager.instance.sandboxLayer.allEntityButtons.Last() as SandboxButtonEntity).SetSprite();
+                var heartContainer = traverse.Field("heartContainer").GetValue();
+                AccessTools.Method(heartContainer.GetType(), "MoveContainerY")?.Invoke(heartContainer, new object[] { tuple.Item4 });
+            //}
+            /*
             var ui = UIManager.instance;
             var lastButton = ui?.sandboxLayer?.allEntityButtons?.LastOrDefault();
             if (lastButton is SandboxButtonEntity sbEntity)
@@ -178,6 +160,8 @@ public static void SafeInitVisuals(object directorInstance)
 
             var heartContainer = traverse.Field("heartContainer").GetValue();
             AccessTools.Method(heartContainer.GetType(), "MoveContainerY")?.Invoke(heartContainer, new object[] { tuple.Item4 });
+               */
+            UIManager.instance?.menuLayer.CalculateMenu();
         }
 
     }
diff --git a/CustomLevels/DirectorPatches.cs b/CustomLevels/DirectorPatches.cs
@@ -21,6 +21,10 @@ public static void ApplyPatch(HarmonyLib.Harmony harmony)
             var transpiler = AccessTools.Method(typeof(DirectorPatches), nameof(InitTranspiler));
             harmony.Patch(original, transpiler: new HarmonyMethod(transpiler));
 
+            var originalInitGameMode = AccessTools.Method(typeof(Director), "InitGameMode");
+            var transpilerInitGameMode = AccessTools.Method(typeof(DirectorPatches), nameof(InitGameModeTranspiler));
+            harmony.Patch(originalInitGameMode, transpiler: new HarmonyMethod(transpilerInitGameMode));
+
             var originalVisuals = AccessTools.Method(typeof(Director), "InitVisuals");
             var prefixVisuals = AccessTools.Method(typeof(DirectorPatches), nameof(InitVisualsPrefix));
             harmony.Patch(originalVisuals, prefix: new HarmonyMethod(prefixVisuals));
@@ -43,6 +47,27 @@ private static void ParseCommandLineArgs()
             }
         }
 
+        public static IEnumerable<CodeInstruction> InitGameModeTranspiler(IEnumerable<CodeInstruction> instructions)
+        {
+            var debugLogMethod = AccessTools.Method(typeof(Debug), "Log", new[] { typeof(object) });
+            var levelBuilderField = AccessTools.Field(typeof(Director), "levelBuilder");
+            var customLevelField = AccessTools.Field(typeof(LevelGameBuilder), "customLevel");
+
+
+            yield return new CodeInstruction(OpCodes.Ldarg_0);
+            yield return new CodeInstruction(OpCodes.Ldfld, levelBuilderField); 
+
+            yield return new CodeInstruction(OpCodes.Ldc_I4_0);
+
+            yield return new CodeInstruction(OpCodes.Stfld, customLevelField);
+
+            foreach (var instruction in instructions)
+            {
+                yield return instruction;
+            }
+        }
+
+
         public static IEnumerable<CodeInstruction> InitTranspiler(IEnumerable<CodeInstruction> instructions)
         {
             var codes = new List<CodeInstruction>(instructions);
diff --git a/CustomLevels/LayerMenuExtension.cs b/CustomLevels/LayerMenuExtension.cs
@@ -2,6 +2,7 @@
 using HarmonyLib;
 using QuadrataPatcher;
 using Steamworks;
+using System.Collections;
 using System.Collections.Generic;
 using System.Diagnostics.Eventing.Reader;
 using System.Linq;
@@ -10,6 +11,16 @@
 
 public static class LayerMenuExtensions
 {
+    private static IEnumerator WaitAndChangeSprite(MenuButtonSandbox sandboxBtn, Sprite sprite)
+    {
+        yield return new WaitWhile(() => UIManager.isMenuMoving);
+
+        var traverse = Traverse.Create(sandboxBtn);
+        var buttonIcon = traverse.Field("buttonIcon").GetValue<Image>();
+
+        if (buttonIcon != null){buttonIcon.sprite = sprite;}
+    }
+
     public static void ChangeLevelSelectSizeExtended(this object layerMenuInstance, Vector2 size, float time, Ease ease)
     {
         var traverse = Traverse.Create(layerMenuInstance);
@@ -121,10 +132,10 @@ public static void CalculateMenuExtended(this object layerMenuInstance)
 
         if (gameMode != 3 && levelButtons != null)
         {
-            levelButtons.ForEach(button =>
+            foreach (var button in levelButtons)
             {
-                button.navigationButtons[Vector2.up] = activeButtons[0];
-            });
+                button.gameObject.SetActive(true);
+            }
         }
         else if (levelButtons != null)
         {
@@ -228,14 +239,32 @@ public static void CalculateMenuExtended(this object layerMenuInstance)
                 Button loadButton = loadButtonObj.GetComponent<Button>();
                 loadButton.onClick.AddListener(() =>
                 {
+                    
+                    var sandboxBtn = GameObject.FindObjectsOfType<MenuButtonSandbox>().FirstOrDefault();
+
+                    var sandboxTraverse = Traverse.Create(sandboxBtn);
+                    var toggleMapping = sandboxTraverse.Field("toggleMapping").GetValue<Dictionary<GameMode, (GameMode targetMode, Sprite targetIcon)>>();
+
+                    GameMode currentMode = (GameMode)Traverse.Create(typeof(Director)).Field("gameMode").GetValue();
+                    /*
+                    if (toggleMapping.TryGetValue(currentMode, out var mapping) && !(Director.gameMode == (GameMode)3)) {
+                        Debug.Log("Got value of pre: " + Director.gameMode.ToString());
+                        Director.gameMode = mapping.targetMode;
+                        Debug.Log("Got value of: " + mapping.targetMode.ToString());
+                    }
+                    */
+
                     Director.gameMode = (GameMode)3;
-                    DirectorPatches.customLevelCode = inputField.text;
                     UIManager.instance?.menuLayer.CloseMenu();
-                    Director.instance.Init();
+                    UIManager.instance?.sandboxLayer.sideButtons.Last().ResetButton();
+                    Director.instance?.StartCoroutine(WaitAndChangeSprite(sandboxBtn, toggleMapping[Director.gameMode].targetIcon));
+                    DirectorPatches.customLevelCode = inputField.text;
+                    Director.instance?.Init();
 
                     Debug.Log($"[Patch] Loaded custom level code: {inputField.text}");
                 });
 
+
                 Debug.Log("[Patch] Menu Load button and InputField added.");
             }
 
diff --git a/CustomLevels/LevelGameBuilderExtension.cs b/CustomLevels/LevelGameBuilderExtension.cs
@@ -8,9 +8,8 @@ namespace QuadrataPatcher
 {
     public static class LevelGameBuilderExtensions
     {
-        public static void InitCustomLevelFromCode(this object instance, string levelCode, out int currentLevelIndex, out object currentGameLevel)
+        public static void InitCustomLevelFromCode(this object instance, string levelCode, out object currentGameLevel)
         {
-            currentLevelIndex = 90;
             currentGameLevel = null;
 
             try
@@ -66,7 +65,7 @@ public static void InitCustomLevelFromCode(this object instance, string levelCod
 
                 currentGameLevel = gameLevel;
 
-                Debug.Log($"<color=green>Custom level loaded from code '{levelCode}' with index {currentLevelIndex}!</color>");
+                Debug.Log($"<color=green>Custom level loaded from code '{levelCode}'!</color>");
             }
             catch (Exception ex)
             {
diff --git a/CustomLevels/MenuButtonSandboxExtensions.cs b/CustomLevels/MenuButtonSandboxExtensions.cs
@@ -0,0 +1,29 @@
+﻿using UnityEngine;
+using System.Collections.Generic;
+using System.Reflection;
+
+namespace CustomLevels
+{
+    internal static class MenuButtonSandboxExtensions
+    {
+        public static void ToggleMappingSet(MenuButtonSandbox instance)
+        {
+            var toggleMappingField = typeof(MenuButtonSandbox).GetField("toggleMapping", BindingFlags.NonPublic | BindingFlags.Instance);
+            var editorIconField = typeof(MenuButtonSandbox).GetField("editorIcon", BindingFlags.NonPublic | BindingFlags.Instance);
+            var gameIconField = typeof(MenuButtonSandbox).GetField("gameIcon", BindingFlags.NonPublic | BindingFlags.Instance);
+
+            var editorIcon = (Sprite)editorIconField.GetValue(instance);
+            var gameIcon = (Sprite)gameIconField.GetValue(instance);
+
+            var mapping = new Dictionary<GameMode, (GameMode, Sprite)>
+            {
+                { GameMode.Game, (GameMode.SandboxEdit, editorIcon) },
+                { GameMode.SandboxEdit, (GameMode.Game, gameIcon) },
+                { GameMode.SandboxPlay, (GameMode.Game, gameIcon) },
+                { (GameMode)3, (GameMode.Game, gameIcon) }
+            };
+
+            toggleMappingField.SetValue(instance, mapping);
+        }
+    }
+}
diff --git a/CustomLevels/MenuButtonSandboxPatches.cs b/CustomLevels/MenuButtonSandboxPatches.cs
@@ -0,0 +1,21 @@
+﻿using HarmonyLib;
+
+namespace CustomLevels
+{
+    [HarmonyPatch(typeof(MenuButtonSandbox), "Awake")]
+    internal static class MenuButtonSandboxPatches
+    {
+        static bool Prefix(MenuButtonSandbox __instance)
+        {
+            MenuButtonSandboxExtensions.ToggleMappingSet(__instance);
+            return false;
+        }
+
+        public static void ApplyPatch(HarmonyLib.Harmony harmony)
+        {
+            var originalAwake = AccessTools.Method(typeof(MenuButtonSandbox), "Awake");
+            var prefix = AccessTools.Method(typeof(MenuButtonSandboxPatches), nameof(Prefix));
+            harmony.Patch(originalAwake, prefix: new HarmonyMethod(prefix));
+        }
+    }
+}
diff --git a/CustomLevels/main.cs b/CustomLevels/main.cs
@@ -1,8 +1,9 @@
 ﻿using MelonLoader;
 using HarmonyLib;
 using System.Reflection;
+using CustomLevels;
 
-[assembly: MelonInfo(typeof(QuadrataPatcher.Main), "Custom Levels", "0.1.0", "Bud3699")]
+[assembly: MelonInfo(typeof(QuadrataPatcher.Main), "Custom Levels", "0.2.0", "Bud3699")]
 [assembly: MelonGame("Mindlabor", "Quadrata")]
 
 namespace QuadrataPatcher
@@ -23,6 +24,9 @@ public override void OnInitializeMelon()
             LevelManagerPatches.ApplyPatch(harmony);
             MelonLogger.Msg("Patched Level Manger to allow gameplay");
 
+            MenuButtonSandboxPatches.ApplyPatch(harmony);
+            MelonLogger.Msg("Patched MenuButtonSandbox to allow icon changes");
+
             string[] args = System.Environment.GetCommandLineArgs();
             bool patchedLayerMenu = false;
 

Original file line number	Diff line number	Diff line change
`@@ -8,9 +8,8 @@ namespace QuadrataPatcher`
`8`	`8`	`{`
`9`	`9`	`public static class LevelGameBuilderExtensions`
`10`	`10`	`{`
`11`		`- public static void InitCustomLevelFromCode(this object instance, string levelCode, out int currentLevelIndex, out object currentGameLevel)`
	`11`	`+ public static void InitCustomLevelFromCode(this object instance, string levelCode, out object currentGameLevel)`
`12`	`12`	`{`
`13`		`- currentLevelIndex = 90;`
`14`	`13`	`currentGameLevel = null;`
`15`	`14`
`16`	`15`	`try`
`@@ -66,7 +65,7 @@ public static void InitCustomLevelFromCode(this object instance, string levelCod`
`66`	`65`
`67`	`66`	`currentGameLevel = gameLevel;`
`68`	`67`
`69`		`- Debug.Log($"<color=green>Custom level loaded from code '{levelCode}' with index {currentLevelIndex}!</color>");`
	`68`	`+ Debug.Log($"<color=green>Custom level loaded from code '{levelCode}'!</color>");`
`70`	`69`	`}`
`71`	`70`	`catch (Exception ex)`
`72`	`71`	`{`