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.

7 files changed, 309 insertions, 97 deletions

@@ -87,6 +87,7 @@ namespace ManifoldGardenArchipelago
 
                     if (GameData.listenersByItem.TryGetValue(itemName, out var listeners))
                     {
+                        //Plugin.Logger.LogInfo($"Evaluating for {itemName}");
                         GameState.EvaluateGameStateListeners(listeners);
                     }
                 }
@@ -372,6 +372,8 @@ namespace ManifoldGardenArchipelago
                         Requirement req = ParseRequirement(scenePair.Key, (Dictionary<object, object>)smokePair.Value);
                         sceneDescription.smokeWalls[sir.index] = req;
 
+                        Plugin.Logger.LogInfo($"Smoke {sir} requirements: {req}");
+
                         foreach (var reqScene in req.references.scenes)
                         {
                             GetOrAddListeners(listenersByScene, reqScene).smokeWalls[sir] = req;
@@ -112,7 +112,7 @@ namespace ManifoldGardenArchipelago
         {
             foreach (var location in listeners.locations)
             {
-                if (location.Value.Check())
+                if (location.Value.Check() == Requirement.Decision.Yes)
                 {
                     Plugin.archipelagoManager.CheckLocation(location.Key);
                 }
@@ -120,8 +120,14 @@ namespace ManifoldGardenArchipelago
 
             foreach (var door in listeners.doors)
             {
-                bool shouldOpen = door.Value.Check();
-                Plugin.Logger.LogInfo($"{door.Key}: {door.Value} -> {shouldOpen}");
+                Requirement.Decision decision = door.Value.Check();
+                if (decision == Requirement.Decision.Maybe)
+                {
+                    continue;
+                }
+
+                bool shouldOpen = (decision == Requirement.Decision.Yes);
+                //Plugin.Logger.LogInfo($"{door.Key}: {door.Value} -> {shouldOpen}");
 
                 if (SceneManager.GetSceneByName(door.Key.scene) is Scene doorScene && doorScene.isLoaded)
                 {
@@ -142,11 +148,34 @@ namespace ManifoldGardenArchipelago
                 }
             }
 
+            foreach (var smokeWall in listeners.smokeWalls)
+            {
+                Requirement.Decision decision = smokeWall.Value.Check();
+                if (decision == Requirement.Decision.Maybe)
+                {
+                    continue;
+                }
+
+                bool shouldOpen = (decision == Requirement.Decision.Yes);
+                //Plugin.Logger.LogInfo($"{smokeWall.Key}: {smokeWall.Value} -> {shouldOpen}");
 
+                if (SceneManager.GetSceneByName(smokeWall.Key.scene) is Scene smokeScene && smokeScene.isLoaded)
+                {
+                    LevelSystems levelSystems = GetLevelSystems(smokeScene);
+                    if (levelSystems.isActiveAndEnabled)
+                    {
+                        SolidStateController ldc = levelSystems.chainListeners[smokeWall.Key.index].GetComponent<SolidStateController>();
+                        ldc.chains.Clear();
+
+                        FieldInfo fieldInfo = typeof(SolidStateController).GetField("m_isSolid", BindingFlags.Instance | BindingFlags.NonPublic);
+                        fieldInfo.SetValue(ldc, !shouldOpen);
+                    }
+                }
+            }
 
             foreach (var worldGrow in listeners.worldGrows)
             {
-                if (worldGrow.Value.Check())
+                if (worldGrow.Value.Check() == Requirement.Decision.Yes)
                 {
                     if (SceneManager.GetSceneByName(worldGrow.Key.scene) is Scene gardenScene && gardenScene.isLoaded)
                     {
@@ -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
     {
@@ -50,9 +50,16 @@ namespace ManifoldGardenArchipelago
 
     public abstract class Requirement
     {
+        public enum Decision
+        {
+            Maybe,
+            No,
+            Yes,
+        }
+
         public RequirementReferences references = new();
 
-        public abstract bool Check();
+        public abstract Decision Check();
     }
 
     public class AndRequirement : Requirement
@@ -69,9 +76,19 @@ namespace ManifoldGardenArchipelago
             }
         }
 
-        public override bool Check()
+        public override Decision Check()
         {
-            return _requirements.All(x => x.Check());
+            foreach (var requirement in _requirements)
+            {
+                Decision decision = requirement.Check();
+
+                if (decision != Decision.Yes)
+                {
+                    return decision;
+                }
+            }
+
+            return Decision.Yes;
         }
 
         public override string ToString()
@@ -94,9 +111,19 @@ namespace ManifoldGardenArchipelago
             }
         }
 
-        public override bool Check()
+        public override Decision Check()
         {
-            return _requirements.Any(x => x.Check());
+            foreach (var requirement in _requirements)
+            {
+                Decision decision = requirement.Check();
+
+                if (decision != Decision.No)
+                {
+                    return decision;
+                }
+            }
+
+            return Decision.No;
         }
 
         public override string ToString()
@@ -116,9 +143,9 @@ namespace ManifoldGardenArchipelago
             references.items.Add(itemName);
         }
 
-        public override bool Check()
+        public override Decision Check()
         {
-            return Plugin.archipelagoManager.HasItem(_itemName);
+            return Plugin.archipelagoManager.HasItem(_itemName) ? Decision.Yes : Decision.No;
         }
 
         public override string ToString()
@@ -138,9 +165,9 @@ namespace ManifoldGardenArchipelago
             references.scenes.Add(sceneName);
         }
 
-        public override bool Check()
+        public override Decision Check()
         {
-            return Plugin.slotSave.VisitedScenes.Contains(_sceneName);
+            return Plugin.slotSave.VisitedScenes.Contains(_sceneName) ? Decision.Yes : Decision.No;
         }
 
         public override string ToString()
@@ -161,9 +188,16 @@ namespace ManifoldGardenArchipelago
             references.buttons.Add(button);
         }
 
