using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Threading.Tasks;
using Archipelago.MultiClient.Net;
using Archipelago.MultiClient.Net.Enums;
using Archipelago.MultiClient.Net.Helpers;
using Archipelago.MultiClient.Net.Models;
using BepInEx;
using BepInEx.Logging;
using DG.Tweening;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using MoonlighterAPMod.Archipelago;
using MoonlighterAPMod.Mod;
using Newtonsoft.Json.Linq;
using TMPro;
using UnityEngine;
using UnityEngine.EventSystems;
using UnityEngine.Events;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: AssemblyCompany("MoonlighterAPMod")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("0.0.0.0")]
[assembly: AssemblyInformationalVersion("0.0.0+a23a1d3f322bb9a461944b85a574dff5cf28e26f")]
[assembly: AssemblyProduct("Moonlighter Archipelago Mod")]
[assembly: AssemblyTitle("MoonlighterAPMod")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace MoonlighterAPMod
{
	internal class APDebug
	{
		private static int n;

		internal static void StartDebug()
		{
			n = 0;
		}

		internal static void Debug()
		{
			MoonlighterAPMod.APInfo($"Debug message: {++n}");
		}
	}
	internal static class ModInfo
	{
		internal const string PLUGIN_GUID = "FeluciaPS.MoonlighterAPMod";

		internal const string PLUGIN_NAME = "MoonlighterAPMod";

		internal const string PLUGIN_VERSION = "0.0.0";

		internal const string GAME_NAME = "Moonlighter";
	}
	[BepInPlugin("FeluciaPS.MoonlighterAPMod", "MoonlighterAPMod", "0.0.0")]
	internal class MoonlighterAPMod : BaseUnityPlugin
	{
		internal static ManualLogSource Logger;

		internal static ArchipelagoClient client;

		internal static ConnectionUI connectionUI;

		internal static void APMessage(object obj)
		{
			Logger.LogMessage(obj);
		}

		internal static void APInfo(object obj)
		{
			Logger.LogInfo(obj);
		}

		internal static void APError(object obj)
		{
			Logger.LogError(obj);
		}

		private void Awake()
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Expected O, but got Unknown
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Expected O, but got Unknown
			client = new ArchipelagoClient();
			Logger = ((BaseUnityPlugin)this).Logger;
			PatchLoader.LoadPatches();
			GameObject val = new GameObject("AP-UIManager");
			val.AddComponent<UIManager>();
			GameObject val2 = new GameObject("AP-ConnectionUI");
			connectionUI = val2.AddComponent<ConnectionUI>();
			Object.DontDestroyOnLoad((Object)(object)val2);
		}

		internal static void ExitDungeon()
		{
			DungeonResultsPanel componentInChildren = ((Component)GUIManager.Instance).GetComponentInChildren<DungeonResultsPanel>();
			componentInChildren.PlayAnimations();
			typeof(DungeonResultsPanel).GetField("_fromEmblem", BindingFlags.Instance | BindingFlags.NonPublic).SetValue(componentInChildren, false);
			((Panel)componentInChildren).OnBButtonPressed();
		}
	}
	internal class PatchLoader
	{
		internal static Harmony harmony;

		internal static void LoadPatches()
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Expected O, but got Unknown
			MoonlighterAPMod.APInfo("Loading patches for FeluciaPS.MoonlighterAPMod...");
			harmony = new Harmony("FeluciaPS.MoonlighterAPMod");
			harmony.PatchAll(Assembly.GetExecutingAssembly());
			MoonlighterAPMod.APInfo("Patches for FeluciaPS.MoonlighterAPMod loaded!");
		}
	}
	public static class MyPluginInfo
	{
		public const string PLUGIN_GUID = "MoonlighterAPMod";

		public const string PLUGIN_NAME = "Moonlighter Archipelago Mod";

		public const string PLUGIN_VERSION = "0.0.0";
	}
}
namespace MoonlighterAPMod.Patches
{
	internal class BossKeyPatches
	{
		[HarmonyPatch(typeof(DungeonBossRoom))]
		[HarmonyPatch(/*Could not decode attribute arguments.*/)]
		internal static class IsBossDefeatedPatch
		{
			internal static void Postfix(ref bool __result)
			{
				//IL_0014: Unknown result type (might be due to invalid IL or missing references)
				//IL_0019: Unknown result type (might be due to invalid IL or missing references)
				//IL_001a: Unknown result type (might be due to invalid IL or missing references)
				//IL_001d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0020: Unknown result type (might be due to invalid IL or missing references)
				//IL_0051: Unknown result type (might be due to invalid IL or missing references)
				//IL_0037: Unknown result type (might be due to invalid IL or missing references)
				if (ArchipelagoClient.IsClientConnected)
				{
					Culture culture = DungeonManager.Instance.culture;
					long locationId = culture * 100 + 10;
					__result = LocationHelper.IsChecked(locationId);
					if (__result)
					{
						MoonlighterAPMod.APInfo($"Preventing {culture} boss spawn because location is checked");
					}
					else
					{
						MoonlighterAPMod.APInfo($"Forcing {culture} boss spawn because location is unchecked");
					}
				}
			}
		}

