1 files changed, 237 insertions, 0 deletions

@@ -0,0 +1,237 @@
+using HarmonyLib;
+using System.Reflection;
+
+namespace ManifoldGardenArchipelago
+{
+    [HarmonyPatch(typeof(LineDoorController), "SetDoorOpenCloseStateAnimated")]
+    static class LineDoorControllerSetDoorOpenCloseStateAnimatedPatch
+    {
+        static bool Prefix(LineDoorController __instance, bool open)
+        {
+            SceneItemReference sir = GameState.GetChainListenerSceneReference(__instance);
+
+            if (GameData.scenes.TryGetValue(sir.scene, out var sceneDescription))
+            {
+                if (sceneDescription.doors.TryGetValue(sir.index, out var requirement))
+                {
+                    if (open != requirement.Check())
+                    {
+                        return false;
+                    }
+                }
+            }
+
+            return true;
+        }
+    }
+
+    [HarmonyPatch(typeof(ButtonLineActivator), "ToggleButtonPress")]
+    static class ButtonLineActivatorToggleButtonPressPatch
+    {
+        static void Prefix(ButtonLineActivator __instance, bool setPressed)
+        {
+            SceneItemReference sir = GameState.GetButtonSceneReference(__instance);
+            Plugin.Logger.LogInfo($"Button {sir} state {setPressed}");
+
+            if (!GameData.listenersByButton.TryGetValue(sir, out GameStateListeners listeners))
+            {
+                return;
+            }
+
+            if (setPressed)
+            {
+                Plugin.slotSave.ActivatedButtons.Add(sir);
+            }
+            else
+            {
+                Plugin.slotSave.ActivatedButtons.Remove(sir);
+            }
+
+            GameState.EvaluateGameStateListeners(listeners);
+        }
+    }
+
+    [HarmonyPatch(typeof(CubeReceiverController), "SetActivatorActive")]
+    static class CubeReceiverControllerSetActivatorActivePatch
+    {
+        static void Prefix(CubeReceiverController __instance, bool active)
+        {
+            SceneItemReference sir = GameState.GetSocketSceneReference(__instance);
+            Plugin.Logger.LogInfo($"Socket {sir} state {active}");
+
+            if (!GameData.listenersBySocket.TryGetValue(sir, out GameStateListeners listeners))
+            {
+                return;
+            }
+
+            if (active)
+            {
+                Plugin.slotSave.ActivatedSockets.Add(sir);
+            }
+            else
+            {
+                Plugin.slotSave.ActivatedSockets.Remove(sir);
+            }
+
+            GameState.EvaluateGameStateListeners(listeners);
+        }
+    }
+
+    [HarmonyPatch(typeof(CubeLineActivator), "SetActivatorActive")]
+    static class CubeLineActivatorSetActivatorActivePatch
+    {
+        static void Prefix(CubeLineActivator __instance, bool setActive)
+        {
+            SceneItemReference sir = GameState.GetPadSceneReference(__instance);
+            Plugin.Logger.LogInfo($"Pad {sir} state {setActive}");
+
+            if (!GameData.listenersByPad.TryGetValue(sir, out GameStateListeners listeners))
+            {
+                return;
+            }
+
+            if (setActive)
+            {
+                Plugin.slotSave.ActivatedPads.Add(sir);
+            }
+            else
+            {
+                Plugin.slotSave.ActivatedPads.Remove(sir);
+            }
+
+            GameState.EvaluateGameStateListeners(listeners);
+        }
+    }
+
+    [HarmonyPatch(typeof(WaterDetector), "SetActivatorActive")]
+    static class WaterDetectorSetActivatorActivePatch
+    {
+        static void Prefix(WaterDetector __instance, bool setActive)
+        {
+            SceneItemReference sir = GameState.GetWaterwheelSceneReference(__instance);
+            Plugin.Logger.LogInfo($"Waterwheel {sir} state {setActive}");
+
+            if (!GameData.listenersByWaterwheel.TryGetValue(sir, out GameStateListeners listeners))
+            {
+                return;
+            }
+
+            if (setActive)
+            {
+                Plugin.slotSave.ActivatedWaterwheels.Add(sir);
+            }
+            else
+            {
+                Plugin.slotSave.ActivatedWaterwheels.Remove(sir);
+            }
+
+            GameState.EvaluateGameStateListeners(listeners);
+        }
+    }
+
+    [HarmonyPatch(typeof(SphereController), nameof(SphereController.SetState))]
+    static class SphereControllerSetStatePatch
+    {
+        static void Prefix(SphereController __instance, SphereController.State newState)
+        {
+            SceneItemReference sir = GameState.GetSphereSceneReference(__instance);
+            Plugin.Logger.LogInfo($"Sphere {sir} state {newState}");
+
+            if (!GameData.listenersBySphere.TryGetValue(sir, out GameStateListeners listeners))
+            {
+                return;
+            }
+
+            if (newState == SphereController.State.AtDestination)
+            {
+                Plugin.slotSave.ActivatedSpheres.Add(sir);
+            }
+            else
+            {
+                Plugin.slotSave.ActivatedSpheres.Remove(sir);
+            }
+
+            GameState.EvaluateGameStateListeners(listeners);
+        }
+    }
+
+    [HarmonyPatch(typeof(LineDoorController), nameof(LineDoorController.OnLevelEnable))]
+    static class LineDoorControllerOnLevelEnablePatch
+    {
+        static void Prefix(LineDoorController __instance)
+        {
+            SceneItemReference sir = GameState.GetChainListenerSceneReference(__instance);
+
+            if (GameData.scenes.TryGetValue(sir.scene, out var sceneDescription))
+            {
+                if (sceneDescription.doors.TryGetValue(sir.index, out var requirement))
+                {
+                    FieldInfo fieldInfo = typeof(LineDoorController).GetField("doorShouldOpenImmediatelyOnEnable", BindingFlags.Instance | BindingFlags.NonPublic);
+                    fieldInfo.SetValue(__instance, requirement.Check());
+
+                    __instance.chains.Clear();
+                }
+            }
+        }
+    }
+
+    [HarmonyPatch(typeof(LineDoorController), nameof(LineDoorController.OnLoad))]
+    static class LineDoorControllerOnLoadPatch
+    {
+        static void Prefix(LineDoorController __instance)
+        {
+            SceneItemReference sir = GameState.GetChainListenerSceneReference(__instance);
+
+            if (GameData.scenes.TryGetValue(sir.scene, out var sceneDescription))
+            {
+                if (sceneDescription.doors.TryGetValue(sir.index, out var requirement))
+                {
+                    FieldInfo fieldInfo = typeof(LineDoorController).GetField("doorShouldOpenImmediatelyOnEnable", BindingFlags.Instance | BindingFlags.NonPublic);
+                    fieldInfo.SetValue(__instance, requirement.Check());
+
+                    __instance.chains.Clear();
+                }
+            }
+        }
+    }
+
+    [HarmonyPatch(typeof(LevelLoader), nameof(LevelLoader.MovePlayerIntoNewScene))]
+    static class LevelLoaderMovePlayerIntoNewScenePatch
+    {
+        static void Postfix(LevelSystems newLevel)
+        {
+            Plugin.slotSave.VisitedScenes.Add(newLevel.levelName);
+
+            if (GameData.listenersByScene.TryGetValue(newLevel.levelName, out var listeners))
+            {
+                GameState.EvaluateGameStateListeners(listeners);
+            }
+        }
+    }
+
+    [HarmonyPatch(typeof(DarkModeCollapsedCubeWorldGrow), nameof(DarkModeCollapsedCubeWorldGrow.OnChainFillComplete))]
+    static class DarkModeCollapsedCubeWorldGrowOnChainFillCompletePatch
+    {
+        static bool Prefix()
+        {
+            return false;
+        }
+    }
+
+    [HarmonyPatch(typeof(DarkModeCollapsedCubeWorldGrow), nameof(DarkModeCollapsedCubeWorldGrow.OnLevelEnable))]
+    static class DarkModeCollapsedCubeWorldGrowOnLevelEnablePatch
+    {
+        static void Prefix(DarkModeCollapsedCubeWorldGrow __instance)
+        {
+            SceneItemReference sir = GameState.GetChainListenerSceneReference(__instance);
+
+            if (GameData.scenes.TryGetValue(sir.scene, out var sceneDescription) &&
+                sceneDescription.worldGrows.TryGetValue(sir.index, out var requirement) &&
+                requirement.Check())
+            {
+                FieldInfo fieldInfo = typeof(DarkModeCollapsedCubeWorldGrow).GetField("m_grown", BindingFlags.Instance | BindingFlags.NonPublic);
+                fieldInfo.SetValue(__instance, true);
+            }
+        }
+    }
+}