-        public override bool Check()
+        public override Decision Check()
         {
-            return Plugin.slotSave.ActivatedButtons.Contains(_button);
+            if (Plugin.slotSave.ActivatedButtons.TryGetValue(_button, out bool value))
+            {
+                return value ? Decision.Yes : Decision.No;
+            }
+            else
+            {
+                return Decision.Maybe;
+            }
         }
 
         public override string ToString()
@@ -184,9 +218,16 @@ namespace ManifoldGardenArchipelago
             references.sockets.Add(socket);
         }
 
-        public override bool Check()
+        public override Decision Check()
         {
-            return Plugin.slotSave.ActivatedSockets.Contains(_socket);
+            if (Plugin.slotSave.ActivatedSockets.TryGetValue(_socket, out bool value))
+            {
+                return value ? Decision.Yes : Decision.No;
+            }
+            else
+            {
+                return Decision.Maybe;
+            }
         }
 
         public override string ToString()
@@ -207,9 +248,16 @@ namespace ManifoldGardenArchipelago
             references.pads.Add(pad);
         }
 
-        public override bool Check()
+        public override Decision Check()
         {
-            return Plugin.slotSave.ActivatedPads.Contains(_pad);
+            if (Plugin.slotSave.ActivatedPads.TryGetValue(_pad, out bool value))
+            {
+                return value ? Decision.Yes : Decision.No;
+            }
+            else
+            {
+                return Decision.Maybe;
+            }
         }
 
         public override string ToString()
@@ -230,9 +278,16 @@ namespace ManifoldGardenArchipelago
             references.waterwheels.Add(waterwheel);
         }
 
