A bunch of things

- Requirement decisions now have three states: yes, no, and maybe. Maybe means that the state of the game object in question hasn't been detected yet, so acting on the event that checked the requirement should be deferred. This was intended to fix the inverted pad checks in Pyramid, but it does not seem to have worked. Questioning reverting this part.
- Fixed the doors in W018.
- Smoke walls now work, sort of. If the cube is still on the pad, loading the game in that room will cause the wall to close (leaving and re-entering the room dismisses it thought). Putting the cube back on the pad will also close it again. Need to fix later.
- More patches that record gameplay state without interaction from the player and call listeners for those objects. e.g. buttons getting pressed by the game when loaded in, as opposed to when pressed by the player. Pads have been tweaked like this too.
- When opening a door, the mod now also invokes the animator. This fixes the problem where doors would appear to be closed when re-entering a room, even though you could still walk through them.

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
     {