		[HarmonyPatch(typeof(DungeonBossRoom))]
		[HarmonyPatch("InternalOnBossDeath")]
		internal static class BossDeathPatch
		{
			internal static void Postfix(DungeonBossRoom __instance)
			{
				//IL_0014: Unknown result type (might be due to invalid IL or missing references)
				//IL_0019: Unknown result type (might be due to invalid IL or missing references)
				//IL_001a: Unknown result type (might be due to invalid IL or missing references)
				//IL_001c: Invalid comparison between Unknown and I4
				//IL_002c: Unknown result type (might be due to invalid IL or missing references)
				//IL_002f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0032: Unknown result type (might be due to invalid IL or missing references)
				//IL_003a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0063: Unknown result type (might be due to invalid IL or missing references)
				if (ArchipelagoClient.IsClientConnected)
				{
					Culture culture = DungeonManager.Instance.culture;
					if ((int)culture == 5)
					{
						GoalHelper.TrySendGoal(GoalHelper.GoalType.PirateBoss);
						return;
					}
					long locationId = culture * 100 + 10;
					MoonlighterAPMod.APInfo($"Sending location for boss kill {culture}");
					LocationHelper.SendLocation(locationId);
					MoonlighterAPMod.APInfo("Lying to the game and pretending no boss was defeated so no scary cutscenes happen");
					GameManager.Instance.bossDefeatedCulture = (Culture)6;
				}
			}
		}

		[HarmonyPatch(typeof(HeroInventoryPanel))]
		[HarmonyPatch("UpdateBossKeys")]
		internal static class InventoryKeysPatch
		{
			private static void ShowKey(Image image)
			{
				DOTweenModuleUI.DOFade(image, 1f, 0.1f);
			}

			private static void HideKey(Image image)
			{
				DOTweenModuleUI.DOFade(image, 0f, 0.1f);
			}

			internal static bool Prefix(HeroInventoryPanel __instance)
			{
				if (!ArchipelagoClient.IsClientConnected)
				{
					return true;
				}
				MoonlighterAPMod.APInfo("Modifying boss key display");
				if (ItemHelper.HasItem("Golem Key"))
				{
					ShowKey(__instance.golemKey);
				}
				else
				{
					HideKey(__instance.golemKey);
				}
				if (ItemHelper.HasItem("Forest Key"))
				{
					ShowKey(__instance.forestKey);
				}
				else
				{
					HideKey(__instance.forestKey);
				}
				if (ItemHelper.HasItem("Desert Key"))
				{
					ShowKey(__instance.desertKey);
				}
				else
				{
					HideKey(__instance.desertKey);
				}
				if (ItemHelper.HasItem("Tech Key"))
				{
					ShowKey(__instance.techKey);
				}
				else
				{
					HideKey(__instance.techKey);
				}
				return false;
			}
		}
	}
	internal class CrazyPetePatches
	{
		[HarmonyPatch(typeof(CrazyPeteNotes))]
		[HarmonyPatch("Start")]
		internal static class PeteInitPatch
		{
			internal static void Postfix(CrazyPeteNotes __instance)
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0011: Unknown result type (might be due to invalid IL or missing references)
				//IL_0014: Unknown result type (might be due to invalid IL or missing references)
				//IL_0016: Unknown result type (might be due to invalid IL or missing references)
				//IL_0018: Unknown result type (might be due to invalid IL or missing references)
				Culture culture = DungeonManager.Instance.culture;
				for (int i = 0; i < 3; i++)
				{
					long locationId = culture * 100 + i + 1;
					if (!LocationHelper.IsChecked(locationId))
					{
						__instance.crazyPeteNoteIndex = i;
						break;
					}
				}
			}
		}