-        public override bool Check()
+        public override Decision Check()
         {
-            return Plugin.slotSave.ActivatedWaterwheels.Contains(_waterwheel);
+            if (Plugin.slotSave.ActivatedWaterwheels.TryGetValue(_waterwheel, out bool value))
+            {
+                return value ? Decision.Yes : Decision.No;
+            }
+            else
+            {
+                return Decision.Maybe;
+            }
         }
 
         public override string ToString()
@@ -253,9 +308,16 @@ namespace ManifoldGardenArchipelago
             references.spheres.Add(sphere);
         }
 
-        public override bool Check()
+        public override Decision Check()
         {
-            return Plugin.slotSave.ActivatedSpheres.Contains(_sphere);
+            if (Plugin.slotSave.ActivatedSpheres.TryGetValue(_sphere, out bool value))
+            {
+                return value ? Decision.Yes : Decision.No;
+            }
+            else
+            {
+                return Decision.Maybe;
+            }
         }
 
         public override string ToString()
@@ -275,9 +337,22 @@ namespace ManifoldGardenArchipelago
             references = requirement.references;
         }
 
-        public override bool Check()
+        public override Decision Check()
         {
-            return !_requirement.Check();
+            Decision subdec = _requirement.Check();
+
+            if (subdec == Decision.Yes)
+            {
+                return Decision.No;
+            }
+            else if (subdec == Decision.No)
+            {
+                return Decision.Yes;
+            }
+            else
+            {
+                return Decision.Maybe;
+            }
         }
 
         public override string ToString()
@@ -1,18 +1,14 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
+using System.Collections.Generic;
 
 namespace ManifoldGardenArchipelago
 {
     public class SlotSave
     {
         public readonly HashSet<string> VisitedScenes = [];
-        public readonly HashSet<SceneItemReference> ActivatedButtons = [];
-        public readonly HashSet<SceneItemReference> ActivatedSockets = [];
-        public readonly HashSet<SceneItemReference> ActivatedPads = [];
-        public readonly HashSet<SceneItemReference> ActivatedWaterwheels = [];
-        public readonly HashSet<SceneItemReference> ActivatedSpheres = [];
+        public readonly Dictionary<SceneItemReference, bool> ActivatedButtons = [];
+        public readonly Dictionary<SceneItemReference, bool> ActivatedSockets = [];
+        public readonly Dictionary<SceneItemReference, bool> ActivatedPads = [];
+        public readonly Dictionary<SceneItemReference, bool> ActivatedWaterwheels = [];
+        public readonly Dictionary<SceneItemReference, bool> ActivatedSpheres = [];
     }
 }
@@ -274,24 +274,25 @@ World_612_BlindSpherePuzzle_Optimized:
             scene: Hallway_W612_W057_Optimized
             index: 0
 World_018_PastaTile_Optimized:
-  0:
-    or:
-      - button: 0
-      - pad: 0
-  3:
-    or:
-      - pad: 0
-      - sphere:
-          scene: Hallway_W018_W003B_Optimized
-          index: 0
-  5:
-    or:
-      - button: 1
-      - button:
-          - scene: Hallway_W018_W063_Optimized
-            index: 0
-          - scene: Hallway_W018_W063_Optimized
-            index: 1
+  doors:
+    0:
+      or:
+        - button: 0
+        - pad: 0
+    3:
+      or:
+        - pad: 0
+        - sphere:
+            scene: Hallway_W018_W003B_Optimized
+            index: 0
+    5:
+      or:
+        - button: 1
+        - button:
+            - scene: Hallway_W018_W063_Optimized
+              index: 0
+            - scene: Hallway_W018_W063_Optimized
+              index: 1
 Hallway_W018_W003B_Optimized:
   locations:
     Mini Sphere Puzzle Solved:
@@ -559,6 +560,7 @@ World_026_Library_Optimized:
   smoke:
     3:
       item: Library - Yellow Smoke Wall
+      entry: World_026_Library_Optimized
 Hallway_W026_W002_Optimized:
   locations:
     Yellow Cube Fetch Quest Completed: