1 files changed, 151 insertions, 44 deletions

@@ -1,5 +1,6 @@
 using HarmonyLib;
 using System.Reflection;
+using UnityEngine;
 
 namespace ManifoldGardenArchipelago
 {
@@ -14,9 +15,16 @@ namespace ManifoldGardenArchipelago
             {
                 if (sceneDescription.doors.TryGetValue(sir.index, out var requirement))
                 {
-                    if (open != requirement.Check())
+                    Requirement.Decision decision = requirement.Check();
+
+                    if (decision != Requirement.Decision.Maybe)
                     {
-                        return false;
+                        bool shouldOpen = (decision == Requirement.Decision.Yes);
+
+                        if (open != shouldOpen)
+                        {
+                            return false;
+                        }
                     }
                 }
             }
@@ -38,15 +46,27 @@ namespace ManifoldGardenArchipelago
                 return;
             }
 
-            if (setPressed)
-            {
-                Plugin.slotSave.ActivatedButtons.Add(sir);
-            }
-            else
+            Plugin.slotSave.ActivatedButtons[sir] = setPressed;
+
+            GameState.EvaluateGameStateListeners(listeners);
+        }
+    }
+
+    [HarmonyPatch(typeof(ButtonLineActivator), "ForceButtonPressedImmediately")]
+    static class ButtonLineActivatorForceButtonPressedImmediatelyPatch
+    {
+        static void Prefix(ButtonLineActivator __instance, bool _pressed)
+        {
+            SceneItemReference sir = GameState.GetButtonSceneReference(__instance);
+            Plugin.Logger.LogInfo($"Button {sir} forced state {_pressed}");
+
+            if (!GameData.listenersByButton.TryGetValue(sir, out GameStateListeners listeners))
             {
-                Plugin.slotSave.ActivatedButtons.Remove(sir);
+                return;
             }
 
+            Plugin.slotSave.ActivatedButtons[sir] = _pressed;
+
             GameState.EvaluateGameStateListeners(listeners);
         }
     }
@@ -64,14 +84,7 @@ namespace ManifoldGardenArchipelago
                 return;
             }
 
-            if (active)
-            {
-                Plugin.slotSave.ActivatedSockets.Add(sir);
-            }
-            else
-            {
-                Plugin.slotSave.ActivatedSockets.Remove(sir);
-            }
+            Plugin.slotSave.ActivatedSockets[sir] = active;
 
             GameState.EvaluateGameStateListeners(listeners);
         }
@@ -90,15 +103,46 @@ namespace ManifoldGardenArchipelago
                 return;
             }
 
-            if (setActive)
+            Plugin.slotSave.ActivatedPads[sir] = setActive;
+
+            GameState.EvaluateGameStateListeners(listeners);
+        }
+    }
+
+    [HarmonyPatch(typeof(CubeLineActivator), "ForceActivatorToTurnOnAsCorrectCubeOnSwitch")]
+    static class CubeLineActivatorForceActivatorToTurnOnAsCorrectCubeOnSwitchPatch
+    {
+        static void Prefix(CubeLineActivator __instance)
+        {
+            SceneItemReference sir = GameState.GetPadSceneReference(__instance);
+            Plugin.Logger.LogInfo($"Pad {sir} forced on");
+
+            if (!GameData.listenersByPad.TryGetValue(sir, out GameStateListeners listeners))
             {
-                Plugin.slotSave.ActivatedPads.Add(sir);
+                return;
             }
-            else
+
+            Plugin.slotSave.ActivatedPads[sir] = true;
+
+            GameState.EvaluateGameStateListeners(listeners);
+        }
+    }
+
+    [HarmonyPatch(typeof(CubeLineActivator), "ForceActivatorToTurnOffAsCorrectCubeNotOnSwitch")]
+    static class CubeLineActivatorForceActivatorToTurnOffAsCorrectCubeNotOnSwitchPatch
+    {
+        static void Prefix(CubeLineActivator __instance)
+        {
+            SceneItemReference sir = GameState.GetPadSceneReference(__instance);
+            Plugin.Logger.LogInfo($"Pad {sir} forced off");
+
+            if (!GameData.listenersByPad.TryGetValue(sir, out GameStateListeners listeners))
             {
-                Plugin.slotSave.ActivatedPads.Remove(sir);
+                return;
             }
 
+            Plugin.slotSave.ActivatedPads[sir] = false;
+
             GameState.EvaluateGameStateListeners(listeners);
         }
     }
