Mapped out most of the game

9 files changed, 1913 insertions, 98 deletions

@@ -4,12 +4,7 @@ using Archipelago.MultiClient.Net.Models;
 using Archipelago.MultiClient.Net.Packets;
 using System;
 using System.Collections.Generic;
-using System.Linq;
-using System.Reflection;
-using System.Text;
 using System.Threading.Tasks;
-using UnityEngine.SceneManagement;
-using static ManifoldGardenArchipelago.GameData;
 
 namespace ManifoldGardenArchipelago
 {
@@ -18,24 +13,8 @@ namespace ManifoldGardenArchipelago
         private ArchipelagoSession _session;
         private int _itemIndex = 0;
 
-        public Dictionary<string, Dictionary<int, bool>> chainListenersByScene = new();
-
-        public ArchipelagoManager()
-        {
-            foreach (var item in GameData.door_by_item)
-            {
-                foreach (var chainListenerReference in item.Value)
-                {
-                    if (!chainListenersByScene.TryGetValue(chainListenerReference.scene, out var listenersInScene))
-                    {
-                        listenersInScene = [];
-                        chainListenersByScene.Add(chainListenerReference.scene, listenersInScene);
-                    }
-
-                    listenersInScene[chainListenerReference.index] = false;
-                }
-            }
-        }
+        private HashSet<string> _items = [];
+        private HashSet<string> _locations = [];
 
         public async Task<LoginResult> Connect(string url, string slotName, string password)
         {
@@ -72,6 +51,23 @@ namespace ManifoldGardenArchipelago
             _session = null;
         }
 
+        public bool HasItem(string itemName)
+        {
+            return _items.Contains(itemName);
+        }
+
+        public void CheckLocation(string locationName)
+        {
+            if (_locations.Contains(locationName))
+            {
+                return;
+            }
+
+            _locations.Add(locationName);
+
+            _session.Locations.CompleteLocationChecks(_session.Locations.GetLocationIdFromName("Manifold Garden", locationName));
+        }
+
         public void Update()
         {
             if (_session == null)
@@ -85,29 +81,13 @@ namespace ManifoldGardenArchipelago
                 {
                     ItemInfo item = _session.Items.AllItemsReceived[i];
                     string itemName = item.ItemName;
+                    Plugin.Logger.LogInfo($"Received {itemName}");
+
+                    _items.Add(itemName);
 
-                    if (GameData.door_by_item.TryGetValue(itemName, out List<GameData.ChainListenerReference> door))
+                    if (GameData.listenersByItem.TryGetValue(itemName, out var listeners))
                     {
-                        foreach (GameData.ChainListenerReference chainListenerReference in door)
-                        {
-                            chainListenersByScene[chainListenerReference.scene][chainListenerReference.index] = true;
-
-                            if (SceneManager.GetSceneByName(chainListenerReference.scene) is Scene doorScene && doorScene.isLoaded)
-                            {
-                                LevelSystems levelSystems = doorScene.GetRootGameObjects().Single((obj) => obj.name == "Level Systems").GetComponent<LevelSystems>();
-                                if (levelSystems.isActiveAndEnabled)
-                                {
-                                    LineDoorController ldc = levelSystems.chainListeners[chainListenerReference.index].GetComponent<LineDoorController>();
-                                    ldc.chains.Clear();
-                                    
-                                    FieldInfo fieldInfo = typeof(LineDoorController).GetField("doorShouldOpenImmediatelyOnEnable", BindingFlags.Instance | BindingFlags.NonPublic);
-                                    fieldInfo.SetValue(ldc, true);
-
-                                    MethodInfo methodInfo = typeof(LineDoorController).GetMethod("SetDoorOpenCloseStateAnimated", BindingFlags.NonPublic | BindingFlags.Instance);
-                                    methodInfo.Invoke(ldc, [true, false]);
-                                }
-                            }
-                        }
+                        GameState.EvaluateGameStateListeners(listeners);
                     }
                 }
 
@@ -1,18 +1,446 @@
 using System.Collections.Generic;
+using System.IO;
+using YamlDotNet.Serialization;
 
 namespace ManifoldGardenArchipelago
 {
-    public class GameData
+    public readonly struct SceneItemReference(string scene_arg, int index_arg)
     {
-        public readonly struct ChainListenerReference(string scene_arg, int index_arg)
+        public readonly string scene = scene_arg;
+        public readonly int index = index_arg;
+
+        public override string ToString()
+        {
+            return $"({scene}, {index})";
+        }
+    }
+
+    public readonly struct LocationDescription(string name_arg, Requirement requirement_arg)
+    {
+        public readonly string name = name_arg;
+        public readonly Requirement requirement = requirement_arg;
+    }
+
+    public class SceneDescription
+    {
+        public readonly List<LocationDescription> locations = [];
+        public readonly Dictionary<int, Requirement> doors = [];
+        public readonly Dictionary<int, Requirement> smokeWalls = [];
+        public readonly Dictionary<int, Requirement> worldGrows = [];
+    }
+
+    public class GameStateListeners
+    {
+        public readonly Dictionary<string, Requirement> locations = [];
+        public readonly Dictionary<SceneItemReference, Requirement> doors = [];
+        public readonly Dictionary<SceneItemReference, Requirement> smokeWalls = [];
+        public readonly Dictionary<SceneItemReference, Requirement> worldGrows = [];
+    }
+
+    public static class GameData
+    {
+        public static readonly Dictionary<string, SceneDescription> scenes = [];
+
+        public static readonly Dictionary<string, GameStateListeners> listenersByScene = [];
+        public static readonly Dictionary<SceneItemReference, GameStateListeners> listenersByButton = [];
+        public static readonly Dictionary<SceneItemReference, GameStateListeners> listenersBySocket = [];
+        public static readonly Dictionary<SceneItemReference, GameStateListeners> listenersByPad = [];
+        public static readonly Dictionary<SceneItemReference, GameStateListeners> listenersByWaterwheel = [];
+        public static readonly Dictionary<SceneItemReference, GameStateListeners> listenersBySphere = [];
+        public static readonly Dictionary<string, GameStateListeners> listenersByItem = [];
+
+        public static Requirement ParseRequirement(string scene, Dictionary<object, object> yamlReq)
+        {
+            List<Requirement> reqs = [];
+
+            if (yamlReq.ContainsKey("item"))
+            {
+                if (yamlReq["item"] is string itemName)
+                {
+                    reqs.Add(new ItemRequirement(itemName));
+                }
+                else if (yamlReq["item"] is List<string> items)
+                {
+                    foreach (var item in items)
+                    {
+                        reqs.Add(new ItemRequirement(item));
+                    }
+                }
+            }
+
+            if (yamlReq.ContainsKey("button"))
+            {
+                if (yamlReq["button"] is string index)
+                {
+                    reqs.Add(new ButtonRequirement(new(scene, int.Parse(index))));
+                }
+                else if (yamlReq["button"] is Dictionary<object, object> details)
+                {
+                    reqs.Add(new ButtonRequirement(new((string)details["scene"], int.Parse((string)details["index"]))));
+                }
+                else if (yamlReq["button"] is List<object> buttons)
+                {
+                    foreach (var button in buttons)
+                    {
+                        if (button is string index2)
+                        {
+                            reqs.Add(new ButtonRequirement(new(scene, int.Parse(index2))));
+                        }
+                        else if (button is Dictionary<object, object> details2)
+                        {
+                            reqs.Add(new ButtonRequirement(new((string)details2["scene"], int.Parse((string)details2["index"]))));
+                        }
+                    }
+                }
+            }
+
+            if (yamlReq.ContainsKey("socket"))
+            {
+                if (yamlReq["socket"] is string index)
+                {
+                    reqs.Add(new SocketRequirement(new(scene, int.Parse(index))));
+                }
+                else if (yamlReq["socket"] is Dictionary<object, object> details)
+                {
+                    reqs.Add(new SocketRequirement(new((string)details["scene"], int.Parse((string)details["index"]))));
+                }
+                else if (yamlReq["socket"] is List<object> buttons)
+                {
+                    foreach (var button in buttons)
+                    {
+                        if (button is string index2)
+                        {
+                            reqs.Add(new SocketRequirement(new(scene, int.Parse(index2))));
+                        }
+                        else if (button is Dictionary<object, object> details2)
+                        {
+                            reqs.Add(new SocketRequirement(new((string)details2["scene"], int.Parse((string)details2["index"]))));
+                        }
+                    }
+                }
+            }
+
+            if (yamlReq.ContainsKey("pad"))
+            {
+                if (yamlReq["pad"] is string index)
+                {
+                    reqs.Add(new PadRequirement(new(scene, int.Parse(index))));
+                }
+                else if (yamlReq["pad"] is Dictionary<object, object> details)
+                {
+                    reqs.Add(new PadRequirement(new((string)details["scene"], int.Parse((string)details["index"]))));
+                }
+                else if (yamlReq["pad"] is List<object> buttons)
+                {
+                    foreach (var button in buttons)
+                    {
+                        if (button is string index2)
+                        {
+                            reqs.Add(new PadRequirement(new(scene, int.Parse(index2))));
+                        }
+                        else if (button is Dictionary<object, object> details2)
+                        {
+                            reqs.Add(new PadRequirement(new((string)details2["scene"], int.Parse((string)details2["index"]))));
+                        }
+                    }
+                }
+            }
+
+            if (yamlReq.ContainsKey("waterwheel"))
+            {
+                if (yamlReq["waterwheel"] is string index)
+                {
+                    reqs.Add(new WaterwheelRequirement(new(scene, int.Parse(index))));
+                }
+                else if (yamlReq["waterwheel"] is Dictionary<object, object> details)
+                {
+                    reqs.Add(new WaterwheelRequirement(new((string)details["scene"], int.Parse((string)details["index"]))));
+                }
+                else if (yamlReq["waterwheel"] is List<object> buttons)
+                {
+                    foreach (var button in buttons)
+                    {
+                        if (button is string index2)
+                        {
+                            reqs.Add(new WaterwheelRequirement(new(scene, int.Parse(index2))));
+                        }
+                        else if (button is Dictionary<object, object> details2)
+                        {
+                            reqs.Add(new WaterwheelRequirement(new((string)details2["scene"], int.Parse((string)details2["index"]))));
+                        }
+                    }
+                }
+            }
+
+            if (yamlReq.ContainsKey("sphere"))
+            {
+                if (yamlReq["sphere"] is string index)
+                {
+                    reqs.Add(new SphereRequirement(new(scene, int.Parse(index))));
+                }
+                else if (yamlReq["sphere"] is Dictionary<object, object> details)
+                {
+                    reqs.Add(new SphereRequirement(new((string)details["scene"], int.Parse((string)details["index"]))));
+                }
+                else if (yamlReq["sphere"] is List<object> buttons)
+                {
+                    foreach (var button in buttons)
+                    {
+                        if (button is string index2)
+                        {
+                            reqs.Add(new SphereRequirement(new(scene, int.Parse(index2))));
+                        }
+                        else if (button is Dictionary<object, object> details2)
+                        {
+                            reqs.Add(new SphereRequirement(new((string)details2["scene"], int.Parse((string)details2["index"]))));
+                        }
+                    }
+                }
+            }
+
+            if (yamlReq.ContainsKey("or"))
+            {
+                List<Requirement> unionReq = [];
+
+                foreach (var reqObj in (List<object>)yamlReq["or"])
+                {
+                    unionReq.Add(ParseRequirement(scene, (Dictionary<object, object>)reqObj));
+                }
+
+                reqs.Add(new OrRequirement(unionReq));
+            }
+
+            if (yamlReq.ContainsKey("inverted"))
+            {
+                reqs.Add(new InvertedRequirement(ParseRequirement(scene, (Dictionary<object, object>)yamlReq["inverted"])));
+            }
+
+            if (reqs.Count == 1)
+            {
+                return reqs[0];
+            }
+            else
+            {
+                return new AndRequirement(reqs);
+            }
+        }
+
+        private static GameStateListeners GetOrAddListeners<T>(Dictionary<T, GameStateListeners> kvp, T key)
         {
-            public readonly string scene = scene_arg;
-            public readonly int index = index_arg;
+            if (!kvp.TryGetValue(key, out GameStateListeners listeners))
+            {
+                listeners = new();
+                kvp[key] = listeners;
+            }
+
+            return listeners;
         }
 
-        public static readonly Dictionary<string, List<ChainListenerReference>> door_by_item = new()
+        public static void Load()
         {
-            {"Blue Secret Path", [new ChainListenerReference("World_000_Optimized", 16)] }
-        };
+            Plugin.Logger.LogInfo(Path.Combine(BepInEx.Paths.BepInExRootPath, "plugins", "game_data.yaml"));
+            var yamlText = File.OpenText(Path.Combine(BepInEx.Paths.BepInExRootPath, "plugins", "game_data.yaml"));
+
+            var deserializer = new DeserializerBuilder().Build();
+            var yamlObject = deserializer.Deserialize<Dictionary<string, object>>(yamlText);
+
+            foreach (var scenePair in yamlObject)
+            {
+                Plugin.Logger.LogInfo($"Scene: {scenePair.Key}");
+                SceneDescription sceneDescription = new();
+
+                var sceneDetails = (Dictionary<object, object>)scenePair.Value;
+
+                if (sceneDetails.ContainsKey("locations"))
+                {
+                    var sceneLocations = (Dictionary<object, object>)sceneDetails["locations"];
+
+                    foreach (var locationPair in sceneLocations)
+                    {
+                        string locationName = (string)locationPair.Key;
+                        Requirement req = ParseRequirement(scenePair.Key, (Dictionary<object, object>)locationPair.Value);
+                        sceneDescription.locations.Add(new(locationName, req));
+
+                        Plugin.Logger.LogInfo($"{locationName} requirements: {req}");
+
+                        foreach (var reqScene in req.references.scenes)
+                        {
+                            GetOrAddListeners(listenersByScene, reqScene).locations[locationName] = req;
+                        }
+
+                        foreach (var button in req.references.buttons)
+                        {
+                            GetOrAddListeners(listenersByButton, button).locations[locationName] = req;
+                        }
+
+                        foreach (var socket in req.references.sockets)
+                        {
+                            GetOrAddListeners(listenersBySocket, socket).locations[locationName] = req;
+                        }
+
+                        foreach (var pad in req.references.pads)
+                        {
+                            GetOrAddListeners(listenersByPad, pad).locations[locationName] = req;
+                        }
+
+                        foreach (var waterwheel in req.references.waterwheels)
+                        {
+                            GetOrAddListeners(listenersByWaterwheel, waterwheel).locations[locationName] = req;
+                        }
+
+                        foreach (var sphere in req.references.spheres)
+                        {
+                            GetOrAddListeners(listenersBySphere, sphere).locations[locationName] = req;
+                        }
+
+                        foreach (var item in req.references.items)
+                        {
+                            GetOrAddListeners(listenersByItem, item).locations[locationName] = req;
+                        }
+                    }
+                }
+                
+                if (sceneDetails.ContainsKey("doors"))
+                {
+                    var sceneDoors = (Dictionary<object, object>)sceneDetails["doors"];
+
+                    foreach (var doorPair in sceneDoors)
+                    {
+                        SceneItemReference sir = new(scenePair.Key, int.Parse((string)doorPair.Key));
+                        Requirement req = ParseRequirement(scenePair.Key, (Dictionary<object, object>)doorPair.Value);
+                        sceneDescription.doors[sir.index] = req;
+
+                        Plugin.Logger.LogInfo($"Door {sir} requirements: {req}");
+
+                        foreach (var reqScene in req.references.scenes)
+                        {
+                            GetOrAddListeners(listenersByScene, reqScene).doors[sir] = req;
+                        }
+
+                        foreach (var button in req.references.buttons)
+                        {
+                            GetOrAddListeners(listenersByButton, button).doors[sir] = req;
+                        }
+
+                        foreach (var socket in req.references.sockets)
+                        {
+                            GetOrAddListeners(listenersBySocket, socket).doors[sir] = req;
+                        }
+
+                        foreach (var pad in req.references.pads)
+                        {
+                            GetOrAddListeners(listenersByPad, pad).doors[sir] = req;
+                        }
+
+                        foreach (var waterwheel in req.references.waterwheels)
+                        {
+                            GetOrAddListeners(listenersByWaterwheel, waterwheel).doors[sir] = req;
+                        }
+
+                        foreach (var sphere in req.references.spheres)
+                        {
+                            GetOrAddListeners(listenersBySphere, sphere).doors[sir] = req;
+                        }
+
+                        foreach (var item in req.references.items)
+                        {
+                            GetOrAddListeners(listenersByItem, item).doors[sir] = req;
+                        }
+                    }
+                }
+
+                if (sceneDetails.ContainsKey("smoke"))
+                {
+                    foreach (var smokePair in (Dictionary<object, object>)sceneDetails["smoke"])
+                    {
+                        SceneItemReference sir = new(scenePair.Key, int.Parse((string)smokePair.Key));
+                        Requirement req = ParseRequirement(scenePair.Key, (Dictionary<object, object>)smokePair.Value);
+                        sceneDescription.smokeWalls[sir.index] = req;
+
+                        foreach (var reqScene in req.references.scenes)
+                        {
+                            GetOrAddListeners(listenersByScene, reqScene).smokeWalls[sir] = req;
+                        }
+
+                        foreach (var button in req.references.buttons)
+                        {
+                            GetOrAddListeners(listenersByButton, button).smokeWalls[sir] = req;
+                        }
+
+                        foreach (var socket in req.references.sockets)
+                        {
+                            GetOrAddListeners(listenersBySocket, socket).smokeWalls[sir] = req;
+                        }
+
+                        foreach (var pad in req.references.pads)
+                        {
+                            GetOrAddListeners(listenersByPad, pad).smokeWalls[sir] = req;
+                        }
+
+                        foreach (var waterwheel in req.references.waterwheels)
+                        {
+                            GetOrAddListeners(listenersByWaterwheel, waterwheel).smokeWalls[sir] = req;
+                        }
+
+                        foreach (var sphere in req.references.spheres)
+                        {
+                            GetOrAddListeners(listenersBySphere, sphere).smokeWalls[sir] = req;
+                        }
+
+                        foreach (var item in req.references.items)
+                        {
+                            GetOrAddListeners(listenersByItem, item).smokeWalls[sir] = req;
+                        }
+                    }
+                }
+
+                if (sceneDetails.ContainsKey("world_grow"))
+                {
+                    foreach (var worldPair in (Dictionary<object, object>)sceneDetails["world_grow"])
+                    {
+                        SceneItemReference sir = new(scenePair.Key, int.Parse((string)worldPair.Key));
+                        Requirement req = ParseRequirement(scenePair.Key, (Dictionary<object, object>)worldPair.Value);
+                        sceneDescription.worldGrows[sir.index] = req;
+
+                        foreach (var reqScene in req.references.scenes)
+                        {
+                            GetOrAddListeners(listenersByScene, reqScene).worldGrows[sir] = req;
+                        }
+
+                        foreach (var button in req.references.buttons)
+                        {
+                            GetOrAddListeners(listenersByButton, button).worldGrows[sir] = req;
+                        }
+
+                        foreach (var socket in req.references.sockets)
+                        {
+                            GetOrAddListeners(listenersBySocket, socket).worldGrows[sir] = req;
+                        }
+
+                        foreach (var pad in req.references.pads)
+                        {
+                            GetOrAddListeners(listenersByPad, pad).worldGrows[sir] = req;
+                        }
+
+                        foreach (var waterwheel in req.references.waterwheels)
+                        {
+                            GetOrAddListeners(listenersByWaterwheel, waterwheel).worldGrows[sir] = req;
+                        }
+
+                        foreach (var sphere in req.references.spheres)
+                        {
+                            GetOrAddListeners(listenersBySphere, sphere).worldGrows[sir] = req;
+                        }
+
+                        foreach (var item in req.references.items)
+                        {
+                            GetOrAddListeners(listenersByItem, item).worldGrows[sir] = req;
+                        }
+                    }
+                }
+
+                scenes[scenePair.Key] = sceneDescription;
+            }
+        }
     }
 }
@@ -0,0 +1,167 @@
+using System;
+using System.Linq;
+using System.Reflection;
+using UnityEngine;
+using UnityEngine.SceneManagement;
+
+namespace ManifoldGardenArchipelago
+{
+    public class GameState
+    {
+        public static LevelSystems GetLevelSystems(Component component)
+        {
+            return component.gameObject.scene.GetRootGameObjects().Single((obj) => obj.name == "Level Systems").GetComponent<LevelSystems>();
+        }
+
+        public static LevelSystems GetLevelSystems(Scene scene)
+        {
+            return scene.GetRootGameObjects().Single((obj) => obj.name == "Level Systems").GetComponent<LevelSystems>();
+        }
+
+        public static SceneItemReference GetChainListenerSceneReference(Component component)
+        {
+            LevelSystems levelSystem = GetLevelSystems(component);
+
+            for (int i = 0; i < levelSystem.chainListeners.Count(); i++)
+            {
+                if (levelSystem.chainListeners[i] == component)
+                {
+                    return new(component.gameObject.scene.name, i);
+                }
+            }
+
+            throw new Exception("Shouldn't happen");
+        }
+
+        public static SceneItemReference GetButtonSceneReference(ButtonLineActivator arg)
+        {
+            LevelSystems levelSystem = GetLevelSystems(arg);
+
+            for (int i = 0; i < levelSystem.buttonLineActivators.Count(); i++)
+            {
+                if (levelSystem.buttonLineActivators[i] == arg)
+                {
+                    return new(arg.gameObject.scene.name, i);
+                }
+            }
+
+            throw new Exception("Shouldn't happen");
+        }
+
+        public static SceneItemReference GetPadSceneReference(CubeLineActivator arg)
+        {
+            LevelSystems levelSystem = GetLevelSystems(arg);
+
+            for (int i = 0; i < levelSystem.cubeLineActivators.Count(); i++)
+            {
+                if (levelSystem.cubeLineActivators[i] == arg)
+                {
+                    return new(arg.gameObject.scene.name, i);
+                }
+            }
+
+            throw new Exception("Shouldn't happen");
+        }
+
+        public static SceneItemReference GetSocketSceneReference(CubeReceiverController arg)
+        {
+            LevelSystems levelSystem = GetLevelSystems(arg);
+
+            for (int i = 0; i < levelSystem.cubeReceiverControllers.Count(); i++)
+            {
+                if (levelSystem.cubeReceiverControllers[i] == arg)
+                {
+                    return new(arg.gameObject.scene.name, i);
+                }
+            }
+
+            throw new Exception("Shouldn't happen");
+        }
+
+        public static SceneItemReference GetSphereSceneReference(SphereController arg)
+        {
+            LevelSystems levelSystem = GetLevelSystems(arg);
+
+            for (int i = 0; i < levelSystem.sphereControllers.Count(); i++)
+            {
+                if (levelSystem.sphereControllers[i] == arg)
+                {
+                    return new(arg.gameObject.scene.name, i);
+                }
+            }
+
+            throw new Exception("Shouldn't happen");
+        }
+
+        public static SceneItemReference GetWaterwheelSceneReference(WaterDetector arg)
+        {
+            LevelSystems levelSystem = GetLevelSystems(arg);
+
+            for (int i = 0; i < levelSystem.waterDetectors.Count(); i++)
+            {
+                if (levelSystem.waterDetectors[i] == arg)
+                {
+                    return new(arg.gameObject.scene.name, i);
+                }
+            }
+
+            throw new Exception("Shouldn't happen");
+        }
+
+        public static void EvaluateGameStateListeners(GameStateListeners listeners)
+        {
+            foreach (var location in listeners.locations)
+            {
+                if (location.Value.Check())
+                {
+                    Plugin.archipelagoManager.CheckLocation(location.Key);
+                }
+            }
+
+            foreach (var door in listeners.doors)
+            {
+                bool shouldOpen = door.Value.Check();
+                Plugin.Logger.LogInfo($"{door.Key}: {door.Value} -> {shouldOpen}");
+
+                if (SceneManager.GetSceneByName(door.Key.scene) is Scene doorScene && doorScene.isLoaded)
+                {
+                    LevelSystems levelSystems = GetLevelSystems(doorScene);
+                    if (levelSystems.isActiveAndEnabled)
+                    {
+                        LineDoorController ldc = levelSystems.chainListeners[door.Key.index].GetComponent<LineDoorController>();
+                        ldc.chains.Clear();
+
+                        FieldInfo fieldInfo = typeof(LineDoorController).GetField("doorShouldOpenImmediatelyOnEnable", BindingFlags.Instance | BindingFlags.NonPublic);
+                        fieldInfo.SetValue(ldc, shouldOpen);
+
+                        MethodInfo methodInfo = typeof(LineDoorController).GetMethod("SetDoorOpenCloseStateAnimated", BindingFlags.NonPublic | BindingFlags.Instance);
+                        methodInfo.Invoke(ldc, [shouldOpen, false]);
+
+                        ldc.saveData.isOpen = shouldOpen;
+                    }
+                }
+            }
+
+
+
+            foreach (var worldGrow in listeners.worldGrows)
+            {
+                if (worldGrow.Value.Check())
+                {
+                    if (SceneManager.GetSceneByName(worldGrow.Key.scene) is Scene gardenScene && gardenScene.isLoaded)
+                    {
+                        LevelSystems levelSystems = GetLevelSystems(gardenScene);
+                        if (levelSystems.isActiveAndEnabled)
+                        {
+                            DarkModeCollapsedCubeWorldGrow ldc = levelSystems.chainListeners[worldGrow.Key.index].GetComponent<DarkModeCollapsedCubeWorldGrow>();
+                            ldc.chains.Clear();
+
+                            FieldInfo fieldInfo = typeof(DarkModeCollapsedCubeWorldGrow).GetField("m_grown", BindingFlags.Instance | BindingFlags.NonPublic);
+                            fieldInfo.SetValue(ldc, true);
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
@@ -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);
+            }
+        }
+    }
+}
@@ -25,6 +25,7 @@
     <PackageReference Include="BepInEx.Core" Version="5.*" />
     <PackageReference Include="BepInEx.PluginInfoProps" Version="2.*" />
     <PackageReference Include="UnityEngine.Modules" Version="2019.3.15" IncludeAssets="compile" />
+    <PackageReference Include="YamlDotNet" Version="13.7.1" />
   </ItemGroup>
   
   <ItemGroup Condition="'$(TargetFramework.TrimEnd(`0123456789`))' == 'net'">
@@ -36,4 +37,10 @@
       <HintPath>D:\SteamLibrary\steamapps\common\Manifold Garden\ManifoldGarden_Data\Managed\Assembly-CSharp.dll</HintPath>
     </Reference>
   </ItemGroup>
+  
+  <ItemGroup>
+    <None Update="game_data.yaml">
+      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
+    </None>
+  </ItemGroup>
 </Project>
@@ -1,7 +1,6 @@
 using BepInEx;
 using BepInEx.Logging;
 using HarmonyLib;
-using System.Linq;
 using System.Reflection;
 
 namespace ManifoldGardenArchipelago
@@ -12,6 +11,7 @@ namespace ManifoldGardenArchipelago
         internal static new ManualLogSource Logger;
 
         public static ArchipelagoManager archipelagoManager = new();
+        public static SlotSave slotSave = new();
 
         private void Awake()
         {
@@ -21,6 +21,7 @@ namespace ManifoldGardenArchipelago
 
             Harmony.CreateAndPatchAll(Assembly.GetExecutingAssembly());
 
+            GameData.Load();
             archipelagoManager.Connect("localhost:38281", "Manifold", "").RunSynchronously();
         }
     }
@@ -34,52 +35,6 @@ namespace ManifoldGardenArchipelago
         }
     }
 
-    [HarmonyPatch(typeof(LineDoorController), "SetDoorOpenCloseStateAnimated")]
-    static class LineDoorControllerSetDoorOpenCloseStateAnimatedPatch
-    {
-        static bool Prefix(LineDoorController __instance, bool open)
-        {
-            if (Plugin.archipelagoManager.chainListenersByScene.TryGetValue(__instance.gameObject.scene.name, out var activatedChainListeners))
-            {
-                LevelSystems levelSystem = __instance.gameObject.scene.GetRootGameObjects().Single((obj) => obj.name == "Level Systems").GetComponent<LevelSystems>();
-
-                foreach (var listener in activatedChainListeners)
-                {
-                    if (levelSystem.chainListeners[listener.Key] == __instance)
-                    {
-                        if (open != listener.Value)
-                        {
-                            return false;
-                        }
-                    }
-                }
-            }
-
-            return true;
-        }
-    }
-
-    [HarmonyPatch(typeof(LineDoorController), nameof(LineDoorController.OnLevelEnable))]
-    static class LineDoorControllerOnLevelEnablePatch
-    {
-        static void Prefix(LineDoorController __instance)
-        {
-            if (Plugin.archipelagoManager.chainListenersByScene.TryGetValue(__instance.gameObject.scene.name, out var activatedChainListeners))
-            {
-                LevelSystems levelSystem = __instance.gameObject.scene.GetRootGameObjects().Single((obj) => obj.name == "Level Systems").GetComponent<LevelSystems>();
-
-                foreach (var listener in activatedChainListeners)
-                {
-                    if (levelSystem.chainListeners[listener.Key] == __instance)
-                    {
-                        FieldInfo fieldInfo = typeof(LineDoorController).GetField("doorShouldOpenImmediatelyOnEnable", BindingFlags.Instance | BindingFlags.NonPublic);
-                        fieldInfo.SetValue(__instance, listener.Value);
-                    }
-                }
-            }
-        }
-    }
-
     [HarmonyPatch(typeof(ButtonLineActivator), nameof(ButtonLineActivator.OnInteract))]
     static class ButtonLineActivatorOnInteractPatch
     {
@@ -0,0 +1,288 @@
+using System.Collections.Generic;
+using System.Linq;
+
+namespace ManifoldGardenArchipelago
+{
+    public struct RequirementReferences
+    {
+        public RequirementReferences() { }
+
+        public readonly HashSet<string> scenes = [];
+        public readonly HashSet<SceneItemReference> buttons = [];
+        public readonly HashSet<SceneItemReference> sockets = [];
+        public readonly HashSet<SceneItemReference> pads = [];
+        public readonly HashSet<SceneItemReference> waterwheels = [];
+        public readonly HashSet<SceneItemReference> spheres = [];
+        public readonly HashSet<string> items = [];
+
+        public void Merge(RequirementReferences other)
+        {
+            foreach (var item in other.scenes)
+            {
+                scenes.Add(item);
+            }
+            foreach (var item in other.buttons)
+            {
+                buttons.Add(item);
+            }
+            foreach (var item in other.sockets)
+            {
+                sockets.Add(item);
+            }
+            foreach (var item in other.pads)
+            {
+                pads.Add(item);
+            }
+            foreach (var item in other.waterwheels)
+            {
+                waterwheels.Add(item);
+            }
+            foreach (var item in other.spheres)
+            {
+                spheres.Add(item);
+            }
+            foreach (var item in other.items)
+            {
+                items.Add(item);
+            }
+        }
+    }
+
+    public abstract class Requirement
+    {
+        public RequirementReferences references = new();
+
+        public abstract bool Check();
+    }
+
+    public class AndRequirement : Requirement
+    {
+        private readonly List<Requirement> _requirements;
+
+        public AndRequirement(List<Requirement> requirements)
+        {
+            _requirements = requirements;
+
+            foreach (var subreq in _requirements)
+            {
+                references.Merge(subreq.references);
+            }
+        }
+
+        public override bool Check()
+        {
+            return _requirements.All(x => x.Check());
+        }
+
+        public override string ToString()
+        {
+            return "And(" + string.Join(", ", _requirements.Select((req) => req.ToString())) + ")";
+        }
+    }
+
+    public class OrRequirement : Requirement
+    {
+        private readonly List<Requirement> _requirements;
+
+        public OrRequirement(List<Requirement> requirements)
+        {
+            _requirements = requirements;
+
+            foreach (var subreq in _requirements)
+            {
+                references.Merge(subreq.references);
+            }
+        }
+
+        public override bool Check()
+        {
+            return _requirements.Any(x => x.Check());
+        }
+
+        public override string ToString()
+        {
+            return "Or(" + string.Join(", ", _requirements.Select((req) => req.ToString())) + ")";
+        }
+    }
+
+    public class ItemRequirement : Requirement
+    {
+        private readonly string _itemName;
+
+        public ItemRequirement(string itemName)
+        {
+            _itemName = itemName;
+
+            references.items.Add(itemName);
+        }
+
+        public override bool Check()
+        {
+            return Plugin.archipelagoManager.HasItem(_itemName);
+        }
+
+        public override string ToString()
+        {
+            return $"Item({_itemName})";
+        }
+    }
+
+    public class EntryRequirement : Requirement
+    {
+        private readonly string _sceneName;
+
+        public EntryRequirement(string sceneName)
+        {
+            _sceneName = sceneName;
+
+            references.scenes.Add(sceneName);
+        }
+
+        public override bool Check()
+        {
+            return Plugin.slotSave.VisitedScenes.Contains(_sceneName);
+        }
+
+        public override string ToString()
+        {
+            return $"Entry({_sceneName})";
+        }
+    }
+
+    public class ButtonRequirement : Requirement
+    {
+        private readonly SceneItemReference _button;
+
+        public ButtonRequirement(SceneItemReference button)
+        {
+            _button = button;
+
+            references.scenes.Add(button.scene);
+            references.buttons.Add(button);
+        }
+
+        public override bool Check()
+        {
+            return Plugin.slotSave.ActivatedButtons.Contains(_button);
+        }
+
+        public override string ToString()
+        {
+            return $"Button{_button}";
+        }
+    }
+
+    public class SocketRequirement : Requirement
+    {
+        private readonly SceneItemReference _socket;
+
+        public SocketRequirement(SceneItemReference socket)
+        {
+            _socket = socket;
+
+            references.scenes.Add(socket.scene);
+            references.sockets.Add(socket);
+        }
+
+        public override bool Check()
+        {
+            return Plugin.slotSave.ActivatedSockets.Contains(_socket);
+        }
+
+        public override string ToString()
+        {
+            return $"Socket{_socket}";
+        }
+    }
+
+    public class PadRequirement : Requirement
+    {
+        private readonly SceneItemReference _pad;
+
+        public PadRequirement(SceneItemReference pad)
+        {
+            _pad = pad;
+
+            references.scenes.Add(pad.scene);
+            references.pads.Add(pad);
+        }
+
+        public override bool Check()
+        {
+            return Plugin.slotSave.ActivatedPads.Contains(_pad);
+        }
+
+        public override string ToString()
+        {
+            return $"Pad{_pad}";
+        }
+    }
+
+    public class WaterwheelRequirement : Requirement
+    {
+        private readonly SceneItemReference _waterwheel;
+
+        public WaterwheelRequirement(SceneItemReference waterwheel)
+        {
+            _waterwheel = waterwheel;
+
+            references.scenes.Add(waterwheel.scene);
+            references.waterwheels.Add(waterwheel);
+        }
+
+        public override bool Check()
+        {
+            return Plugin.slotSave.ActivatedWaterwheels.Contains(_waterwheel);
+        }
+
+        public override string ToString()
+        {
+            return $"Waterwheel{_waterwheel}";
+        }
+    }
+
+    public class SphereRequirement : Requirement
+    {
+        private readonly SceneItemReference _sphere;
+
+        public SphereRequirement(SceneItemReference sphere)
+        {
+            _sphere = sphere;
+
+            references.scenes.Add(sphere.scene);
+            references.spheres.Add(sphere);
+        }
+
+        public override bool Check()
+        {
+            return Plugin.slotSave.ActivatedSpheres.Contains(_sphere);
+        }
+
+        public override string ToString()
+        {
+            return $"Sphere{_sphere}";
+        }
+    }
+
+    public class InvertedRequirement : Requirement
+    {
+        private readonly Requirement _requirement;
+
+        public InvertedRequirement(Requirement requirement)
+        {
+            _requirement = requirement;
+
+            references = requirement.references;
+        }
+
+        public override bool Check()
+        {
+            return !_requirement.Check();
+        }
+
+        public override string ToString()
+        {
+            return $"Not({_requirement})";
+        }
+    }
+}
@@ -0,0 +1,18 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+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 = [];
+    }
+}
@@ -0,0 +1,735 @@
+World_000_Optimized:
+  locations:
+    Tutorial Completed:
+      socket: 0
+  doors:
+    16:
+      item: Blue Secret Path
+      or:
+        - socket: 2
+        - button:
+            scene: Hallway_W000_W052_Optimized
+            index: 0
+World_062_LargeGap_Optimized:
+  locations:
+    Large Gap Puzzle Solved:
+      socket: 0
+    Secret Hub Green Button:
+      button: 3
+    Secret Hub Garnier Button:
+      button: 5
+    Secret Hub Back Door Button:
+      button: 1
+    Secret Hub Front Door Button:
+      button: 4
+  doors:
+    10:
+      item: Secret Hub Garnier Entrance
+      or:
+        - entry: Hallway_W062_W900_Optimized
+        - button: 5
+    0:
+      item: Large Gap Exterior Door
+      or:
+        - button: 0
+        - socket: 0
+    8:
+      item: Large Gap Exterior Secret Door
+      or:
+        - button: 0
+        - button: 4
+    7:
+      or:
+        - pad: 0
+        - button: 2
+    4:
+      or:
+        - socket: 0
+        - button: 2
+    3:
+      item: Library Main Entrance
+      or:
+        - button: 2
+        - button:
+            scene: Hallway_W062_W026_Optimized
+            index: 0
+    1:
+      item: Large Gap Interior Secret Door
+      or:
+        - button: 2
+        - button: 1
+    5:
+      item: Secret Hub Orange Entrance
+      or:
+        - button: 3
+        - button:
+            scene: Hallway_W062_W063_Optimized
+            index: 0
+Hallway_W062_W063_Optimized:
+  doors:
+    0:
+      item: Secret Hub Orange Entrance
+      or:
+        - button: 0
+        - socket:
+            scene: World_063_TowerX_Optimized
+            index: 0
+World_001_Optimized:
+  # lasers are called DarkModeCageControllers; will handle them separately bc most worlds don't item-lock them
+  locations:
+    Blue - Red Laser Activated:
+      socket: 5
+    Blue - Yellow Laser Activated:
+      socket: 4
+    Blue - Green Laser Activated:
+      socket: 3
+    Blue - Tree Purified:
+      entry: AudioVisual_001_Optimized
+World_044_CubicSpaceDivision_Optimized:
+  locations:
+    Blue God Cube Planted:
+      socket: 5
+    Red God Cube Planted:
+      socket: 2
+    Green God Cube Planted:
+      socket: 3
+    Yellow God Cube Planted:
+      socket: 0
+    Purple God Cube Planted:
+      socket: 1
+    Orange God Cube Planted:
+      socket: 4
+  world_grow:
+    # These are in chainListeners just like doors
+    5:
+      item: Blue Garden
+    0:
+      item: Yellow Garden
+    1:
+      item: Purple Garden
+    2:
+      item: Red Garden
+    3:
+      item: Green Garden
+    4:
+      item: Orange Garden
+  doors:
+    12:
+      item: Orange Garden
+World_044B_CubicSpaceDivision_Optimized:
+  doors:
+    0:
+      item: Blue Garden
+      or:
+        - button: 0
+        - button:
+            scene: Hallway_W044_W015_Optimized
+            index: 1
+Hallway_W044_W015_Optimized:
+  locations:
+    Tower Orange Tree Puzzle Solved:
+      socket: [0, 1]
+  doors:
+    5:
+      or:
+        - button: 1
+        - socket: [0, 1]
+    1:
+      item: Stepwell Entrance
+      or:
+        - socket: [0, 1]
+        - button:
+            scene: World_015_Stepwell_Optimized
+            index: 1
+World_613_LongBridgeLongTower_Optimized:
+  locations:
+    Long Bridge Long Tower Puzzle Solved:
+      pad: 0
+  doors:
+    1:
+      item: Yellow Secret Path
+      or:
+        - socket:
+            - scene: Hallway_W044_W015_Optimized
+              index: 0
+            - scene: Hallway_W044_W015_Optimized
+              index: 1
+        - button: 0
+    0:
+      or:
+        - button: 0
+        - pad: 0
+World_015_Stepwell_Optimized:
+  doors:
+    1:
+      or:
+        - button: 0
+        - button: 1
+    0:
+      or:
+        - button: 1
+        - pad:
+            scene: Hallway_W015_W041_Optimized
+            index: 2
+Hallway_W015_W041_Optimized:
+  doors:
+    3:
+      or:
+        - pad: 2
+        - button: 0
+    1:
+      or:
+        - button: 0
+        - pad: 3
+    4:
+      item: Stepwell Entrance
+      or:
+        - pad: 3
+        - button:
+            scene: World_045_FirstHub_Optimized
+            index: 0
+World_045_FirstHub_Optimized:
+  locations:
+    Pyramid First Exit Opened:
+      button: 0
+    Pyramid Second Exit Opened:
+      socket: 0
+    Pyramid Waterwheel Activated:
+      waterwheel: 0
+    Pyramid Lower Tree Reached:
+      inverted:
+        pad: 0
+    Pyramid Upper Tree Reached:
+      inverted:
+        pad: 1
+  doors:
+    11:
+      item: Path to Red
+      or:
+        - button: 0
+        - pad:
+            - scene: Hallway_W045_W018_Optimized
+              index: 0
+            - scene: Hallway_W045_W018_Optimized
+              index: 1
+    0:
+      item: Path to Green
+      or:
+        - button: 0
+        - button:
+            scene: Hallway_045_053_Optimized
+            index: 0
+    6:
+      item: Apartments Entrance
+      or:
+        - button: 0
+        - button:
+            scene: Hallway_W045_W073_Optimized
+            index: 0
+  smoke:
+    2:
+      item: Pyramid - Red Smoke Wall
+      or:
+        - button: 0
+        - inverted:
+            pad: 0
+    4:
+      item: Pyramid - Green Smoke Wall
+      or:
+        - button: 0
+        - inverted:
+            pad: 1
+Hallway_W045_W018_Optimized:
+  locations:
+    Purple/Orange Tree Puzzle Solved:
+      pad: [0, 1]
+  doors:
+    1:
+      or:
+        - pad: [0, 1]
+        - button:
+            scene: Hallway_W041_W018_Optimized
+            index: 0
+Hallway_W041_W018_Optimized:
+  doors:
+    0:
+      or:
+        - button: 0
+        - button:
+            scene: World_018_PastaTile_Optimized
+            index: 0
+World_612_BlindSpherePuzzle_Optimized:
+  locations:
+    Blind Sphere Puzzle Solved:
+      sphere: 0
+  doors:
+    1:
+      item: Red Secret Path
+      or:
+        - sphere: 0
+        - button:
+            scene: Hallway_W041_W018_Optimized
+            index: 0
+        - button:
+            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
+Hallway_W018_W003B_Optimized:
+  locations:
+    Mini Sphere Puzzle Solved:
+      sphere: 0
+  doors:
+    1:
+      or:
+        - sphere: 0
+        - button: 1
+    4:
+      item: Red Entrance
+      or:
+        - button: 1
+        - entry: World_003_SpherePipe_Optimized
+World_003_SpherePipe_Optimized:
+  locations:
+    Red - Tree Purified:
+      entry: AudioVisual_003_Optimized
+World_044C_CubicSpaceDivision_Optimized:
+  doors:
+    1:
+      item: Red Garden
+      or:
+        - button: 0
+        - button:
+            scene: Hallway_W044_W045_Optimized
+            index: 0
+Hallway_W044_W045_Optimized:
+  locations:
+    Final Test Puzzle Solved:
+      socket: [0, 1]
+  doors:
+    3:
+      item: Final Test Door
+      or:
+        - socket: [0, 1]
+        - button: 0
+        - button:
+            scene: Hallway_W045_W804_Optimized
+            index: 0
+    2:
+      or:
+        - button: 0
+        - inverted:
+            pad:
+              scene: World_045_FirstHub_Optimized
+              index: 0
+Hallway_W045_W053_Optimized:
+  doors:
+    1:
+      item: Path to Green
+      or:
+        - button: 0
+        - entry: World_053_WaterTechingPuzzle_Optimized
+World_053_WaterTechingPuzzle_Optimized:
+  locations:
+    Green - Blue Waterwheel Activated:
+      waterwheel: 0
+    Green - Tree Purified:
+      entry: AudioVisual_053_Optimized
+  doors:
+    4:
+      item: Green - Water Room Entrance
+World_044E_CubicSpaceDivision_Optimized:
+  doors:
+    1:
+      item: Green Garden
+      or:
+        - button: 0
+        - socket:
+            scene: Hallway_W044_W057_Optimized
+            index: 0
+Hallway_W044_W057_Optimized:
+  doors:
+    1:
+      or:
+        - socket: 0
+        - waterwheel:
+            scene: World_057_WaterAndPortals_Optimized
+            index: 0
+Hallway_W612_W057_Optimized:
+  doors:
+    2:
+      or:
+        - button: 0
+        - button:
+            scene: World_057_WaterAndPortals_Optimized
+            index: 0
+World_057_WaterAndPortals_Optimized:
+  locations:
+    Water Through Portals Puzzle Solved:
+      waterwheel: 0
+  doors:
+    0:
+      or:
+        - waterwheel: 0
+        - button:
+            scene: Hallway_W057_W045_Optimized
+            index: 0
+    5:
+      item: Red Secret Path
+      or:
+        - waterwheel: 0
+        - button: 0
+Hallway_W057_W045_Optimized:
+  doors:
+    1:
+      or:
+        - button: 0
+        - inverted:
+            pad:
+              scene: World_045_FirstHub_Optimized
+              index: 1
+Hallway_W045_W073_Optimized:
+  locations:
+    Apartments Waterwheel Activated:
+      waterwheel: 0
+  doors:
+    0:
+      item: Apartments Entrance
+      or:
+        - button: 0
+        - waterwheel:
+            scene: World_073_WaterThruStairs_Optimized
+            index: 0
+    5:
+      item: Orange Secret Path
+      or:
+        - button: 0
+        - waterwheel: 0
+        - button:
+            scene: Hallway_W073_W018_Optimized
+            index: 0
+Hallway_W073_W018_Optimized:
+  doors:
+    1:
+      or:
+        - button: 0
+        - button:
+            scene: World_018_PastaTile_Optimized
+            index: 1
+Hallway_W018_W063_Optimized:
+  doors:
+    0:
+      item: Secret Apartments Shortcut
+      or:
+        - button: [0, 1]
+        - button:
+            scene: Hallway_W045_W073_Optimized
+            index: 0
+    1:
+      item: Orange Shortcut from Apartments
+      or:
+        - button: [0, 1]
+        - entry: World_063_TowerX_Optimized
+World_073_WaterThruStairs_Optimized:
+  locations:
+    Skylight Room Waterwheel Activated:
+      waterwheel: 0
+    Skylight Room Orange Secret:
+      socket: 0
+    Skylight Room Red Secret:
+      socket: 1
+  doors:
+    3:
+      item: Large Gap Main Entrance
+      or:
+        - waterwheel: 0
+        - button: 0
+    1:
+      or:
+        - button: 0
+        - button:
+            scene: Hallway_W073_W062_Optimized
+            index: 0
+    0:
+      item: Skylight to Library Shortcut
+      or:
+        - waterwheel: 0
+        - button:
+            scene: Hallway_W073_W026_Optimized
+            index: 0
+    6:
+      item: Arches Secret Passage
+      or:
+        - waterwheel: 0
+        - button:
+            scene: Hallway_W044_W045_Optimized
+            index: 0
+Hallway_W073_W062_Optimized:
+  doors:
+    1:
+      item: Large Gap Main Entrance
+      or:
+        - button: 0
+        - socket:
+            scene: World_062_LargeGap_Optimized
+            index: 0
+Hallway_W000_W052_Optimized:
+  doors:
+    2:
+      or:
+        - button: 0
+        - button:
+            scene: World_052_JerryMcGuirePuzzle_Optimized
+            index: 1
+World_052_JerryMcGuirePuzzle_Optimized:
+  locations:
+    Jerry McGuire Puzzle Solved:
+      pad: 0
+  doors:
+    2:
+      or:
+        - button: 1
+        - pad: 0
+    0:
+      or:
+        - pad: 0
+        - button: 0
+    1:
+      or:
+        - button: 0
+        - button: 2
+    5:
+      or:
+        - button: 2
+        - button:
+            scene: Hallway_W052_W062_Optimized
+            index: 0
+Hallway_W052_W062_Optimized:
+  doors:
+    2:
+      item: Blue Secret Path
+      or:
+        - button: 0
+        - button:
+            scene: World_062_LargeGap_Optimized
+            index: 0
+Hallway_W062_W026_Optimized:
+  doors:
+    1:
+      item: Library Main Entrance
+      or:
+        - button: 0
+        - entry: World_026_Library_Optimized
+World_026_Library_Optimized:
+  locations:
+    Single Socket Puzzle Solved:
+      socket: 0
+    Double Socket Puzzle Solved:
+      socket: [1, 2]
+  doors:
+    1:
+      item: Path to Yellow
+      or:
+        - entry: World_026_Library_Optimized
+        - entry: Hallway_W026_W002_Optimized
+    6:
+      item: Library - Purple Entrance
+      or:
+        - entry: World_026_Library_Optimized
+        - button:
+            scene: Hallway_W026_W051_Optimized
+            index: 0
+  smoke:
+    3:
+      item: Library - Yellow Smoke Wall
+Hallway_W026_W002_Optimized:
+  locations:
+    Yellow Cube Fetch Quest Completed:
+      socket: 0
+  doors:
+    0:
+      item: Yellow Secret Path
+      or:
+        - entry: Hallway_W026_W002_Optimized
+        - button:
+            scene: Hallway_W026_W015_Optimized
+            index: 0
+Hallway_W026_W015_Optimized:
+  doors:
+    0:
+      or:
+        - button: 0
+        - pad:
+            scene: World_613_LongBridgeLongTower_Optimized
+            index: 0
+Hallway_W026_W002_PuzzleRoom_Optimized:
+  locations:
+    Yellow Entrance Puzzle Solved:
+      socket: [0, 1]
+  doors:
+    1:
+      item: Yellow Entrance
+      or:
+        - socket: [0, 1]
+        - entry: World_002_Optimized
+World_002_Optimized:
+  locations:
+    Yellow - Blue Tower Solved:
+      socket: 3
+    Yellow - Green Tower Solved:
+      socket: 5
+    Yellow - Red Tower Solved:
+      socket: 4
+    Yellow - Tree Purified:
+      entry: AudioVisual_002_Optimized
+World_044D_CubicSpaceDivision_Optimized:
+  doors:
+    0:
+      item: Yellow Garden
+      or:
+        - button: 0
+        - button:
+            scene: Hallway_W044_W026_Optimized
+            index: 0
+Hallway_W044_W026_Optimized:
+  doors:
+    2:
+      or:
+        - button: 0
+        - pad:
+            scene: World_026_Library_Optimized
+            index: 0
+    4:
+      item: Skylight to Library Shortcut
+      or:
+        - button: 0
+        - button: 1
+Hallway_W073_W026_Optimized:
+  doors:
+    1:
+      or:
+        - button: 0
+        - button:
+            scene: Hallway_W044_W026_Optimized
+            index: 1
+Hallway_W026_W051_Optimized:
+  doors:
+    0:
+      item: Library - Purple Entrance
+      or:
+        - button: 0
+        - entry: World_051_CeilingSuspendPuzzle_Optimized
+World_051_CeilingSuspendPuzzle_Optimized:
+  locations:
+    Purple - Tree Purified:
+      entry: AudioVisual_051_Optimized
+World_044G_CubicSpaceDivision_Optimized:
+  doors:
+    1:
+      item: Purple Garden
+      or:
+        - button: 0
+        - button:
+            scene: Hallway_W033_W063_Optimized
+            index: 0
+Hallway_W033_W063_Optimized:
+  locations:
+    Shattered Bridges Puzzle Solved:
+      waterwheel: 0
+  doors:
+    3:
+      or:
+        - button: 0
+        - waterwheel: 0
+    0:
+      item: Orange Entrance
+      or:
+        - waterwheel: 0
+        - socket:
+            scene: World_063_TowerX_Optimized
+            index: 0
+World_611_SecretRoom1_Optimized:
+  locations:
+    Shattered Bridges Secret Puzzle Solved:
+      socket: 0
+  doors:
+    2:
+      item: Secret Hub Shattered Bridges Entrance
+      or:
+        - entry: Hallway_W033_W063_Optimized
+        - button: 0
+    1:
+      or:
+        - button: 0
+        - socket:
+            scene: World_604_TetrominoNonEuclidean_Optimized
+            index: 0
+World_604_TetrominoNonEuclidean_Optimized:
+  locations:
+    Non-Euclidean Tetromino Puzzle Solved:
+      socket: 0
+  doors:
+    0:
+      or:
+        - socket: 0
+        - button: 0
+    2:
+      or:
+        - button: 0
+        - button:
+            scene: Hallway_W604_W062_Optimized
+            index: 0
+Hallway_W604_W062_Optimized:
+  doors:
+    0:
+      item: Secret Hub Shattered Bridges Entrance
+      or:
+        - button: 0
+        - button:
+            scene: World_062_LargeGap_Optimized
+            index: 3
+        - button:
+            scene: World_062_LargeGap_Optimized
+            index: 5
+        - button:
+            scene: World_062_LargeGap_Optimized
+            index: 1
+        - button:
+            scene: World_062_LargeGap_Optimized
+            index: 4
+World_063_TowerX_Optimized:
+  locations:
+    Orange - Inside Puzzle Solved:
+      socket: 0
+    Orange - Tree Purified:
+      entry: AudioVisual_063_Optimized
+  doors:
+    0:
+      item: Orange Tower Door
+      or:
+        - socket: 0
+        - socket: 1
+Hallway_W045_W804_Optimized:
+  doors:
+    0:
+      item: Final Test Door
+      or:
+        - button: 0
+        - entry: World_804_Optimized