1 files changed, 288 insertions, 0 deletions

@@ -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})";
+        }
+    }
+}