		[HarmonyPatch(typeof(CrazyPeteNotes))]
		[HarmonyPatch("Interact")]
		internal static class NotePatch
		{
			internal static void Prefix(CrazyPeteNotes __instance)
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0017: Unknown result type (might be due to invalid IL or missing references)
				//IL_001a: Unknown result type (might be due to invalid IL or missing references)
				//IL_001c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0024: Unknown result type (might be due to invalid IL or missing references)
				Culture culture = DungeonManager.Instance.culture;
				int num = __instance.crazyPeteNoteIndex % 3 + 1;
				long num2 = culture * 100 + num;
				MoonlighterAPMod.APInfo($"Sending crazy pete location {culture} {num} with ID {num2}.");
				LocationHelper.SendLocation(num2);
			}
		}
	}
	internal class DungeonDoorPatches
	{
		[HarmonyPatch(typeof(WorldDungeonDoor))]
		[HarmonyPatch("UpdateByCulturesDefeated")]
		internal static class DoorOpenPatch
		{
			private static void SetState(WorldDungeonDoor __instance, bool state)
			{
				if (state)
				{
					__instance.UnlockDoor();
				}
				else
				{
					__instance.LockDoor();
				}
			}

			private static void SetUnknownDungeonState(WorldDungeonDoor __instance)
			{
				MoonlighterAPMod.APInfo("Placing keys in 5th dungeon door");
				GameObject.Find("GolemLock").SetActive(ItemHelper.HasItem("Golem Key"));
				GameObject.Find("ForestLock").SetActive(ItemHelper.HasItem("Forest Key"));
				GameObject.Find("DesertLock").SetActive(ItemHelper.HasItem("Desert Key"));
				GameObject.Find("TechLock").SetActive(ItemHelper.HasItem("Tech Key"));
				bool state = ItemHelper.HasItems(new string[4] { "Golem Key", "Forest Key", "Desert Key", "Tech Key" });
				SetState(__instance, state);
			}

			internal static bool Prefix(WorldDungeonDoor __instance)
			{
				//IL_001a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0030: Unknown result type (might be due to invalid IL or missing references)
				//IL_0035: Unknown result type (might be due to invalid IL or missing references)
				//IL_0036: Unknown result type (might be due to invalid IL or missing references)
				//IL_0037: Unknown result type (might be due to invalid IL or missing references)
				//IL_0038: Unknown result type (might be due to invalid IL or missing references)
				//IL_003a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0054: Expected I4, but got Unknown
				if (!ArchipelagoClient.IsClientConnected)
				{
					return true;
				}
				MoonlighterAPMod.APInfo($"Setting door state for {__instance.dungeonType}");
				Culture dungeonType = __instance.dungeonType;
				Culture val = dungeonType;
				switch (val - 1)
				{
				case 0:
					SetState(__instance, ItemHelper.HasItem("Unlock Golem Dungeon"));
					break;
				case 1:
					SetState(__instance, ItemHelper.HasItem("Unlock Forest Dungeon"));
					break;
				case 2:
					SetState(__instance, ItemHelper.HasItem("Unlock Desert Dungeon"));
					break;
				case 3:
					SetState(__instance, ItemHelper.HasItem("Unlock Tech Dungeon"));
					break;
				case 4:
					SetUnknownDungeonState(__instance);
					break;
				}
				return false;
			}
		}
	}
	internal class DungeonLoadPatches
	{
		[HarmonyPatch(typeof(WorldDungeonDoor))]
		[HarmonyPatch("LoadDungeon")]
		internal static class DungeonLoadPatch
		{
			internal static void Prefix(WorldDungeonDoor __instance)
			{
				//IL_0010: Unknown result type (might be due to invalid IL or missing references)
				//IL_0016: Invalid comparison between Unknown and I4
				if (ArchipelagoClient.IsClientConnected && (int)__instance.dungeonType == 5)
				{
					GoalHelper.TrySendGoal(GoalHelper.GoalType.FifthDungeon);
				}
			}
		}
	}
	internal class MainMenuPatches
	{
		[HarmonyPatch(typeof(MainMenuPanel))]
		[HarmonyPatch("CloseGamepadPanel")]
		internal static class ArchipelagoMenuButtonPatch
		{
			private static readonly bool finishLater = true;

			internal static void Prefix(MainMenuPanel __instance)
			{
				UIManager.Instance.CreateOrUpdateVersionLabel(((Component)__instance).transform);
				if (!finishLater)
				{
					UIManager.Instance.CreateOrUpdateArchipelagoMenuButton(__instance);
					UIManager.Instance.CreateOptionsPanel();
				}
			}
		}

		[HarmonyPatch(typeof(MainMenuPanel))]
		[HarmonyPatch("PrepareMenuButtons")]
		internal static class ArchipelagoConnectionUIPatch
		{
			internal static void Prefix()
			{
				MoonlighterAPMod.connectionUI.Show();
			}
		}
	}
	internal class TreePatches
	{
		[HarmonyPatch(typeof(TreeBehaviour))]
		[HarmonyPatch("OnTriggerEnter2D")]
		internal static class TreeMoneyPatch
		{
			private static float n;

			internal static void Prefix(TreeBehaviour __instance, float ___timesTreeHitDropped)
			{
				n = ___timesTreeHitDropped;
			}

			internal static void Postfix(TreeBehaviour __instance, float ___timesTreeHitDropped)
			{
				if (___timesTreeHitDropped != n)
				{
					MoonlighterAPMod.APInfo("Sending money tree location");
					LocationHelper.SendLocation(1L);
				}
			}
		}
	}
}
namespace MoonlighterAPMod.Mod
{
	internal class ArchipelagoOptionsPanel : Panel
	{
		private InputFieldEntry serverInput;

		private InputFieldEntry portInput;

		private InputFieldEntry slotInput;

		private InputFieldEntry passwordInput;

		private Button connectButton;

		private Button disconnectButton;

		private Text resultMessage;

		private void Start()
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			((Panel)this).Init();
			serverInput = CreateInputField("Server", new Vector3(0f, 90f, 0f));
			portInput = CreateInputField("Port", new Vector3(0f, 30f, 0f));
			slotInput = CreateInputField("Slot", new Vector3(0f, -30f, 0f));
			passwordInput = CreateInputField("Password", new Vector3(0f, -90f, 0f));
			SetupNavigation(new List<GameObject>(4)
			{
				((Component)serverInput).gameObject,
				((Component)portInput).gameObject,
				((Component)slotInput).gameObject,
				((Component)passwordInput).gameObject
			});
			((Component)serverInput).gameObject.GetComponent<Selectable>().Select();
		}

		private InputFieldEntry CreateInputField(string name, Vector3 position)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Expected O, but got Unknown
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject(name);
			Transform val2 = ((Panel)this).Content.transform.Find("Canvas");
			val.transform.SetParent(val2, false);
			val.transform.localPosition = position;
			val.AddComponent<RectTransform>();
			Button button = val.AddComponent<Button>();
			InputFieldEntry inputFieldEntry = val.AddComponent<InputFieldEntry>();
			GameObject val3 = TMP_DefaultControls.CreateInputField(default(Resources));
			((Object)val3).name = "InputField";
			val3.transform.SetParent(val.transform, false);
			val3.transform.localPosition = Vector3.zero;
			val3.transform.localScale = Vector3.one;
			inputFieldEntry.button = button;
			inputFieldEntry.inputField = val3.GetComponent<TMP_InputField>();
			return inputFieldEntry;
		}

		internal void SetupNavigation(List<GameObject> entries)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			for (int i = 0; i < entries.Count; i++)
			{
				Button component = entries[i].GetComponent<Button>();
				Navigation navigation = ((Selectable)component).navigation;
				((Navigation)(ref navigation)).mode = (Mode)4;
				((Navigation)(ref navigation)).selectOnRight = null;
				((Navigation)(ref navigation)).selectOnLeft = null;
				((Navigation)(ref navigation)).selectOnUp = null;
				((Navigation)(ref navigation)).selectOnDown = null;
				if (i > 0)
				{
					Button component2 = entries[i - 1].GetComponent<Button>();
					((Navigation)(ref navigation)).selectOnUp = (Selectable)(object)component2;
				}
				if (i < entries.Count - 1)
				{
					Button component3 = entries[i + 1].GetComponent<Button>();
					((Navigation)(ref navigation)).selectOnDown = (Selectable)(object)component3;
				}
				((Selectable)component).navigation = navigation;
			}
		}
	}
	internal class ArchipelagoVersionLabel : MonoBehaviour
	{
		internal Text text;

		private Font font;

		internal Font Font
		{
			get
			{
				return font;
			}
			set
			{
				font = value;
				UpdateText();
			}
		}

		private void Awake()
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			((Component)this).transform.localPosition = new Vector3(-265f, -115f, 0f);
			text = ((Component)this).gameObject.AddComponent<Text>();
			UpdateText();
		}

		internal void UpdateText()
		{
			text.text = "AP Mod v0.0.0";
			text.fontSize = 12;
			text.font = font;
			text.alignment = (TextAnchor)6;
		}
	}
	internal class ConnectionUI : MonoBehaviour
	{
		private Rect windowRect = new Rect(20f, 20f, 400f, 400f);

		private string host = "localhost";

		private string port = "38281";

		private string slot = "Player1";

		private string password = "";

		private string statusMessage = "";

		internal bool showWindow = false;

		private void Update()
		{
			if (Input.GetKeyDown((KeyCode)282))
			{
				if (showWindow)
				{
					Hide();
				}
				else
				{
					Show();
				}
			}
		}

		private void OnGUI()
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Expected O, but got Unknown
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			if (showWindow)
			{
				windowRect = GUILayout.Window(0, windowRect, new WindowFunction(DrawWindow), "Archipelago Connection [F1 to show/hide]", Array.Empty<GUILayoutOption>());
			}
		}

		internal void Show()
		{
			showWindow = true;
			Cursor.visible = true;
		}

		internal void Hide()
		{
			showWindow = false;
			Cursor.visible = false;
		}

		private void DrawWindow(int id)
		{
			GUILayout.Label("Host", Array.Empty<GUILayoutOption>());
			host = GUILayout.TextField(host, Array.Empty<GUILayoutOption>());
			GUILayout.Label("Port", Array.Empty<GUILayoutOption>());
			port = GUILayout.TextField(port, Array.Empty<GUILayoutOption>());
			GUILayout.Label("Slot Name", Array.Empty<GUILayoutOption>());
			slot = GUILayout.TextField(slot, Array.Empty<GUILayoutOption>());
			GUILayout.Label("Password (optional)", Array.Empty<GUILayoutOption>());
			password = GUILayout.PasswordField(password, '*', Array.Empty<GUILayoutOption>());
			GUILayout.Space(10f);
			if (!ArchipelagoClient.IsClientConnected)
			{
				if (GUILayout.Button("Connect", Array.Empty<GUILayoutOption>()))
				{
					Connect();
				}
			}
			else if (GUILayout.Button("Disconnect", Array.Empty<GUILayoutOption>()))
			{
				Disconnect();
			}
			GUILayout.Space(10f);
			GUILayout.Label(statusMessage, Array.Empty<GUILayoutOption>());
			GUI.DragWindow();
		}

		private void Connect()
		{
			int.TryParse(port, out var result);
			MoonlighterAPMod.client.Connect(host, result, slot, password);
		}

		private void Disconnect()
		{
			MoonlighterAPMod.client.Disconnect();
			statusMessage = "Disconnected.";
		}

		internal void ShowError(string errorMsg)
		{
			statusMessage = errorMsg;
		}

		internal void ShowSuccess(string successMsg = "")
		{
			statusMessage = successMsg ?? "Connected.";
		}
	}
	internal class InputFieldEntry : MonoBehaviour
	{
		internal Button button;

		internal TMP_InputField inputField;

		private void Awake()
		{
			if ((Object)(object)button == (Object)null)
			{
				button = ((Component)this).GetComponent<Button>();
			}
			if ((Object)(object)inputField == (Object)null)
			{
				inputField = ((Component)this).GetComponentInChildren<TMP_InputField>(true);
			}
		}

		internal void EnterInput()
		{
			if (!((Object)(object)inputField == (Object)null))
			{
				EventSystem.current.SetSelectedGameObject(((Component)inputField).gameObject);
				inputField.ActivateInputField();
				inputField.caretPosition = inputField.text.Length;
			}
		}

		internal void ExitInput()
		{
			if (!((Object)(object)inputField == (Object)null))
			{
				inputField.DeactivateInputField();
				EventSystem.current.SetSelectedGameObject(((Component)button).gameObject);
			}
		}
	}
	internal class MainMenuButton : MonoBehaviour
	{
		private Selectable previous;

		private Selectable next;

		private Button button;

		internal event Action OnClick;

		private void Start()
		{
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Expected O, but got Unknown
			button = ((Component)this).gameObject.GetComponent<Button>();
			((UnityEventBase)button.onClick).RemoveAllListeners();
			UIManager.ClearPersistentEvents((UnityEventBase)(object)button.onClick);
			((UnityEvent)button.onClick).AddListener(new UnityAction(OnSelect));
			if ((Object)(object)next == (Object)null)
			{
				InsertNavigation();
				UpdatePositions();
			}
		}

		private void OnSelect()
		{
			this.OnClick();
		}

		private void InsertNavigation()
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			Navigation val = previous.navigation;
			next = ((Navigation)(ref val)).selectOnDown;
			val = default(Navigation);
			((Navigation)(ref val)).mode = (Mode)4;
			((Navigation)(ref val)).selectOnUp = previous;
			((Navigation)(ref val)).selectOnDown = next;
			((Navigation)(ref val)).selectOnLeft = null;
			((Navigation)(ref val)).selectOnRight = null;
			Navigation navigation = val;
			((Selectable)button).navigation = navigation;
			Navigation navigation2 = previous.navigation;
			((Navigation)(ref navigation2)).selectOnDown = (Selectable)(object)button;
			previous.navigation = navigation2;
			Navigation navigation3 = next.navigation;
			((Navigation)(ref navigation3)).selectOnUp = (Selectable)(object)button;
			next.navigation = navigation3;
		}

		private void UpdatePositions()
		{
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			Selectable selectOnDown = (Selectable)(object)button;
			while ((Object)(object)selectOnDown != (Object)null && !((object)selectOnDown).Equals((object?)button))
			{
				MoonlighterAPMod.APInfo("Moving " + ((Object)((Component)selectOnDown).transform).name + " down..");
				Transform transform = ((Component)selectOnDown).transform;
				transform.position += new Vector3(0f, -60f, 0f);
				Navigation navigation = selectOnDown.navigation;
				selectOnDown = ((Navigation)(ref navigation)).selectOnDown;
			}
		}

		internal void SetPrevious(Selectable previous)
		{
			this.previous = previous;
		}

		internal void SetName(string name)
		{
			((Object)((Component)this).gameObject).name = name;
			Text component = ((Component)this).gameObject.GetComponent<Text>();
			if (component != null)
			{
				component.text = name;
			}
		}
	}
	internal class UIManager : MonoBehaviour
	{
		internal static UIManager Instance;

		internal ArchipelagoOptionsPanel archipelagoOptionsPanel;

		internal ArchipelagoVersionLabel archipelagoVersionLabel;

		internal MainMenuButton archipelagoMenuButton;

		internal Font font;

		private MainMenuPanel mainMenuPanel;

		private void Awake()
		{
			if ((Object)(object)Instance == (Object)null)
			{
				Instance = this;
			}
			else if ((Object)(object)Instance != (Object)(object)this)
			{
				Object.Destroy((Object)(object)((Component)this).gameObject);
			}
		}

		internal void CreateOptionsPanel()
		{
			MoonlighterAPMod.APInfo("Creating AP options panel...");
			GameObject val = GameObject.Find("PopUps");
			GameObject gameObject = ((Component)val.transform.Find("PopUp - Options(Clone)")).gameObject;
			GameObject val2 = Object.Instantiate<GameObject>(gameObject, val.transform);
			Object.Destroy((Object)(object)val2.GetComponent<OptionsPanel>());
			Transform val3 = gameObject.transform.Find("Content");
			Transform obj = val3.Find("Image - Base");
			Object.Destroy((Object)(object)((obj != null) ? ((Component)obj).gameObject : null));
			Transform obj2 = val3.Find("Image - Line");
			Object.Destroy((Object)(object)((obj2 != null) ? ((Component)obj2).gameObject : null));
			Transform obj3 = val3.Find("Tabs");
			Object.Destroy((Object)(object)((obj3 != null) ? ((Component)obj3).gameObject : null));
			Transform obj4 = val3.Find("Contents");
			Object.Destroy((Object)(object)((obj4 != null) ? ((Component)obj4).gameObject : null));
			archipelagoOptionsPanel = val2.AddComponent<ArchipelagoOptionsPanel>();
		}

		internal void CreateOrUpdateVersionLabel(Transform parent)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Expected O, but got Unknown
			MoonlighterAPMod.APInfo("Creating AP version label...");
			GameObject val = new GameObject("APVersionLabel");
			val.transform.SetParent(parent, false);
			archipelagoVersionLabel = val.AddComponent<ArchipelagoVersionLabel>();
			MoonlighterAPMod.APInfo("Finding and saving font...");
			Transform val2 = parent.Find("VersionInfoLabel");
			Text component = ((Component)val2).gameObject.GetComponent<Text>();
			archipelagoVersionLabel.Font = component.font;
		}

		internal void CreateOrUpdateArchipelagoMenuButton(MainMenuPanel mainMenuPanel)
		{
			this.mainMenuPanel = mainMenuPanel;
			GameObject val = mainMenuPanel.mainMenuButtons[2];
			Transform val2 = ((Component)mainMenuPanel).transform.Find("MainMenuButtons");
			GameObject val3 = Object.Instantiate<GameObject>(val, val2);
			archipelagoMenuButton = val3.AddComponent<MainMenuButton>();
			archipelagoMenuButton.SetName("Archipelago");
			archipelagoMenuButton.SetPrevious((Selectable)(object)val.GetComponent<Button>());
			archipelagoMenuButton.OnClick += OpenArchipelagoPanel;
			mainMenuPanel.mainMenuButtons.Add(val3);
		}

		internal void OpenArchipelagoPanel()
		{
			GUIManager.Instance.currentPopUp = (Panel)(object)archipelagoOptionsPanel;
			((Panel)archipelagoOptionsPanel).Enable();
			((Panel)mainMenuPanel).Disable();
		}

		internal void CloseArchipelagoPanel()
		{
			GUIManager.Instance.currentPopUp = null;
			((Panel)archipelagoOptionsPanel).Disable();
		}

		internal static void ClearPersistentEvents(UnityEventBase eventData)
		{
			object obj = typeof(UnityEventBase).GetField("m_PersistentCalls", BindingFlags.Instance | BindingFlags.NonPublic)?.GetValue(eventData);
			MethodInfo methodInfo = obj?.GetType().GetMethod("RemoveListener", BindingFlags.Instance | BindingFlags.Public);
			int persistentEventCount = eventData.GetPersistentEventCount();
			for (int num = persistentEventCount - 1; num >= 0; num--)
			{
				methodInfo?.Invoke(obj, new object[1] { num });
			}
		}
	}
}
namespace MoonlighterAPMod.Archipelago
{
	internal class ArchipelagoClient
	{
		private readonly ArchipelagoConnector _connector = new ArchipelagoConnector();

		private ILocationCheckHelper Locations => _connector.Session.Locations;

		private IReceivedItemsHelper Items => _connector.Session.Items;

		internal int Slot => _connector.Session.ConnectionInfo.Slot;

		internal string Seed => _connector.Session.RoomState.Seed;

		internal static bool IsClientConnected => MoonlighterAPMod.client._connector.IsConnected;

		internal static Dictionary<string, object> SlotData => MoonlighterAPMod.client._connector.SlotData;

		internal async Task Connect(string hostname, int port, string slotName, string password = "")
		{
			await _connector.Connect(hostname, port, slotName, password);
			if (IsClientConnected)
			{
				Items.ItemReceived += new ItemReceivedHandler(OnItemReceived);
			}
		}

		internal async Task Disconnect()
		{
			await _connector.Disconnect();
		}

		internal void SetDeathLink(bool deathLink)
		{
			if (IsClientConnected)
			{
				_connector.SetDeathLink(deathLink);
			}
		}

		internal async Task SendLocation(long locationId)
		{
			await SendLocations(new long[1] { locationId });
		}

		internal async Task SendLocations(long[] locationIds)
		{
			if (IsClientConnected)
			{
				await Locations.CompleteLocationChecksAsync(locationIds);
			}
		}

		internal async Task ScoutLocations(long[] locationIds)
		{
			if (IsClientConnected)
			{
				Dictionary<long, ScoutedItemInfo> locationData = LocationScoutCache.Get(locationIds);
				if (locationData == null)
				{
					LocationScoutCache.Set(await _connector.Session.Locations.ScoutLocationsAsync((HintCreationPolicy)0, locationIds));
				}
			}
		}

		internal bool IsLocationChecked(long locationId)
		{
			if (!IsClientConnected)
			{
				return false;
			}
			return Locations.AllLocationsChecked.Contains(locationId);
		}

		private void OnItemReceived(ReceivedItemsHelper helper)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			while (Items.PeekItem() != null)
			{
				ItemInfo val = Items.DequeueItem();
				if (((Enum)val.Flags).HasFlag((Enum)(object)(ItemFlags)4))
				{
					ItemHelper.ReceiveTrap(val.ItemId, val.ItemName);
				}
				else
				{
					ItemHelper.ReceiveItem(val.ItemId, val.ItemName);
				}
			}
		}

		internal ReadOnlyCollection<ItemInfo> GetAllReceivedItems()
		{
			return Items.AllItemsReceived;
		}

		internal void Goal()
		{
			_connector.Session.SetGoalAchieved();
		}
	}
	internal class ArchipelagoConnector
	{
		internal ArchipelagoSession Session { get; private set; }

		internal Dictionary<string, object> SlotData { get; private set; }

		internal bool IsConnected
		{
			get
			{
				ArchipelagoSession session = Session;
				return session != null && session.Socket.Connected;
			}
		}

		internal async Task Connect(string hostname, int port, string slotName, string password = "")
		{
			MoonlighterAPMod.APInfo($"Attempting to connect to {hostname}:{port} as {slotName}");
			Session = ArchipelagoSessionFactory.CreateSession(hostname, port);
			try
			{
				await Session.ConnectAsync();
			}
			catch (Exception)
			{
				OnLoginFailure();
				return;
			}
			LoginResult result = await Session.LoginAsync("Moonlighter", slotName, (ItemsHandlingFlags)7, new Version(0, 6, 7), (string[])null, (string)null, string.IsNullOrEmpty(password) ? null : password, true);
			if (!result.Successful)
			{
				OnLoginFailure((LoginFailure)result);
			}
			else
			{
				OnLoginSuccessful((LoginSuccessful)result);
			}
		}

		internal async Task Disconnect()
		{
			await Session.Socket.DisconnectAsync();
		}

		private void OnLoginFailure(LoginFailure failureResult = null)
		{
			string text = ((failureResult == null) ? "Connection timed out." : string.Join(", ", failureResult.Errors));
			text = "Connection failed: " + text;
			MoonlighterAPMod.APError(text);
			MoonlighterAPMod.connectionUI.ShowError(text);
			Session = null;
		}

		private void OnLoginSuccessful(LoginSuccessful successResult)
		{
			string text = $"Connected to slot {successResult.Slot} for team {successResult.Team}!";
			MoonlighterAPMod.APInfo(text);
			SlotData = successResult.SlotData;
			MoonlighterAPMod.connectionUI.ShowSuccess(text);
		}

		internal void SetDeathLink(bool deathLink)
		{
			Session.ConnectionInfo.UpdateConnectionOptions((!deathLink) ? Array.Empty<string>() : new string[1] { "DeathLink" });
		}
	}
	internal class GoalHelper
	{
		internal enum GoalType
		{
			Unknown = -1,
			FifthDungeon,
			PirateBoss,
			Collector
		}

		internal static void TrySendGoal(GoalType type)
		{
			if (ArchipelagoClient.IsClientConnected && type == OptionsHelper.Goal)
			{
				MoonlighterAPMod.APInfo($"Achieved player goal {type}");
				MoonlighterAPMod.client.Goal();
			}
		}
	}
	internal class ItemHelper
	{
		internal static bool HasItem(string itemName)
		{
			return HasItems(new string[1] { itemName });
		}

		internal static bool HasItem(long itemId)
		{
			return HasItems(new long[1] { itemId });
		}

		internal static bool HasItems(string[] itemNames)
		{
			ReadOnlyCollection<ItemInfo> allReceivedItems = MoonlighterAPMod.client.GetAllReceivedItems();
			foreach (string name in itemNames)
			{
				if (Extensions.FirstOrDefault<ItemInfo>((IEnumerable<ItemInfo>)allReceivedItems, (Func<ItemInfo, bool>)((ItemInfo item) => item.ItemName == name)) == null)
				{
					return false;
				}
			}
			return true;
		}

		internal static bool HasItems(long[] itemIds)
		{
			ReadOnlyCollection<ItemInfo> allReceivedItems = MoonlighterAPMod.client.GetAllReceivedItems();
			foreach (long id in itemIds)
			{
				if (Extensions.FirstOrDefault<ItemInfo>((IEnumerable<ItemInfo>)allReceivedItems, (Func<ItemInfo, bool>)((ItemInfo item) => item.ItemId == id)) == null)
				{
					return false;
				}
			}
			return true;
		}

		internal static void ReceiveItem(long itemId, string itemName)
		{
		}

		internal static void ReceiveTrap(long itemId, string itemName)
		{
		}
	}
	internal class LocationHelper
	{
		internal static void SendLocation(long locationId)
		{
			MoonlighterAPMod.client.SendLocation(locationId);
		}

		internal static bool IsChecked(long locationId)
		{
			return MoonlighterAPMod.client.IsLocationChecked(locationId);
		}
	}
	internal static class LocationScoutCache
	{
		private class LocationScoutCacheEntry
		{
			private readonly Dictionary<long, ScoutedItemInfo> _entries = new Dictionary<long, ScoutedItemInfo>();

			internal Dictionary<long, ScoutedItemInfo> Get(long[] locationIds)
			{
				Dictionary<long, ScoutedItemInfo> dictionary = new Dictionary<long, ScoutedItemInfo>();
				foreach (long key in locationIds)
				{
					if (!_entries.ContainsKey(key))
					{
						return null;
					}
					dictionary[key] = _entries[key];
				}
				return dictionary;
			}

			internal void Set(Dictionary<long, ScoutedItemInfo> entries)
			{
				foreach (long key in entries.Keys)
				{
					_entries[key] = entries[key];
				}
			}
		}

		private static readonly Dictionary<string, LocationScoutCacheEntry> _cache = new Dictionary<string, LocationScoutCacheEntry>();

		private static string GetSlotKey()
		{
			if (!ArchipelagoClient.IsClientConnected)
			{
				return null;
			}
			return $"{MoonlighterAPMod.client.Seed}-{MoonlighterAPMod.client.Slot}";
		}

		internal static Dictionary<long, ScoutedItemInfo> Get(long[] locationIds)
		{
			string slotKey = GetSlotKey();
			if (slotKey == null)
			{
				return null;
			}
			if (!_cache.ContainsKey(slotKey))
			{
				return null;
			}
			return _cache[slotKey].Get(locationIds);
		}

		internal static void Set(Dictionary<long, ScoutedItemInfo> locationInfo)
		{
			string slotKey = GetSlotKey();
			if (slotKey != null)
			{
				if (!_cache.ContainsKey(slotKey))
				{
					_cache[slotKey] = new LocationScoutCacheEntry();
				}
				_cache[slotKey].Set(locationInfo);
			}
		}
	}
	internal class OptionsHelper
	{
		private static JObject Options => ArchipelagoClient.IsClientConnected ? ((JObject)ArchipelagoClient.SlotData["options"]) : new JObject();

		internal static GoalHelper.GoalType Goal
		{
			get
			{
				JToken option = GetOption("goal");
				return (option != null) ? ((GoalHelper.GoalType)Extensions.Value<int>((IEnumerable<JToken>)option)) : GoalHelper.GoalType.Unknown;
			}
		}

		internal static bool IsDeathLink
		{
			get
			{
				JToken option = GetOption("death_link");
				return option != null && Extensions.Value<int>((IEnumerable<JToken>)option) != 0;
			}
		}

		private static JToken GetOption(string name)
		{
			return Options[name];
		}
	}
}