@@ -109,21 +153,14 @@ namespace ManifoldGardenArchipelago
         static void Prefix(WaterDetector __instance, bool setActive)
         {
             SceneItemReference sir = GameState.GetWaterwheelSceneReference(__instance);
-            Plugin.Logger.LogInfo($"Waterwheel {sir} state {setActive}");
+            //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);
-            }
+            Plugin.slotSave.ActivatedWaterwheels[sir] = setActive;
 
             GameState.EvaluateGameStateListeners(listeners);
         }
@@ -142,14 +179,7 @@ namespace ManifoldGardenArchipelago
                 return;
             }
 
-            if (newState == SphereController.State.AtDestination)
-            {
-                Plugin.slotSave.ActivatedSpheres.Add(sir);
-            }
-            else
-            {
-                Plugin.slotSave.ActivatedSpheres.Remove(sir);
-            }
+            Plugin.slotSave.ActivatedSpheres[sir] = (newState == SphereController.State.AtDestination);
 
             GameState.EvaluateGameStateListeners(listeners);
         }
@@ -166,10 +196,22 @@ namespace ManifoldGardenArchipelago
             {
                 if (sceneDescription.doors.TryGetValue(sir.index, out var requirement))
                 {
-                    FieldInfo fieldInfo = typeof(LineDoorController).GetField("doorShouldOpenImmediatelyOnEnable", BindingFlags.Instance | BindingFlags.NonPublic);
-                    fieldInfo.SetValue(__instance, requirement.Check());
+                    Requirement.Decision decision = requirement.Check();
+
+                    if (decision != Requirement.Decision.Maybe)
+                    {
+                        bool shouldOpen = (decision == Requirement.Decision.Yes);
+
+                        FieldInfo fieldInfo = typeof(LineDoorController).GetField("doorShouldOpenImmediatelyOnEnable", BindingFlags.Instance | BindingFlags.NonPublic);
+                        fieldInfo.SetValue(__instance, shouldOpen);
+
+                        FieldInfo animatorInfo = typeof(LineDoorController).GetField("m_animator", BindingFlags.Instance | BindingFlags.NonPublic);
+                        Animator animator = (Animator)animatorInfo.GetValue(__instance);
+
+                        AnimatorExt.PlayDoorStateThenDisable(animator, __instance.DoorOpenAnimationString, shouldOpen ? 1f : -1f, true);
 
-                    __instance.chains.Clear();
+                        __instance.chains.Clear();
+                    }
                 }
             }
         }
