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: