Opening a door via an item!

4 files changed, 226 insertions, 0 deletions

@@ -0,0 +1,133 @@
+using Archipelago.MultiClient.Net;
+using Archipelago.MultiClient.Net.Enums;
+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
+{
+    public class ArchipelagoManager
+    {
+        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;
+                }
+            }
+        }
+
+        public async Task<LoginResult> Connect(string url, string slotName, string password)
+        {
+            LoginResult result;
+            try
+            {
+                _session = ArchipelagoSessionFactory.CreateSession(url);
+
+                RoomInfoPacket roomInfoPacket = await _session.ConnectAsync();
+
+                result = await _session.LoginAsync("Manifold Garden", slotName, ItemsHandlingFlags.AllItems, null, null, null, password == "" ? null : password);
+            }
+            catch (Exception ex)
+            {
+                return new LoginFailure(ex.GetBaseException().Message);
+            }
+
+            return result;
+        }
+
+        ~ArchipelagoManager()
+        {
+            Disconnect();
+        }
+
+        public void Disconnect()
+        {
+            if (_session == null)
+            {
+                return;
+            }
+
+            _session.Socket.DisconnectAsync();
+            _session = null;
+        }
+
+        public void Update()
+        {
+            if (_session == null)
+            {
+                return;
+            }
+
+            if (_session.Items.AllItemsReceived.Count > _itemIndex)
+            {
+                for (int i = _itemIndex; i < _session.Items.AllItemsReceived.Count; i++)
+                {
+                    ItemInfo item = _session.Items.AllItemsReceived[i];
+                    string itemName = item.ItemName;
+
+                    if (GameData.door_by_item.TryGetValue(itemName, out List<GameData.ChainListenerReference> door))
+                    {
+                        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]);
+                                }
+                            }
+                        }
+                    }
+                }
+
+                _itemIndex = _session.Items.AllItemsReceived.Count;
+
+                /*
+                var hi = new StringBuilder();
+                foreach (var thing in chainListenersByScene)
+                {
+                    hi.AppendLine(thing.Key);
+
+                    foreach (var thing2 in thing.Value)
+                    {
+                        hi.AppendLine($"    {thing2.Key}: {thing2.Value}");
+                    }
+                }
+
+                Plugin.Logger.LogInfo( hi.ToString() );
+                */
+            }
+        }
+    }
+}
@@ -0,0 +1,18 @@
+using System.Collections.Generic;
+
+namespace ManifoldGardenArchipelago
+{
+    public class GameData
+    {
+        public readonly struct ChainListenerReference(string scene_arg, int index_arg)
+        {
+            public readonly string scene = scene_arg;
+            public readonly int index = index_arg;
+        }
+
+        public static readonly Dictionary<string, List<ChainListenerReference>> door_by_item = new()
+        {
+            {"Blue Secret Path", [new ChainListenerReference("World_000_Optimized", 16)] }
+        };
+    }
+}
@@ -20,6 +20,7 @@
   </PropertyGroup>
 
   <ItemGroup>
+    <PackageReference Include="Archipelago.MultiClient.Net" Version="6.5.0" />
     <PackageReference Include="BepInEx.Analyzers" Version="1.*" PrivateAssets="all" />
     <PackageReference Include="BepInEx.Core" Version="5.*" />
     <PackageReference Include="BepInEx.PluginInfoProps" Version="2.*" />
@@ -1,5 +1,8 @@
 using BepInEx;
 using BepInEx.Logging;
+using HarmonyLib;
+using System.Linq;
+using System.Reflection;
 
 namespace ManifoldGardenArchipelago
 {
@@ -8,11 +11,82 @@ namespace ManifoldGardenArchipelago
     {
         internal static new ManualLogSource Logger;
 
+        public static ArchipelagoManager archipelagoManager = new();
+
         private void Awake()
         {
             // Plugin startup logic
             Logger = base.Logger;
             Logger.LogInfo($"Plugin {MyPluginInfo.PLUGIN_GUID} is loaded!");
+
+            Harmony.CreateAndPatchAll(Assembly.GetExecutingAssembly());
+
+            archipelagoManager.Connect("localhost:38281", "Manifold", "").RunSynchronously();
+        }
+    }
+
+    [HarmonyPatch(typeof(GameManager), "Update")]
+    static class GameManagerUpdatePatch
+    {
+        static void Postfix()
+        {
+            Plugin.archipelagoManager.Update();
         }
     }
+
+    [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
+    {
+        public static void Postfix(ButtonLineActivator __instance)
+        {
+            Plugin.Logger.LogInfo($"Interacted with {__instance.name} in {__instance.gameObject.scene.name}: {__instance.isButtonPressed}");
+        }
+    }
+
 }