@@ -180,16 +222,32 @@ namespace ManifoldGardenArchipelago
     {
         static void Prefix(LineDoorController __instance)
         {
+            //Plugin.Logger.LogInfo("LineDoorControllerOnLoadPatch entered");
             SceneItemReference sir = GameState.GetChainListenerSceneReference(__instance);
+            //Plugin.Logger.LogInfo($"Got sir {sir}");
 
             if (GameData.scenes.TryGetValue(sir.scene, out var sceneDescription))
             {
+                //Plugin.Logger.LogInfo($"{sceneDescription.doors.Count} doors in scene");
                 if (sceneDescription.doors.TryGetValue(sir.index, out var requirement))
                 {
-                    FieldInfo fieldInfo = typeof(LineDoorController).GetField("doorShouldOpenImmediatelyOnEnable", BindingFlags.Instance | BindingFlags.NonPublic);
-                    fieldInfo.SetValue(__instance, requirement.Check());
+                    //Plugin.Logger.LogInfo($"Found req {requirement}");
+                    Requirement.Decision decision = requirement.Check();
+
+                    if (decision != Requirement.Decision.Maybe)
+                    {
+                        bool shouldOpen = (decision == Requirement.Decision.Yes);
+
+                        FieldInfo fieldInfo = typeof(LineDoorController).GetField("doorShouldOpenImmediatelyOnEnable", BindingFlags.Instance | BindingFlags.NonPublic);
+                        fieldInfo.SetValue(__instance, shouldOpen);
+
+                        FieldInfo animatorInfo = typeof(LineDoorController).GetField("m_animator", BindingFlags.Instance | BindingFlags.NonPublic);
+                        Animator animator = (Animator)animatorInfo.GetValue(__instance);
+
+                        AnimatorExt.PlayDoorStateThenDisable(animator, __instance.DoorOpenAnimationString, shouldOpen ? 1f : -1f, true);
 
-                    __instance.chains.Clear();
+                        __instance.chains.Clear();
+                    }
                 }
             }
         }
@@ -204,6 +262,7 @@ namespace ManifoldGardenArchipelago
 
             if (GameData.listenersByScene.TryGetValue(newLevel.levelName, out var listeners))
             {
+                Plugin.Logger.LogInfo($"Evaluating for scene {newLevel.levelName}");
                 GameState.EvaluateGameStateListeners(listeners);
             }
         }
@@ -227,7 +286,7 @@ namespace ManifoldGardenArchipelago
 
             if (GameData.scenes.TryGetValue(sir.scene, out var sceneDescription) &&
                 sceneDescription.worldGrows.TryGetValue(sir.index, out var requirement) &&
-                requirement.Check())
+                requirement.Check() == Requirement.Decision.Yes)
             {
                 FieldInfo fieldInfo = typeof(DarkModeCollapsedCubeWorldGrow).GetField("m_grown", BindingFlags.Instance | BindingFlags.NonPublic);
                 fieldInfo.SetValue(__instance, true);
@@ -235,6 +294,54 @@ namespace ManifoldGardenArchipelago
         }
     }
 
+    [HarmonyPatch(typeof(SolidStateController), nameof(SolidStateController.OnChainFillComplete))]
+    static class SolidStateControllerOnChainFillCompletePatch
+    {
+        static bool Prefix(SolidStateController __instance)
+        {
+            SceneItemReference sir = GameState.GetChainListenerSceneReference(__instance);
+
+            if (GameData.scenes.TryGetValue(sir.scene, out var sceneDescription))
+            {
+                if (sceneDescription.smokeWalls.TryGetValue(sir.index, out var requirement))
+                {
+                    Requirement.Decision decision = requirement.Check();
+
+                    if (decision == Requirement.Decision.No)
+                    {
+                        return false;
+                    }
+                }
+            }
+
+            return true;
+        }
+    }
+
+    [HarmonyPatch(typeof(SolidStateController), nameof(SolidStateController.OnUnfilled))]
+    static class SolidStateControllerOnUnfilledPatch
+    {
+        static bool Prefix(SolidStateController __instance)
+        {
+            SceneItemReference sir = GameState.GetChainListenerSceneReference(__instance);
+
+            if (GameData.scenes.TryGetValue(sir.scene, out var sceneDescription))
+            {
+                if (sceneDescription.smokeWalls.TryGetValue(sir.index, out var requirement))
+                {
+                    Requirement.Decision decision = requirement.Check();
+
+                    if (decision == Requirement.Decision.Yes)
+                    {
+                        return false;
+                    }
+                }
+            }
+
+            return true;
+        }
+    }
+
     [HarmonyPatch(typeof(DarkModeCollider), nameof(DarkModeCollider.OnLevelUpdate))]
     static class DarkModeColliderOnLevelUpdatePatch
     {