using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Security;
using System.Security.Permissions;
using System.Text;
using System.Text.RegularExpressions;
using Archipelago.MultiClient.Net;
using Archipelago.MultiClient.Net.Colors;
using Archipelago.MultiClient.Net.Converters;
using Archipelago.MultiClient.Net.Enums;
using Archipelago.MultiClient.Net.Helpers;
using Archipelago.MultiClient.Net.MessageLog.Messages;
using Archipelago.MultiClient.Net.MessageLog.Parts;
using Archipelago.MultiClient.Net.Models;
using Archipelago.MultiClient.Net.Packets;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Newtonsoft.Json.Linq;
using Pikuniku.Achievements;
using Pikuniku.Drawing;
using Pikuniku.Persistence;
using Rewired;
using TMPro;
using UnityEngine;
using UnityEngine.EventSystems;
using UnityEngine.Events;
using UnityEngine.SceneManagement;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: IgnoresAccessChecksTo("Assembly-CSharp")]
[assembly: AssemblyCompany("PikunikuAPMod")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+769ef2132f199e35f20c8a16e601f4740d45f8b9")]
[assembly: AssemblyProduct("PikunikuAPMod")]
[assembly: AssemblyTitle("PikunikuAPMod")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class IsReadOnlyAttribute : Attribute
	{
	}
	[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 PikunikuAPMod
{
	public class APConnectionPanel : UI_MenuPanel
	{
		private class NavVisual
		{
			public Selectable Selectable;

			public RectTransform Rect;

			public Image Background;

			public Outline Outline;

			public Shadow Shadow;

			public Vector2 CurrentOffset = Vector2.zero;

			public Vector2 CurrentShadowDist = Vector2.zero;

			public float CurrentShadowAlpha;
		}

		internal UI_MenuPanel_Aventure AventurePanel;

		private TMP_InputField _hostnameField;

		private TMP_InputField _portField;

		private TMP_InputField _slotField;

		private TMP_InputField _passwordField;

		private TextMeshProUGUI _statusText;

		private TMP_FontAsset _gameFont;

		private Sprite _bgSprite;

		private NavVisual[] _nav;

		private int _navIndex;

		private static readonly Color NormalBg = Color.white;

		private static readonly Color NormalOutline = Color.black;

		private static readonly Vector2 NormalOutlineDist = new Vector2(4f, -4f);

		private static readonly Color SolidShadowColor = new Color(0f, 0f, 0f, 1f);

		private static readonly Vector2 SolidShadowDist = new Vector2(8f, -8f);

		private static readonly Vector2 SelectedOffset = new Vector2(-4f, 4f);

		public static APConnectionPanel Instance { get; private set; }

		public static APConnectionPanel CreateFor(UI_PauseMenu pauseMenu, UI_MenuPanel_Aventure aventurePanel)
		{
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Expected O, but got Unknown
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: 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)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0109: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: Unknown result type (might be due to invalid IL or missing references)
			//IL_0145: Unknown result type (might be due to invalid IL or missing references)
			//IL_0189: Unknown result type (might be due to invalid IL or missing references)
			//IL_018f: Invalid comparison between Unknown and I4
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_0193: Unknown result type (might be due to invalid IL or missing references)
			//IL_0199: Invalid comparison between Unknown and I4
			//IL_0292: Unknown result type (might be due to invalid IL or missing references)
			//IL_029c: Expected O, but got Unknown
			//IL_02a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ac: Expected O, but got Unknown
			//IL_02b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02bc: Expected O, but got Unknown
			//IL_02c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02cc: Expected O, but got Unknown
			//IL_02de: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e8: Expected O, but got Unknown
			//IL_02fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0304: Expected O, but got Unknown
			//IL_01d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01de: Unknown result type (might be due to invalid IL or missing references)
			//IL_01eb: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)Instance != (Object)null)
			{
				return Instance;
			}
			Transform parent = ((Transform)((UI_MenuPanel)aventurePanel).selfRect).parent;
			GameObject val = new GameObject("APConnectionPanel");
			RectTransform val2 = val.AddComponent<RectTransform>();
			((Transform)val2).SetParent(parent, false);
			RectTransform selfRect = ((UI_MenuPanel)aventurePanel).selfRect;
			RectTransform component = ((Component)parent).GetComponent<RectTransform>();
			float num;
			if ((Object)(object)component != (Object)null)
			{
				Rect rect = component.rect;
				if (((Rect)(ref rect)).height > 1f)
				{
					rect = component.rect;
					num = ((Rect)(ref rect)).height;
					goto IL_008e;
				}
			}
			num = 720f;
			goto IL_008e;
			IL_008e:
			float num2 = num;
			val2.anchorMin = new Vector2(selfRect.anchorMin.x, 0.5f);
			val2.anchorMax = new Vector2(selfRect.anchorMax.x, 0.5f);
			val2.pivot = selfRect.pivot;
			val2.sizeDelta = new Vector2(selfRect.sizeDelta.x, num2);
			val2.anchoredPosition = Vector2.zero;
			((Transform)val2).localScale = ((Transform)selfRect).localScale;
			((Transform)val2).localPosition = ((Transform)selfRect).localPosition;
			((Transform)val2).localRotation = ((Transform)selfRect).localRotation;
			val.layer = ((Component)aventurePanel).gameObject.layer;
			Canvas selfCanvas = ((UI_MenuPanel)aventurePanel).selfCanvas;
			Canvas val3 = val.AddComponent<Canvas>();
			val3.renderMode = selfCanvas.renderMode;
			val3.sortingOrder = selfCanvas.sortingOrder;
			val3.sortingLayerID = selfCanvas.sortingLayerID;
			val3.overrideSorting = selfCanvas.overrideSorting;
			val3.pixelPerfect = selfCanvas.pixelPerfect;
			if ((int)selfCanvas.renderMode == 1 || (int)selfCanvas.renderMode == 2)
			{
				val3.worldCamera = selfCanvas.worldCamera;
			}
			((Behaviour)val3).enabled = false;
			CanvasScaler component2 = ((Component)((UI_MenuPanel)aventurePanel).selfCanvas).GetComponent<CanvasScaler>();
			if ((Object)(object)component2 != (Object)null)
			{
				CanvasScaler obj = val.AddComponent<CanvasScaler>();
				obj.uiScaleMode = component2.uiScaleMode;
				obj.referenceResolution = component2.referenceResolution;
				obj.screenMatchMode = component2.screenMatchMode;
				obj.matchWidthOrHeight = component2.matchWidthOrHeight;
				obj.referencePixelsPerUnit = component2.referencePixelsPerUnit;
			}
			val.AddComponent<GraphicRaycaster>();
			CanvasGroup val4 = val.AddComponent<CanvasGroup>();
			val4.interactable = false;
			APConnectionPanel panel = val.AddComponent<APConnectionPanel>();
			((UI_MenuPanel)panel).manager = pauseMenu;
			((UI_MenuPanel)panel).selfRect = val2;
			((UI_MenuPanel)panel).selfCanvas = val3;
			((UI_MenuPanel)panel).canvasGroup = val4;
			((UI_MenuPanel)panel).FullGameObject = val;
			((UI_MenuPanel)panel).allowBackButton = true;
			panel.AventurePanel = aventurePanel;
			((UI_MenuPanel)panel).OnBackButton = new UnityEvent();
			((UI_MenuPanel)panel).OnPreEnableEvent = new UnityEvent();
			((UI_MenuPanel)panel).OnEnableEvent = new UnityEvent();
			((UI_MenuPanel)panel).OnDisableEvent = new UnityEvent();
			((UI_MenuPanel)panel).OnBackButton.AddListener((UnityAction)delegate
			{
				pauseMenu.SwitchToPanelFromBack((UI_MenuPanel)(object)panel);
			});
			((UI_MenuPanel)panel).OnPreEnableEvent.AddListener((UnityAction)delegate
			{
				if ((Object)(object)panel._statusText != (Object)null)
				{
					((TMP_Text)panel._statusText).text = string.Empty;
				}
			});
			panel.GrabGameStyle(aventurePanel);
			panel.BuildUI();
			ArchipelagoHandler archipelagoHandler = PikunikuAPMod.ArchipelagoHandler;
			if ((Object)(object)archipelagoHandler != (Object)null)
			{
				archipelagoHandler.OnConnected += panel.OnConnected;
				archipelagoHandler.OnConnectionFailed += panel.OnConnectionFailed;
			}
			Instance = panel;
			Log.Info("APConnectionPanel created as sibling of adventure panel.");
			return panel;
		}

		private void OnDestroy()
		{
			ArchipelagoHandler archipelagoHandler = PikunikuAPMod.ArchipelagoHandler;
			if ((Object)(object)archipelagoHandler != (Object)null)
			{
				archipelagoHandler.OnConnected -= OnConnected;
				archipelagoHandler.OnConnectionFailed -= OnConnectionFailed;
			}
			Instance = null;
		}

		public override void CustomPanelUpdate()
		{
			UpdateAnimation();
			if (_nav == null || _nav.Length == 0)
			{
				return;
			}
			SyncIndexFromEventSystem();
			bool flag = Input.GetKeyDown((KeyCode)274) || RewiredNavDown();
			bool flag2 = Input.GetKeyDown((KeyCode)273) || RewiredNavUp();
			if (Input.GetKeyDown((KeyCode)9))
			{
				if (Input.GetKey((KeyCode)304) || Input.GetKey((KeyCode)303))
				{
					flag2 = true;
				}
				else
				{
					flag = true;
				}
			}
			if (flag)
			{
				Move(1);
			}
			else if (flag2)
			{
				Move(-1);
			}
			ApplyHighlight();
		}

		private void Move(int delta)
		{
			int num = _nav.Length;
			int num2 = _navIndex;
			for (int i = 0; i < num; i++)
			{
				num2 = (num2 + delta + num) % num;
				if ((Object)(object)_nav[num2]?.Selectable != (Object)null && _nav[num2].Selectable.IsInteractable())
				{
					break;
				}
			}
			SelectIndex(num2);
		}

		private void SelectIndex(int i)
		{
			if (_nav == null || i < 0 || i >= _nav.Length)
			{
				return;
			}
			NavVisual[] nav = _nav;
			for (int j = 0; j < nav.Length; j++)
			{
				Selectable obj = nav[j]?.Selectable;
				TMP_InputField val = (TMP_InputField)(object)((obj is TMP_InputField) ? obj : null);
				if (val != null && val.isFocused)
				{
					val.DeactivateInputField();
				}
			}
			_navIndex = i;
			Selectable selectable = _nav[i].Selectable;
			if ((Object)(object)EventSystem.current != (Object)null)
			{
				EventSystem.current.SetSelectedGameObject(((Component)selectable).gameObject);
			}
			TMP_InputField val2 = (TMP_InputField)(object)((selectable is TMP_InputField) ? selectable : null);
			if (val2 != null)
			{
				val2.ActivateInputField();
				val2.MoveTextEnd(false);
			}
			ApplyHighlight();
		}

		private void SyncIndexFromEventSystem()
		{
			GameObject val = (((Object)(object)EventSystem.current != (Object)null) ? EventSystem.current.currentSelectedGameObject : null);
			if ((Object)(object)val == (Object)null)
			{
				return;
			}
			for (int i = 0; i < _nav.Length; i++)
			{
				if ((Object)(object)_nav[i]?.Selectable != (Object)null && (Object)(object)((Component)_nav[i].Selectable).gameObject == (Object)(object)val)
				{
					_navIndex = i;
					break;
				}
			}
		}

		private void ApplyHighlight()
		{
		}

		private void UpdateAnimation()
		{
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: 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_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_016f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0180: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_0128: Unknown result type (might be due to invalid IL or missing references)
			//IL_013f: Unknown result type (might be due to invalid IL or missing references)
			//IL_014f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ad: Unknown result type (might be due to invalid IL or missing references)
			if (_nav == null)
			{
				return;
			}
			float unscaledDeltaTime = Time.unscaledDeltaTime;
			float num = 60f;
			float num2 = 120f;
			float num3 = 10f;
			for (int i = 0; i < _nav.Length; i++)
			{
				NavVisual navVisual = _nav[i];
				if (navVisual == null)
				{
					continue;
				}
				bool num4 = i == _navIndex;
				Vector2 val = (num4 ? SelectedOffset : Vector2.zero);
				Vector2 val2 = (num4 ? SolidShadowDist : Vector2.zero);
				float num5 = (num4 ? 1f : 0f);
				navVisual.CurrentOffset = Vector2.MoveTowards(navVisual.CurrentOffset, val, unscaledDeltaTime * num);
				navVisual.CurrentShadowDist = Vector2.MoveTowards(navVisual.CurrentShadowDist, val2, unscaledDeltaTime * num2);
				navVisual.CurrentShadowAlpha = Mathf.MoveTowards(navVisual.CurrentShadowAlpha, num5, unscaledDeltaTime * num3);
				if ((Object)(object)navVisual.Rect != (Object)null)
				{
					navVisual.Rect.anchoredPosition = navVisual.CurrentOffset;
					((Transform)navVisual.Rect).localScale = Vector3.one;
				}
				if ((Object)(object)navVisual.Shadow != (Object)null)
				{
					bool flag = navVisual.CurrentShadowAlpha > 0.01f;
					((Behaviour)navVisual.Shadow).enabled = flag;
					if (flag)
					{
						Color solidShadowColor = SolidShadowColor;
						solidShadowColor.a = navVisual.CurrentShadowAlpha;
						navVisual.Shadow.effectColor = solidShadowColor;
						navVisual.Shadow.effectDistance = navVisual.CurrentShadowDist;
					}
				}
				if ((Object)(object)navVisual.Outline != (Object)null)
				{
					((Shadow)navVisual.Outline).effectColor = NormalOutline;
					((Shadow)navVisual.Outline).effectDistance = NormalOutlineDist;
					((Behaviour)navVisual.Outline).enabled = true;
				}
				if ((Object)(object)navVisual.Background != (Object)null)
				{
					((Graphic)navVisual.Background).color = NormalBg;
				}
			}
		}

		private static NavVisual BuildNavVisual(Selectable sel)
		{
			GameObject gameObject = ((Component)sel).gameObject;
			NavVisual navVisual = new NavVisual
			{
				Selectable = sel,
				Rect = gameObject.GetComponent<RectTransform>(),
				Background = gameObject.GetComponent<Image>(),
				Outline = gameObject.GetComponent<Outline>()
			};
			Shadow[] components = gameObject.GetComponents<Shadow>();
			foreach (Shadow val in components)
			{
				if (!(val is Outline))
				{
					navVisual.Shadow = val;
					break;
				}
			}
			return navVisual;
		}

		private void WireSubmitAdvance(TMP_InputField field, int indexOfField)
		{
			((UnityEvent<string>)(object)field.onSubmit).AddListener((UnityAction<string>)delegate
			{
				SelectIndex(Mathf.Min(indexOfField + 1, _nav.Length - 1));
			});
		}

		private static Player GetRewiredPlayer()
		{
			if ((Object)(object)PlayerManager.S == (Object)null)
			{
				return null;
			}
			PlayerClass player = PlayerManager.S.GetPlayer(0);
			if (player == null)
			{
				return null;
			}
			return player.GetRewiredPlayer();
		}

		private static bool RewiredNavUp()
		{
			Player rewiredPlayer = GetRewiredPlayer();
			if (rewiredPlayer != null)
			{
				return rewiredPlayer.GetButtonDown("UIVertical");
			}
			return false;
		}

		private static bool RewiredNavDown()
		{
			Player rewiredPlayer = GetRewiredPlayer();
			if (rewiredPlayer != null)
			{
				return rewiredPlayer.GetNegativeButtonDown("UIVertical");
			}
			return false;
		}

		private void OnConnected()
		{
			if ((Object)(object)AventurePanel != (Object)null)
			{
				AventurePanel.hasCheckedForAdventure = false;
				AventurePanel.CheckMainStory();
			}
			base.manager.SwitchToPanel((UI_MenuPanel)(object)AventurePanel);
		}

		private void OnConnectionFailed(string error)
		{
			if ((Object)(object)_statusText != (Object)null)
			{
				((TMP_Text)_statusText).text = "Failed: " + error;
			}
		}

		private void GrabGameStyle(UI_MenuPanel_Aventure aventurePanel)
		{
			TextMeshProUGUI componentInChildren = ((Component)((UI_MenuPanel)aventurePanel).selfCanvas).GetComponentInChildren<TextMeshProUGUI>(true);
			if ((Object)(object)componentInChildren != (Object)null)
			{
				_gameFont = ((TMP_Text)componentInChildren).font;
			}
			UI_Button[] array = Resources.FindObjectsOfTypeAll<UI_Button>();
			foreach (UI_Button val in array)
			{
				Image img_background = val.img_background;
				if ((Object)(object)((img_background != null) ? img_background.sprite : null) != (Object)null)
				{
					_bgSprite = val.img_background.sprite;
					break;
				}
			}
			Log.Info("APConnectionPanel style: font=" + (((Object)(object)_gameFont != (Object)null) ? ((Object)_gameFont).name : "null") + ", sprite=" + (((Object)(object)_bgSprite != (Object)null) ? ((Object)_bgSprite).name : "null"));
		}

		private void BuildUI()
		{
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: 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)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: Expected O, but got Unknown
			//IL_0286: Unknown result type (might be due to invalid IL or missing references)
			//IL_028b: Unknown result type (might be due to invalid IL or missing references)
			//IL_029c: Unknown result type (might be due to invalid IL or missing references)
			LastConnectionInfo lastConnectionInfo = FileWriter.ReadLastConnection();
			string defaultValue = Fallback(lastConnectionInfo?.Host, "archipelago.gg");
			string defaultValue2 = Fallback(lastConnectionInfo?.Port, "38281");
			string defaultValue3 = Fallback(lastConnectionInfo?.SlotName, "");
			string defaultValue4 = lastConnectionInfo?.Password ?? "";
			GameObject val = MakeRect("Container", ((Component)this).transform);
			RectTransform component = val.GetComponent<RectTransform>();
			Vector2 val2 = default(Vector2);
			((Vector2)(ref val2))..ctor(0.5f, 0.5f);
			component.pivot = val2;
			Vector2 anchorMin = (component.anchorMax = val2);
			component.anchorMin = anchorMin;
			component.anchoredPosition = new Vector2(0f, 15f);
			component.sizeDelta = new Vector2(560f, 660f);
			VerticalLayoutGroup obj = val.AddComponent<VerticalLayoutGroup>();
			((LayoutGroup)obj).childAlignment = (TextAnchor)1;
			((HorizontalOrVerticalLayoutGroup)obj).spacing = 10f;
			((HorizontalOrVerticalLayoutGroup)obj).childForceExpandWidth = true;
			((HorizontalOrVerticalLayoutGroup)obj).childForceExpandHeight = false;
			((LayoutGroup)obj).padding = new RectOffset(10, 10, 10, 10);
			AddSpacer(val.transform, 15f);
			AddTitle(val.transform, "Archipelago");
			AddSpacer(val.transform, 5f);
			AddHorizontalLine(val.transform, 8f);
			AddSpacer(val.transform, 10f);
			_hostnameField = AddInputRow(val.transform, "Host", defaultValue);
			_portField = AddInputRow(val.transform, "Port", defaultValue2);
			_slotField = AddInputRow(val.transform, "Slot Name", defaultValue3);
			_passwordField = AddInputRow(val.transform, "Password", defaultValue4, isPassword: true);
			AddSpacer(val.transform, 25f);
			Button val4 = AddConnectButton(val.transform);
			_statusText = AddStatusLabel(val.transform);
			Selectable[] array = (Selectable[])(object)new Selectable[5]
			{
				(Selectable)_hostnameField,
				(Selectable)_portField,
				(Selectable)_slotField,
				(Selectable)_passwordField,
				(Selectable)val4
			};
			_nav = new NavVisual[array.Length];
			for (int i = 0; i < array.Length; i++)
			{
				_nav[i] = BuildNavVisual(array[i]);
			}
			NavVisual[] nav = _nav;
			foreach (NavVisual navVisual in nav)
			{
				Navigation navigation = navVisual.Selectable.navigation;
				((Navigation)(ref navigation)).mode = (Mode)0;
				navVisual.Selectable.navigation = navigation;
				navVisual.Selectable.transition = (Transition)0;
				if ((Object)(object)navVisual.Shadow != (Object)null)
				{
					((Behaviour)navVisual.Shadow).enabled = false;
				}
			}
			WireSubmitAdvance(_hostnameField, 0);
			WireSubmitAdvance(_portField, 1);
			WireSubmitAdvance(_slotField, 2);
			WireSubmitAdvance(_passwordField, 3);
			base.toSelectFirst = ((Component)_hostnameField).gameObject;
			_navIndex = 0;
			ApplyHighlight();
		}

		private void AddTitle(Transform parent, string text)
		{
			//IL_0025: 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)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			GameObject obj = MakeRect("Title", parent);
			TextMeshProUGUI val = obj.AddComponent<TextMeshProUGUI>();
			((TMP_Text)val).text = text;
			((TMP_Text)val).fontSize = 65f;
			((Graphic)val).color = Color.black;
			((TMP_Text)val).fontStyle = (FontStyles)0;
			((TMP_Text)val).alignment = (TextAlignmentOptions)1028;
			ApplyFont(val);
			Shadow obj2 = obj.AddComponent<Shadow>();
			obj2.effectColor = new Color(1f, 1f, 1f, 0.8f);
			obj2.effectDistance = new Vector2(2f, -2f);
			obj.AddComponent<LayoutElement>().preferredHeight = 65f;
		}

		private TMP_InputField AddInputRow(Transform parent, string label, string defaultValue, bool isPassword = false)
		{
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_012a: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0159: Unknown result type (might be due to invalid IL or missing references)
			//IL_0164: Unknown result type (might be due to invalid IL or missing references)
			//IL_016e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0195: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0206: Unknown result type (might be due to invalid IL or missing references)
			//IL_0280: Unknown result type (might be due to invalid IL or missing references)
			//IL_02dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_02fd: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = MakeRect("Row_" + label, parent);
			VerticalLayoutGroup obj = val.AddComponent<VerticalLayoutGroup>();
			((LayoutGroup)obj).childAlignment = (TextAnchor)0;
			((HorizontalOrVerticalLayoutGroup)obj).spacing = 2f;
			((HorizontalOrVerticalLayoutGroup)obj).childForceExpandWidth = true;
			((HorizontalOrVerticalLayoutGroup)obj).childForceExpandHeight = false;
			val.AddComponent<LayoutElement>().preferredHeight = 90f;
			GameObject obj2 = MakeRect("Label_" + label, val.transform);
			TextMeshProUGUI val2 = obj2.AddComponent<TextMeshProUGUI>();
			((TMP_Text)val2).text = label;
			((TMP_Text)val2).fontSize = 30f;
			((Graphic)val2).color = Color.black;
			((TMP_Text)val2).alignment = (TextAlignmentOptions)513;
			ApplyFont(val2);
			obj2.AddComponent<LayoutElement>().preferredHeight = 30f;
			GameObject val3 = MakeRect("FieldWrapper_" + label, val.transform);
			val3.AddComponent<LayoutElement>().preferredHeight = 52f;
			GameObject val4 = MakeRect("Field_" + label, val3.transform);
			Image val5 = val4.AddComponent<Image>();
			((Graphic)val5).color = Color.white;
			if ((Object)(object)_bgSprite != (Object)null)
			{
				val5.sprite = _bgSprite;
				val5.type = (Type)1;
			}
			((Behaviour)val4.AddComponent<Shadow>()).enabled = false;
			Outline obj3 = val4.AddComponent<Outline>();
			((Shadow)obj3).effectColor = Color.black;
			((Shadow)obj3).effectDistance = new Vector2(4f, -4f);
			RectTransform component = val4.GetComponent<RectTransform>();
			component.anchorMin = new Vector2(0.3f, 0f);
			component.anchorMax = Vector2.one;
			component.sizeDelta = Vector2.zero;
			GameObject val6 = MakeRect("Viewport", val4.transform);
			RectTransform component2 = val6.GetComponent<RectTransform>();
			component2.anchorMin = Vector2.zero;
			component2.anchorMax = Vector2.one;
			component2.offsetMin = new Vector2(12f, 6f);
			component2.offsetMax = new Vector2(-12f, -6f);
			val6.AddComponent<RectMask2D>();
			GameObject obj4 = MakeRect("Text", val6.transform);
			TextMeshProUGUI val7 = obj4.AddComponent<TextMeshProUGUI>();
			((TMP_Text)val7).fontSize = 26f;
			((Graphic)val7).color = Color.black;
			((TMP_Text)val7).alignment = (TextAlignmentOptions)513;
			ApplyFont(val7);
			FillParent(obj4.GetComponent<RectTransform>());
			GameObject obj5 = MakeRect("Placeholder", val6.transform);
			TextMeshProUGUI val8 = obj5.AddComponent<TextMeshProUGUI>();
			((TMP_Text)val8).text = label.ToLower() + "...";
			((TMP_Text)val8).fontSize = 26f;
			((Graphic)val8).color = new Color(0.4f, 0.4f, 0.4f, 0.8f);
			((TMP_Text)val8).fontStyle = (FontStyles)2;
			((TMP_Text)val8).alignment = (TextAlignmentOptions)513;
			ApplyFont(val8);
			FillParent(obj5.GetComponent<RectTransform>());
			TMP_InputField val9 = val4.AddComponent<TMP_InputField>();
			val9.textViewport = component2;
			val9.textComponent = (TMP_Text)(object)val7;
			val9.placeholder = (Graphic)(object)val8;
			val9.text = defaultValue;
			val9.caretColor = Color.black;
			val9.selectionColor = new Color(0.3f, 0.6f, 1f, 0.4f);
			if (isPassword)
			{
				val9.inputType = (InputType)2;
			}
			return val9;
		}

		private Button AddConnectButton(Transform parent)
		{
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: 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)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_0162: Unknown result type (might be due to invalid IL or missing references)
			//IL_016c: Expected O, but got Unknown
			GameObject val = MakeRect("ButtonWrapper_Connect", parent);
			val.AddComponent<LayoutElement>().preferredHeight = 65f;
			GameObject val2 = MakeRect("Button_Connect", val.transform);
			RectTransform component = val2.GetComponent<RectTransform>();
			component.anchorMin = Vector2.zero;
			component.anchorMax = Vector2.one;
			component.sizeDelta = Vector2.zero;
			Image val3 = val2.AddComponent<Image>();
			((Graphic)val3).color = Color.white;
			if ((Object)(object)_bgSprite != (Object)null)
			{
				val3.sprite = _bgSprite;
				val3.type = (Type)1;
			}
			Outline obj = val2.AddComponent<Outline>();
			((Shadow)obj).effectColor = Color.black;
			((Shadow)obj).effectDistance = new Vector2(4f, -4f);
			Shadow obj2 = val2.AddComponent<Shadow>();
			obj2.effectColor = new Color(0f, 0f, 0f, 0.25f);
			obj2.effectDistance = new Vector2(3f, -3f);
			GameObject obj3 = MakeRect("Label", val2.transform);
			TextMeshProUGUI val4 = obj3.AddComponent<TextMeshProUGUI>();
			((TMP_Text)val4).text = "Connect";
			((TMP_Text)val4).fontSize = 30f;
			((Graphic)val4).color = Color.black;
			((TMP_Text)val4).fontStyle = (FontStyles)0;
			((TMP_Text)val4).alignment = (TextAlignmentOptions)514;
			ApplyFont(val4);
			FillParent(obj3.GetComponent<RectTransform>());
			val2.AddComponent<LayoutElement>().preferredHeight = 65f;
			Button obj4 = val2.AddComponent<Button>();
			((UnityEvent)obj4.onClick).AddListener(new UnityAction(OnConnectClicked));
			return obj4;
		}

		private TextMeshProUGUI AddStatusLabel(Transform parent)
		{
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			GameObject obj = MakeRect("Status", parent);
			TextMeshProUGUI val = obj.AddComponent<TextMeshProUGUI>();
			((TMP_Text)val).text = string.Empty;
			((TMP_Text)val).fontSize = 20f;
			((Graphic)val).color = new Color(0.75f, 0.1f, 0.1f);
			((TMP_Text)val).alignment = (TextAlignmentOptions)514;
			((TMP_Text)val).enableWordWrapping = true;
			ApplyFont(val);
			obj.AddComponent<LayoutElement>().preferredHeight = 55f;
			return val;
		}

		private void AddSpacer(Transform parent, float height)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			GameObject obj = MakeRect("Spacer", parent);
			Image obj2 = obj.AddComponent<Image>();
			((Graphic)obj2).color = Color.clear;
			((Graphic)obj2).raycastTarget = false;
			LayoutElement obj3 = obj.AddComponent<LayoutElement>();
			obj3.preferredHeight = height;
			obj3.minHeight = height;
		}

		private void AddHorizontalLine(Transform parent, float thickness, float widthPadding = 0f)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = MakeRect("Line", parent);
			((Graphic)val.AddComponent<Image>()).color = Color.black;
			LayoutElement obj = val.AddComponent<LayoutElement>();
			obj.preferredHeight = thickness;
			obj.minHeight = thickness;
			if (widthPadding > 0f)
			{
				val.GetComponent<RectTransform>();
			}
		}

		private static GameObject MakeRect(string name, Transform parent)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: 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_001b: Expected O, but got Unknown
			GameObject val = new GameObject(name);
			val.AddComponent<RectTransform>();
			val.transform.SetParent(parent, false);
			return val;
		}

		private static void FillParent(RectTransform rt)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: 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)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: 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)
			rt.anchorMin = Vector2.zero;
			rt.anchorMax = Vector2.one;
			Vector2 offsetMin = (rt.offsetMax = Vector2.zero);
			rt.offsetMin = offsetMin;
		}

		private void ApplyFont(TextMeshProUGUI tmp)
		{
			if ((Object)(object)_gameFont != (Object)null)
			{
				((TMP_Text)tmp).font = _gameFont;
			}
		}

		private static string Fallback(string value, string fallback)
		{
			if (!string.IsNullOrEmpty(value))
			{
				return value;
			}
			return fallback;
		}

		private void OnConnectClicked()
		{
			string text = _hostnameField.text.Trim();
			string s = _portField.text.Trim();
			string text2 = _slotField.text.Trim();
			string text3 = _passwordField.text;
			if (string.IsNullOrEmpty(text2))
			{
				((TMP_Text)_statusText).text = "Enter a slot name!";
				return;
			}
			if (!int.TryParse(s, out var result))
			{
				result = 38281;
			}
			((TMP_Text)_statusText).text = "Connecting…";
			try
			{
				ArchipelagoHandler archipelagoHandler = PikunikuAPMod.ArchipelagoHandler;
				archipelagoHandler.CreateSession(text, result, text2, text3);
				archipelagoHandler.Connect();
				FileWriter.WriteLastConnection(text, result, text2, text3);
			}
			catch (Exception ex)
			{
				((TMP_Text)_statusText).text = "Error: " + ex.Message;
				Log.Error($"Connect failed: {ex}");
			}
		}
	}
	public static class Scenes
	{
		public const string TitleScreen = "00_TITLESCREEN";

		public const string Prologue = "66_PROLOGUE";

		public const string MountainVillage = "02_MOUNTAINVILLAGE";

		public const string ValleyRoad = "02.1_MOUNTAINVILLAGETOFOREST";

		public const string MountainTemple = "02.2_MOUNTAIN_TEMPLE";

		public const string MountainBoss = "02.3_MOUNTAIN_ROBOTBOSS";

		public const string MountainMetro = "02.4_MOUNTAIN_METRO";

		public const string Forest = "03_FOREST";

		public const string ForestDanceBattle = "03.1_FOREST_DANCEBATTLE";

		public const string ForestTemple = "03.2_FOREST_TEMPLE";

		public const string ForestBoss = "03.3_FOREST_ROBOTBOSS";

		public const string ForestMetro = "03.4_FOREST_METRO";

		public const string ForestTartineZone = "03.5_FOREST_TARTINEZONE";

		public const string Lake = "04.1_LAKE";

		public const string Mine = "04_MINE";

		public const string LakeBoss = "04.2_LAKE_ROBOTBOSS";

		public const string HQ = "05_HQ";

		public const string HQFinalBoss = "05.1_HQ_FINALBOSS";

		public const string Beach = "07_BEACH";
	}
	public static class StorySegments
	{
		public const int INTRO_WAKEUP = 0;

		public const int INTRO_FINDWAYOUT = 1;

		public const int MOUNTAIN_WHEREAREYOU = 2;

		public const int MOUNTAIN_REPAIRBRIDGE = 3;

		public const int MOUNTAIN_BACKTOVILLAGE = 4;

		public const int MOUNTAIN_TALKTOPAINTER = 5;

		public const int MOUNTAIN_FINDPENCILHAT = 6;

		public const int MOUNTAIN_GIVEPENCILHATBACK = 7;

		public const int MOUNTAIN_DRAWSCARECROW = 8;

		public const int MOUNTAIN_PUTFACEONSCARECROW = 9;

		public const int MOUNTAIN_EXPLOREWORLD = 10;

		public const int MOUNTAIN_EXPLOREWORLD2 = 11;

		public const int FOREST_HELPVILLAGERSINTREE1 = 12;

		public const int FOREST_HELPVILLAGERSINTREE2_ROCK = 13;

		public const int FOREST_HELPVILLAGERSINTREE2 = 14;

		public const int FOREST_GOMEETPOINT = 15;

		public const int FOREST_GOTOCLUB = 16;

		public const int FOREST_GETSWAGGY = 17;

		public const int FOREST_ENTERCLUB = 18;

		public const int FOREST_CHALLENGEROBOT = 19;

		public const int FOREST_TALKTORESISTANCE = 20;

		public const int FOREST_FINDPURPOSECARD = 21;

		public const int FOREST_FOLLOWTHEREBELS = 22;

		public const int FOREST_BEATROBOT = 23;

		public const int FOREST_CELEBRATEVICTORY = 24;

		public const int FOREST_CELEBRATEVICTORY2 = 25;

		public const int MOUNTAIN_GETBACKMOUNTAIN = 26;

		public const int MOUNTAIN_BEATGIANTROBOT = 27;

		public const int FOREST_CELEBRATEVICTORYMOUNTAINBOSS = 28;

		public const int FOREST_FIXELECTRICITY = 29;

		public const int FOREST_GOTOTHELAKE = 30;

		public const int LAKE_INSPECT = 31;

		public const int LAKE_FINDKEY = 32;

		public const int LAKE_ENTERMINE = 33;

		public const int MINE_FOLLOWWORM = 34;

		public const int MINE_FOLLOWWORM2 = 35;

		public const int MINE_FINDERNIE = 36;

		public const int MINE_BRINGBACKERNIE = 37;

		public const int MINE_TALKTOREBELS = 38;

		public const int LAKE_FIGHTROBOT = 39;

		public const int HQ_OOPS = 40;

		public const int HQ_ARCHDPT1 = 41;

		public const int HQ_ARCHDPT2 = 42;

		public const int HQ_ESCAPE3 = 43;

		public const int HQ_ESCAPE_HELPVILLAGERS = 44;

		public const int HQ_BEATSUNSHINE1 = 45;

		public const int HQ_BEATSUNSHINE = 46;
	}
	public static class ArchipelagoConstants
	{
		public readonly struct CoinLoc
		{
			public readonly int Id;

			public readonly float X;

			public readonly float Y;

			public readonly string Name;

			public CoinLoc(int id, float x, float y, string name)
			{
				Id = id;
				X = x;
				Y = y;
				Name = name;
			}
		}

		public const string GameName = "Pikuniku";

		public const long BaseId = 100L;

		public static readonly Dictionary<string, long> Locations = new Dictionary<string, long>
		{
			{ "Walking Piku Trophy", 100L },
			{ "The Hidden Rock Trophy", 101L },
			{ "Baskick Champion Trophy", 102L },
			{ "Sam The Slime Trophy", 103L },
			{ "The Resistance Trophy", 104L },
			{ "A Giant Robot Trophy", 105L },
			{ "Demonic Toast Trophy", 106L },
			{ "PikDug Trophy", 107L },
			{ "Piku at The Beach Trophy", 108L },
			{ "The Worms Trophy", 109L },
			{ "Ernie the Worm Trophy", 110L },
			{ "Sunshine Inc. Robot Trophy", 111L },
			{ "Mr. Sunshine Trophy", 112L },
			{ "Valley Dancing Bug", 113L },
			{ "Road to Forest Dancing Bug", 114L },
			{ "Forest Dancing Bug", 115L },
			{ "Cave Dancing Bug", 116L },
			{ "Sunshine HQ Dancing Bug", 117L },
			{ "Valley Plush Purchase", 118L },
			{ "Forest Sunglasses Purchase", 119L },
			{ "Forest Postcard Purchase", 120L },
			{ "Forest X-Ray Goggles Purchase", 121L },
			{ "Pencil Hat", 122L },
			{ "Apple 1", 123L },
			{ "Apple 2", 124L },
			{ "Apple 3", 125L },
			{ "Beast Mask", 126L },
			{ "Flower Hat", 127L },
			{ "Draw on the Tree", 128L },
			{ "Magnetic Card", 129L },
			{ "Defeat the First Giant Robot", 130L },
			{ "Water Hat", 131L },
			{ "Golden Tooth from the Silver Frog", 132L },
			{ "Some Arms", 133L },
			{ "Defeat the Second Giant Robot", 134L },
			{ "The Cabin Key", 135L },
			{ "A Video Game", 136L },
			{ "A Detonator", 137L },
			{ "Defeat the Third Giant Robot", 138L },
			{ "Piku & Niku I Trophy", 139L },
			{ "Piku & Niku II Trophy", 140L },
			{ "Piku & Niku III Trophy", 141L },
			{ "Piku & Niku IV Trophy", 142L },
			{ "Piku & Niku V Trophy", 143L },
			{ "Co-op Level 1 Complete", 144L },
			{ "Co-op Level 2 Complete", 145L },
			{ "Co-op Level 3 Complete", 146L },
			{ "Co-op Level 4 Complete", 147L },
			{ "Co-op Level 5 Complete", 148L },
			{ "Co-op Level 6 Complete", 149L },
			{ "Co-op Level 7 Complete", 150L },
			{ "Co-op Level 8 Complete", 151L },
			{ "Co-op Level 9 Complete", 152L },
			{ "Valley: Coin near windmill 1", 153L },
			{ "Valley: Coin near windmill 2", 154L },
			{ "Valley: Coin near windmill 3", 155L },
			{ "Valley: Coin above shop", 156L },
			{ "Valley: Coin above umbrella", 157L },
			{ "Valley: Coin above cloud 1", 158L },
			{ "Valley: Coin above cloud 2", 159L },
			{ "Valley: Coin above cloud 3", 160L },
			{ "Valley: Coin above flower house", 161L },
			{ "Valley: Coin left under moving bridge", 162L },
			{ "Valley: Coin right under moving bridge", 163L },
			{ "Valley: Coin above lower cornfield 1", 164L },
			{ "Valley: Coin above lower cornfield 2", 165L },
			{ "Valley: Coin above lower cornfield 3", 166L },
			{ "Valley: Coin above lower cornfield 4", 167L },
			{ "Valley: Coin in air between cornfields 1", 168L },
			{ "Valley: Coin in air between cornfields 2", 169L },
			{ "Valley: Coin above upper cornfield 1", 170L },
			{ "Valley: Coin above upper cornfield 2", 171L },
			{ "Valley: Coin above upper cornfield 3", 172L },
			{ "Valley: Coin above upper cornfield 4", 173L },
			{ "Apple Temple: Coin next to spring", 174L },
			{ "Apple Temple: Coin on spike trap", 175L },
			{ "Apple Temple: Coin on first platform between spikes", 176L },
			{ "Apple Temple: Coin on second platform between spikes", 177L },
			{ "Apple Temple: Coin near hidden room", 178L },
			{ "Apple Temple: Coin after breakable rock 1", 179L },
			{ "Apple Temple: Coin after breakable rock 2", 180L },
			{ "Apple Temple: Coin after breakable rock 3", 181L },
			{ "Apple Temple: Coin requiring 2 buttons puzzle 1", 182L },
			{ "Apple Temple: Coin requiring 2 buttons puzzle 2", 183L },
			{ "Apple Temple: Coin requiring 2 buttons puzzle 3", 184L },
			{ "Apple Temple: Coin requiring 2 buttons puzzle 4", 185L },
			{ "Apple Temple: Coin requiring 2 buttons puzzle 5", 186L },
			{ "Apple Temple: Coin requiring 2 buttons puzzle 6", 187L },
			{ "Apple Temple: Coin between spike ceilings", 188L },
			{ "Apple Temple: Coin at start of bounce pad chain", 189L },
			{ "Apple Temple: Coin at end of temple 1", 190L },
			{ "Apple Temple: Coin at end of temple 2", 191L },
			{ "Apple Temple: Coin at end of temple 3", 192L },
			{ "Apple Temple: Coin at end of temple 4", 193L },
			{ "Valley Road: Coin at start", 194L },
			{ "Valley Road: Coin near hooks", 195L },
			{ "Valley Road: Coin on clouds above hooks", 196L },
			{ "Valley Road: Coin on clouds after boulders", 197L },
			{ "Valley Road: Coin in mushroom cave", 198L },
			{ "Valley Road: Coin on lower cave after door 1", 199L },
			{ "Valley Road: Coin on lower cave after door 2", 200L },
			{ "Valley Road: Coin on lower cave after door 3", 201L },
			{ "Valley Road: Coin on upper cloud near flower", 202L },
			{ "Valley Road: Coin on moving cloud 1", 203L },
			{ "Valley Road: Coin on moving cloud 2", 204L },
			{ "Valley Road: Coin on moving cloud 3", 205L },
			{ "Valley Road: Coin on moving cloud 4", 206L },
			{ "Valley Road: Coin on moving cloud 5", 207L },
			{ "Valley Road: Coin on moving cloud 6", 208L },
			{ "Valley Road: Coin on moving cloud 7", 209L },
			{ "Valley Road: Coin on moving cloud 8", 210L },
			{ "Valley Road: Coin on moving cloud 9", 211L },
			{ "Valley Road: Coin on moving cloud 10", 212L },
			{ "Valley Road: Coin on moving cloud 11", 213L },
			{ "Valley Road: Coin on moving cloud 12", 214L },
			{ "Valley Road: Coin on moving cloud 13", 215L },
			{ "Valley Road: Coin on moving cloud 14", 216L },
			{ "Valley Road: Coin at end of moving clouds", 217L },
			{ "Valley Road: Coin in hook upper hidden room 1", 218L },
			{ "Valley Road: Coin in hook upper hidden room 2", 219L },
			{ "Valley Road: Coin in hook upper hidden room 3", 220L },
			{ "Valley Road: Coin in hook upper hidden room 4", 221L },
			{ "Valley Road: Coin on zipline", 222L },
			{ "Valley Road: Coin on tree branch", 223L },
			{ "Valley Road: Coin near trees", 224L },
			{ "Valley Road: Coin in water hat area room 1", 225L },
			{ "Valley Road: Coin in water hat area room 2", 226L },
			{ "Valley Road: Coin in water hat area room 3", 227L },
			{ "Valley Road: Coin in water hat area room 4", 228L },
			{ "Forest: Coin on cut down log", 229L },
			{ "Forest: Coin on triple cut down logs 1", 230L },
			{ "Forest: Coin on triple cut down logs 2", 231L },
			{ "Forest: Coin on triple cut down logs 3", 232L },
			{ "Forest: Coin on ramp", 233L },
			{ "Forest: Coin on first log gear", 234L },
			{ "Forest: Coin on top of first log gear log", 235L },
			{ "Forest: Coin on second log gear", 236L },
			{ "Forest: Coin on fourth log", 237L },
			{ "Forest: Coin between logs", 238L },
			{ "Forest: Coin on fifth log gear", 239L },
			{ "Forest: Coin under sixth log gear", 240L },
			{ "Forest: Coin near owl on log", 241L },
			{ "Forest: Coin after logs", 242L },
			{ "Forest: Coin on town tree branch left", 243L },
			{ "Forest: Coin on town tree branch right", 244L },
			{ "Forest: Coin above community house", 245L },
			{ "Forest: Coin to the right of toastopia house", 246L },
			{ "Forest: Coin after rope bridge right of houses", 247L },
			{ "Forest: Coin atop last tree branch 1", 248L },
			{ "Forest: Coin atop last tree branch 2", 249L },
			{ "Forest: Coin on moving cloud 1", 250L },
			{ "Forest: Coin on moving cloud 2", 251L },
			{ "Forest: Coin on moving cloud 3", 252L },
			{ "Forest: Coin on moving cloud 4", 253L },
			{ "Forest: Coin on moving cloud 5", 254L },
			{ "Forest: Coin on moving cloud 6", 255L },
			{ "Forest: Coin on moving cloud 7", 256L },
			{ "Forest: Coin on moving cloud 8", 257L },
			{ "Forest: Coin on moving cloud 9", 258L },
			{ "Forest: Coin on moving cloud 10", 259L },
			{ "Forest: Coin on moving cloud 11", 260L },
			{ "Forest: Coin on moving cloud 12", 261L },
			{ "Forest: Coin on moving cloud 13", 262L },
			{ "Forest: Coin on moving cloud 14", 263L },
			{ "Forest: Coin on moving cloud 15", 264L },
			{ "Frog Temple: Coin left of entrance 1", 265L },
			{ "Frog Temple: Coin left of entrance 2", 266L },
			{ "Frog Temple: Coin left of entrance 3", 267L },
			{ "Frog Temple: Coin on spike trap", 268L },
			{ "Frog Temple: Coin before hook", 269L },
			{ "Frog Temple: Coin after 2nd checkpoint", 270L },
			{ "Frog Temple: Coin above arrow pit", 271L },
			{ "Frog Temple: Coin at symbol puzzle hint", 272L },
			{ "Frog Temple: Coin at nut bridge puzzle 1", 273L },
			{ "Frog Temple: Coin at nut bridge puzzle 2", 274L },
			{ "Frog Temple: Coin at nut bridge puzzle 3", 275L },
			{ "Cave: Coin in spring tunnel 1", 276L },
			{ "Cave: Coin in spring tunnel 2", 277L },
			{ "Cave: Coin in spring tunnel 3", 278L },
			{ "Cave: Coin in spring tunnel 4", 279L },
			{ "Cave: Coin after first pipe tunnel 1", 280L },
			{ "Cave: Coin after first pipe tunnel 2", 281L },
			{ "Cave: Coin before detonator tunnel 1", 282L },
			{ "Cave: Coin before detonator tunnel 2", 283L },
			{ "Cave: Coin before detonator tunnel 3", 284L },
			{ "Cave: Coin before detonator tunnel 4", 285L },
			{ "Cave: Coin near moving platforms", 286L },
			{ "Cave: Coin after first resistance puzzle 1", 287L },
			{ "Cave: Coin after first resistance puzzle 2", 288L },
			{ "Cave: Coin hidden near plant", 289L },
			{ "Cave: Coin after second resistance puzzle", 290L },
			{ "Cave: Coin above worm room 1", 291L },
			{ "Cave: Coin above worm room 2", 292L },
			{ "Cave: Coin under worm room", 293L },
			{ "Cave: Coin above ernie worm", 294L },
			{ "Cave: Coin above gray spinning cross 1", 295L },
			{ "Cave: Coin above gray spinning cross 2", 296L }
		};

		public static readonly Dictionary<string, long> Items = new Dictionary<string, long>
		{
			{ "Pencil Hat", 100L },
			{ "Water Hat", 101L },
			{ "Sunglasses", 102L },
			{ "X-Ray Glasses", 103L },
			{ "Flower Hat", 104L },
			{ "Beast Mask", 105L },
			{ "Some Arms", 106L },
			{ "Magnetic Card", 107L },
			{ "The Cabin Key", 108L },
			{ "A Detonator", 109L },
			{ "Apple", 110L },
			{ "The Golden Tooth from the Silver Frog", 111L },
			{ "Co-op Level Access", 112L },
			{ "A Video Game", 113L },
			{ "Sam the Slime Trophy", 114L },
			{ "The Resistance Trophy", 115L },
			{ "A Giant Robot Trophy", 116L },
			{ "The Demonic Toast Trophy", 117L },
			{ "PikDug Trophy", 118L },
			{ "Piku at the Beach Trophy", 119L },
			{ "The Worms Trophy", 120L },
			{ "Ernie the Worm Trophy", 121L },
			{ "Sunshine Inc. Robot Trophy", 122L },
			{ "Mr. Sunshine Trophy", 123L },
			{ "Baskick Champion Trophy", 124L },
			{ "Walking Piku Trophy", 125L },
			{ "The Hidden Rock Trophy", 126L },
			{ "Piku & Niku I Trophy", 127L },
			{ "Piku & Niku II Trophy", 128L },
			{ "Piku & Niku III Trophy", 129L },
			{ "Piku & Niku IV Trophy", 130L },
			{ "Piku & Niku V Trophy", 131L },
			{ "A Scary Plush", 132L },
			{ "Forest Postcard", 133L },
			{ "5 Coins", 134L },
			{ "Joyful Whimsy", 135L }
		};

		public static readonly CoinLoc[] CoinLocations = new CoinLoc[144]
		{
			new CoinLoc(1199576228, 290.5f, -81.1f, "Valley: Coin near windmill 1"),
			new CoinLoc(889188242, 293.2f, -81.1f, "Valley: Coin near windmill 2"),
			new CoinLoc(889144834, 295.7f, -81f, "Valley: Coin near windmill 3"),
			new CoinLoc(889149006, 364.8f, -57.6f, "Valley: Coin above shop"),
			new CoinLoc(889178494, 377.8f, -60.2f, "Valley: Coin above umbrella"),
			new CoinLoc(889169866, 413.2f, -26.6f, "Valley: Coin above cloud 1"),
			new CoinLoc(889134516, 415.8f, -26.6f, "Valley: Coin above cloud 2"),
			new CoinLoc(889122018, 418.4f, -26.6f, "Valley: Coin above cloud 3"),
			new CoinLoc(889153857, 432f, -50.7f, "Valley: Coin above flower house"),
			new CoinLoc(889161219, 453f, -97f, "Valley: Coin left under moving bridge"),
			new CoinLoc(889106873, 469f, -103f, "Valley: Coin right under moving bridge"),
			new CoinLoc(889191034, 175f, -89f, "Valley: Coin above lower cornfield 1"),
			new CoinLoc(889123450, 177f, -89f, "Valley: Coin above lower cornfield 2"),
			new CoinLoc(889121971, 179f, -89f, "Valley: Coin above lower cornfield 3"),
			new CoinLoc(1199575527, 181f, -89f, "Valley: Coin above lower cornfield 4"),
			new CoinLoc(889188847, 158.4f, -77.8f, "Valley: Coin in air between cornfields 1"),
			new CoinLoc(889156023, 158.4f, -80.8f, "Valley: Coin in air between cornfields 2"),
			new CoinLoc(889186242, 172f, -74f, "Valley: Coin above upper cornfield 1"),
			new CoinLoc(889184443, 173.9f, -73.9f, "Valley: Coin above upper cornfield 2"),
			new CoinLoc(889118349, 175.9f, -73.9f, "Valley: Coin above upper cornfield 3"),
			new CoinLoc(889135973, 178f, -74f, "Valley: Coin above upper cornfield 4"),
			new CoinLoc(51908967, 11.4f, 7.1f, "Apple Temple: Coin next to spring"),
			new CoinLoc(51846333, 15f, -17f, "Apple Temple: Coin on spike trap"),
			new CoinLoc(51821243, 33f, -21f, "Apple Temple: Coin on first platform between spikes"),
			new CoinLoc(895346862, 44f, -21f, "Apple Temple: Coin on second platform between spikes"),
			new CoinLoc(51833320, 82f, -5f, "Apple Temple: Coin near hidden room"),
			new CoinLoc(51883161, 109.6f, -17.4f, "Apple Temple: Coin after breakable rock 1"),
			new CoinLoc(51834740, 111.6f, -17.4f, "Apple Temple: Coin after breakable rock 2"),
			new CoinLoc(51853567, 113.6f, -17.4f, "Apple Temple: Coin after breakable rock 3"),
			new CoinLoc(51825124, 163.2f, -40.8f, "Apple Temple: Coin requiring 2 buttons puzzle 1"),
			new CoinLoc(51828777, 165.2f, -40.8f, "Apple Temple: Coin requiring 2 buttons puzzle 2"),
			new CoinLoc(51834651, 167.2f, -40.8f, "Apple Temple: Coin requiring 2 buttons puzzle 3"),
			new CoinLoc(51847808, 163.2f, -43.1f, "Apple Temple: Coin requiring 2 buttons puzzle 4"),
			new CoinLoc(51829431, 165.2f, -43.1f, "Apple Temple: Coin requiring 2 buttons puzzle 5"),
			new CoinLoc(51893689, 167.2f, -43.1f, "Apple Temple: Coin requiring 2 buttons puzzle 6"),
			new CoinLoc(1723174925, 215f, -46.9f, "Apple Temple: Coin between spike ceilings"),
			new CoinLoc(51854706, 226.1f, -35.8f, "Apple Temple: Coin at start of bounce pad chain"),
			new CoinLoc(51885771, 271.6f, -22.7f, "Apple Temple: Coin at end of temple 1"),
			new CoinLoc(51838646, 268.6f, -25.5f, "Apple Temple: Coin at end of temple 2"),
			new CoinLoc(51878197, 268.6f, -22.7f, "Apple Temple: Coin at end of temple 3"),
			new CoinLoc(1723174131, 265.6f, -22.7f, "Apple Temple: Coin at end of temple 4"),
			new CoinLoc(70776915, 22.8f, -76f, "Valley Road: Coin at start"),
			new CoinLoc(70776915, 85f, -63f, "Valley Road: Coin near hooks"),
			new CoinLoc(70776915, 69f, -37.7f, "Valley Road: Coin on clouds above hooks"),
			new CoinLoc(70776915, 147.6f, -53.8f, "Valley Road: Coin on clouds after boulders"),
			new CoinLoc(70776915, 209f, -63f, "Valley Road: Coin in mushroom cave"),
			new CoinLoc(70776915, 246.1f, -82.9f, "Valley Road: Coin on lower cave after door 1"),
			new CoinLoc(70776915, 253.5f, -82.9f, "Valley Road: Coin on lower cave after door 2"),
			new CoinLoc(70776915, 260.9f, -82.9f, "Valley Road: Coin on lower cave after door 3"),
			new CoinLoc(70776915, 216.5f, -17.2f, "Valley Road: Coin on upper cloud near flower"),
			new CoinLoc(70776915, 190f, 1.4f, "Valley Road: Coin on moving cloud 1"),
			new CoinLoc(70776915, 191.8f, 1.4f, "Valley Road: Coin on moving cloud 2"),
			new CoinLoc(70776915, 193.5f, 1.4f, "Valley Road: Coin on moving cloud 3"),
			new CoinLoc(70776915, 195.6f, 1.4f, "Valley Road: Coin on moving cloud 4"),
			new CoinLoc(70776915, 190f, -0.6f, "Valley Road: Coin on moving cloud 5"),
			new CoinLoc(70776915, 191.8f, -0.6f, "Valley Road: Coin on moving cloud 6"),
			new CoinLoc(70776915, 193.5f, -0.6f, "Valley Road: Coin on moving cloud 7"),
			new CoinLoc(70776915, 195.6f, -0.6f, "Valley Road: Coin on moving cloud 8"),
			new CoinLoc(70776915, 204.4f, 1.4f, "Valley Road: Coin on moving cloud 9"),
			new CoinLoc(70776915, 206.2f, 1.4f, "Valley Road: Coin on moving cloud 10"),
			new CoinLoc(70776915, 207.9f, 1.4f, "Valley Road: Coin on moving cloud 11"),
			new CoinLoc(70776915, 204.4f, -0.6f, "Valley Road: Coin on moving cloud 12"),
			new CoinLoc(70776915, 206.2f, -0.6f, "Valley Road: Coin on moving cloud 13"),
			new CoinLoc(70776915, 207.9f, -0.6f, "Valley Road: Coin on moving cloud 14"),
			new CoinLoc(70776915, 140.9f, -5f, "Valley Road: Coin at end of moving clouds"),
			new CoinLoc(70776915, 125.2f, -15.5f, "Valley Road: Coin in hook upper hidden room 1"),
			new CoinLoc(70776915, 127f, -15.5f, "Valley Road: Coin in hook upper hidden room 2"),
			new CoinLoc(70776915, 125.2f, -13.5f, "Valley Road: Coin in hook upper hidden room 3"),
			new CoinLoc(70776915, 127f, -13.5f, "Valley Road: Coin in hook upper hidden room 4"),
			new CoinLoc(70776915, 305.3f, -16.2f, "Valley Road: Coin on zipline"),
			new CoinLoc(70776915, 320.4f, -29.1f, "Valley Road: Coin on tree branch"),
			new CoinLoc(62192953, 334.8f, -41.2f, "Valley Road: Coin near trees"),
			new CoinLoc(2085386414, 144f, -98f, "Valley Road: Coin in water hat area room 1"),
			new CoinLoc(2092971986, 138f, -98f, "Valley Road: Coin in water hat area room 2"),
			new CoinLoc(649749052, 133f, -98f, "Valley Road: Coin in water hat area room 3"),
			new CoinLoc(2093405322, 128.6f, -98f, "Valley Road: Coin in water hat area room 4"),
			new CoinLoc(1549184843, 55f, -195f, "Forest: Coin on cut down log"),
			new CoinLoc(1549224845, 141f, -206f, "Forest: Coin on triple cut down logs 1"),
			new CoinLoc(1549205227, 149f, -206f, "Forest: Coin on triple cut down logs 2"),
			new CoinLoc(1549228498, 157f, -204f, "Forest: Coin on triple cut down logs 3"),
			new CoinLoc(1549214684, 189.8f, -209.3f, "Forest: Coin on ramp"),
			new CoinLoc(1667825996, 219.2f, -194.6f, "Forest: Coin on first log gear"),
			new CoinLoc(1549200294, 219.1f, -189f, "Forest: Coin on top of first log gear log"),
			new CoinLoc(1549220811, 245f, -187f, "Forest: Coin on second log gear"),
			new CoinLoc(1549151259, 277f, -163f, "Forest: Coin on fourth log"),
			new CoinLoc(1702486725, 298f, -164.8f, "Forest: Coin between logs"),
			new CoinLoc(1703946260, 327f, -158.7f, "Forest: Coin on fifth log gear"),
			new CoinLoc(1549188468, 339.1f, -185.6f, "Forest: Coin under sixth log gear"),
			new CoinLoc(1548603409, 363f, -137f, "Forest: Coin near owl on log"),
			new CoinLoc(1549154939, 374f, -146f, "Forest: Coin after logs"),
			new CoinLoc(1839019233, 488.9f, -163.9f, "Forest: Coin on town tree branch left"),
			new CoinLoc(1839992568, 497.3f, -155.4f, "Forest: Coin on town tree branch right"),
			new CoinLoc(1834202660, 529.1f, -152.1f, "Forest: Coin above community house"),
			new CoinLoc(1837535892, 605.1f, -156f, "Forest: Coin to the right of toastopia house"),
			new CoinLoc(154918642, 653f, -169f, "Forest: Coin after rope bridge right of houses"),
			new CoinLoc(1549206017, 658f, -153f, "Forest: Coin atop last tree branch 1"),
			new CoinLoc(1549213430, 658f, -144.6f, "Forest: Coin atop last tree branch 2"),
			new CoinLoc(1549218646, 626.1f, -105.7f, "Forest: Coin on moving cloud 1"),
			new CoinLoc(1549221410, 629.1f, -105.7f, "Forest: Coin on moving cloud 2"),
			new CoinLoc(1549196638, 632.1f, -105.7f, "Forest: Coin on moving cloud 3"),
			new CoinLoc(1549176235, 635.1f, -105.7f, "Forest: Coin on moving cloud 4"),
			new CoinLoc(1549150881, 638.1f, -105.7f, "Forest: Coin on moving cloud 5"),
			new CoinLoc(1549213502, 629.1f, -108f, "Forest: Coin on moving cloud 6"),
			new CoinLoc(1549208573, 632.1f, -108f, "Forest: Coin on moving cloud 7"),
			new CoinLoc(1549200835, 635.1f, -108f, "Forest: Coin on moving cloud 8"),
			new CoinLoc(1549186031, 638.1f, -108f, "Forest: Coin on moving cloud 9"),
			new CoinLoc(1549163596, 649.1f, -105.7f, "Forest: Coin on moving cloud 10"),
			new CoinLoc(1549170179, 652.1f, -105.7f, "Forest: Coin on moving cloud 11"),
			new CoinLoc(1549163589, 655.1f, -105.7f, "Forest: Coin on moving cloud 12"),
			new CoinLoc(1549185406, 649.1f, -108f, "Forest: Coin on moving cloud 13"),
			new CoinLoc(1549232206, 652.1f, -108f, "Forest: Coin on moving cloud 14"),
			new CoinLoc(1549211934, 655.1f, -108f, "Forest: Coin on moving cloud 15"),
			new CoinLoc(740310583, 8f, 10f, "Frog Temple: Coin left of entrance 1"),
			new CoinLoc(740050088, 11f, 10f, "Frog Temple: Coin left of entrance 2"),
			new CoinLoc(739750294, 14f, 10f, "Frog Temple: Coin left of entrance 3"),
			new CoinLoc(1099654487, 70.1f, 9.6f, "Frog Temple: Coin on spike trap"),
			new CoinLoc(1096215408, 97.8f, 5.6f, "Frog Temple: Coin before hook"),
			new CoinLoc(1096215408, 130.1f, 8.6f, "Frog Temple: Coin after 2nd checkpoint"),
			new CoinLoc(522213601, 236.2f, -9.7f, "Frog Temple: Coin above arrow pit"),
			new CoinLoc(525698043, 304f, -14f, "Frog Temple: Coin at symbol puzzle hint"),
			new CoinLoc(1706505722, 354.2f, -17.1f, "Frog Temple: Coin at nut bridge puzzle 1"),
			new CoinLoc(1706215749, 356.7f, -17.1f, "Frog Temple: Coin at nut bridge puzzle 2"),
			new CoinLoc(1706088097, 359.3f, -17.1f, "Frog Temple: Coin at nut bridge puzzle 3"),
			new CoinLoc(73042658, 202f, -20f, "Cave: Coin in spring tunnel 1"),
			new CoinLoc(1182784534, 205.6f, -20f, "Cave: Coin in spring tunnel 2"),
			new CoinLoc(1182624852, 209.1f, -20f, "Cave: Coin in spring tunnel 3"),
			new CoinLoc(1182375973, 212.6f, -20f, "Cave: Coin in spring tunnel 4"),
			new CoinLoc(1248839813, 153.6f, -157.3f, "Cave: Coin after first pipe tunnel 1"),
			new CoinLoc(1248221666, 153.6f, -160f, "Cave: Coin after first pipe tunnel 2"),
			new CoinLoc(1249179375, 142.7f, -157.3f, "Cave: Coin before detonator tunnel 1"),
			new CoinLoc(1249379767, 145.5f, -157.3f, "Cave: Coin before detonator tunnel 2"),
			new CoinLoc(1248403122, 142.7f, -160f, "Cave: Coin before detonator tunnel 3"),
			new CoinLoc(1248666468, 145.5f, -160f, "Cave: Coin before detonator tunnel 4"),
			new CoinLoc(110171987, 218f, -146f, "Cave: Coin near moving platforms"),
			new CoinLoc(110514548, 242f, -179f, "Cave: Coin after first resistance puzzle 1"),
			new CoinLoc(109996565, 245f, -179f, "Cave: Coin after first resistance puzzle 2"),
			new CoinLoc(119674886, 268f, -163f, "Cave: Coin hidden near plant"),
			new CoinLoc(119361553, 380.5f, -173.2f, "Cave: Coin after second resistance puzzle"),
			new CoinLoc(120455579, 444.9f, -167f, "Cave: Coin above worm room 1"),
			new CoinLoc(120475059, 457.4f, -167f, "Cave: Coin above worm room 2"),
			new CoinLoc(179300603, 471.2f, -204.8f, "Cave: Coin under worm room"),
			new CoinLoc(180586320, 497f, -221f, "Cave: Coin above ernie worm"),
			new CoinLoc(182877868, 552.7f, -198.4f, "Cave: Coin above gray spinning cross 1"),
			new CoinLoc(448907562, 559.8f, -202.4f, "Cave: Coin above gray spinning cross 2")
		};

		public static string ResolveCoinLocation(int uniqueId, float x, float y)
		{
			string result = null;
			float num = float.MaxValue;
			CoinLoc[] coinLocations = CoinLocations;
			for (int i = 0; i < coinLocations.Length; i++)
			{
				CoinLoc coinLoc = coinLocations[i];
				if (coinLoc.Id == uniqueId)
				{
					float num2 = coinLoc.X - x;
					float num3 = coinLoc.Y - y;
					float num4 = num2 * num2 + num3 * num3;
					if (num4 < num)
					{
						num = num4;
						result = coinLoc.Name;
					}
				}
			}
			return result;
		}
	}
	public class ArchipelagoHandler : MonoBehaviour
	{
		private string seed;

		private readonly Queue<long> locationsToCheck = new Queue<long>();

		private readonly object queueLock = new object();

		private string lastDeath;

		private DateTime lastDeathLinkTime = DateTime.Now;

		private readonly Random random = new Random();

		private readonly string[] deathMessages = new string[6] { "got kicked a little too hard.", "should not have trusted Mr. Sunshine.", "drank too much green liquid.", "got FREE MONEY!!!", "got chosen to go to the volcano.", "got kicked out of el bunko." };

		private int _gameOversSinceLastSend;

		private ArchipelagoSession Session { get; set; }

		private string Server { get; set; }

		private int Port { get; set; }

		private string Slot { get; set; }

		private string Password { get; set; }

		public bool IsConnected
		{
			get
			{
				if (Session != null)
				{
					return Session.Socket.Connected;
				}
				return false;
			}
		}

		public bool DeathLinkEnabled => PikunikuAPMod.DeathLink?.Value switch
		{
			DeathLinkMode.On => true, 
			DeathLinkMode.Off => false, 
			_ => PikunikuAPMod.SlotData?.DeathLink ?? false, 
		};

		public event Action OnConnected;

		public event Action<string> OnConnectionFailed;

		public event Action OnDisconnected;

		public event Action<string> OnLogMessage;

		private static string GetColorHex(PaletteColor? color)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: 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_0046: Expected I4, but got Unknown
			return color switch
			{
				(PaletteColor)2L => "#EE0000", 
				(PaletteColor)3L => "#00FF7F", 
				(PaletteColor)7L => "#FAFAD2", 
				(PaletteColor)4L => "#6495ED", 
				(PaletteColor)6L => "#EE00EE", 
				(PaletteColor)5L => "#00EEEE", 
				(PaletteColor)1L => "#000000", 
				(PaletteColor)0L => "#FFFFFF", 
				(PaletteColor)8L => "#6D8BE8", 
				(PaletteColor)9L => "#FA8072", 
				(PaletteColor)10L => "#AF99EF", 
				_ => "#FFFFFF", 
			};
		}

		public void CreateSession(string server, int port, string slot, string password)
		{
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Expected O, but got Unknown
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Expected O, but got Unknown
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Expected O, but got Unknown
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Expected O, but got Unknown
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Expected O, but got Unknown
			Server = server;
			Port = port;
			Slot = slot;
			Password = password;
			Session = ArchipelagoSessionFactory.CreateSession(Server, Port);
			Session.MessageLog.OnMessageReceived += new MessageReceivedHandler(OnMessageReceived);
			Session.Socket.ErrorReceived += new ErrorReceivedHandler(OnError);
			Session.Socket.SocketClosed += new SocketClosedHandler(OnSocketClosed);
			Session.Socket.PacketReceived += new PacketReceivedHandler(PacketReceived);
			Session.Items.ItemReceived += new ItemReceivedHandler(ItemReceived);
		}

		private void OnDestroy()
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Expected O, but got Unknown
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Expected O, but got Unknown
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Expected O, but got Unknown
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Expected O, but got Unknown
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Expected O, but got Unknown
			if (Session != null)
			{
				Session.MessageLog.OnMessageReceived -= new MessageReceivedHandler(OnMessageReceived);
				Session.Socket.ErrorReceived -= new ErrorReceivedHandler(OnError);
				Session.Socket.SocketClosed -= new SocketClosedHandler(OnSocketClosed);
				Session.Socket.PacketReceived -= new PacketReceivedHandler(PacketReceived);
				Session.Items.ItemReceived -= new ItemReceivedHandler(ItemReceived);
			}
		}

		public void Connect()
		{
			//IL_0177: Unknown result type (might be due to invalid IL or missing references)
			//IL_019e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			Log.Message($"Logging in to {Server}:{Port} as {Slot}...");
			LoginResult val = Session.TryConnectAndLogin("Pikuniku", Slot, (ItemsHandlingFlags)7, new Version(0, 6, 7), new string[0], (string)null, Password, true);
			if (val.Successful)
			{
				Log.Message($"Success! Connected to {Server}:{Port}");
				LoginSuccessful val2 = (LoginSuccessful)val;
				PikunikuAPMod.SlotData = new SlotData(val2.SlotData);
				Log.Info(val2.SlotData);
				Log.Info(PikunikuAPMod.SlotData.PikuColor);
				Log.Info(PikunikuAPMod.SlotData.DeathLinkAmnesty);
				Log.Info(PikunikuAPMod.SlotData.DeathLink);
				Log.Info(PikunikuAPMod.SlotData.Coinsanity);
				Log.Info(PikunikuAPMod.SlotData.CoopLevels);
				ApplyDeathLinkTag();
				seed = Session.RoomState.Seed;
				if (seed != null)
				{
					PikunikuAPMod.SaveDataHandler.GetSaveGame(seed, Slot);
					PikunikuAPMod.GameHandler.SetupSeedSlot(seed, Slot);
				}
				PikunikuAPMod.GameHandler.InitOnConnect();
				((MonoBehaviour)this).StartCoroutine(RunCheckQueue());
				this.OnConnected?.Invoke();
			}
			else
			{
				LoginFailure val3 = (LoginFailure)val;
				string text = Enumerable.Aggregate(seed: Enumerable.Aggregate(seed: $"Failed to Connect to {Server}:{Port} as {Slot}:", source: val3.Errors, func: (string current, string error) => current + "\n    " + error), source: val3.ErrorCodes, func: (string current, ConnectionRefusedError error) => current + $"\n    {error}");
				this.OnConnectionFailed?.Invoke(text);
				Log.Error(text);
			}
		}

		public void Disconnect()
		{
			if (Session != null)
			{
				((MonoBehaviour)this).StopAllCoroutines();
				Session.Socket.Disconnect();
				Session = null;
				Log.Message("Disconnected from Archipelago");
			}
		}

		private void OnError(Exception ex, string message)
		{
			Log.Error("Socket error: " + message + " - " + ex.Message);
		}

		private void OnSocketClosed(string reason)
		{
			((MonoBehaviour)this).StopAllCoroutines();
			Log.Warning("Socket closed: " + reason);
			this.OnDisconnected?.Invoke();
		}

		private void ItemReceived(ReceivedItemsHelper helper)
		{
			try
			{
				int valueOrDefault = (PikunikuAPMod.SaveDataHandler?.SaveData?.ItemIndex).GetValueOrDefault();
				while (helper.Any())
				{
					ItemInfo item = helper.DequeueItem();
					int num = helper.Index - 1;
					if (num >= valueOrDefault)
					{
						PikunikuAPMod.ItemHandler.HandleItem(num, item);
					}
				}
			}
			catch (Exception arg)
			{
				Log.Error($"ItemReceived Error: {arg}");
				throw;
			}
		}

		public void SetGoal()
		{
			Session.SetGoalAchieved();
			Session.SetClientState((ArchipelagoClientState)30);
		}

		public void CheckLocations(long[] ids)
		{
			lock (queueLock)
			{
				foreach (long item in ids)
				{
					locationsToCheck.Enqueue(item);
				}
			}
		}

		public void CheckLocation(long id)
		{
			if (IsLocationChecked(id))
			{
				return;
			}
			lock (queueLock)
			{
				locationsToCheck.Enqueue(id);
			}
		}

		private IEnumerator RunCheckQueue()
		{
			while (true)
			{
				long num = 0L;
				bool flag = false;
				lock (queueLock)
				{
					if (locationsToCheck.Count > 0)
					{
						num = locationsToCheck.Dequeue();
						flag = true;
					}
				}
				if (flag)
				{
					Session.Locations.CompleteLocationChecks(new long[1] { num });
					Log.Message($"Sent location check: {num}");
				}
				yield return (object)new WaitForSeconds(0.1f);
			}
		}

		public bool HasReceivedItem(string itemName)
		{
			if (Session == null || Session.Items == null)
			{
				return false;
			}
			return Session.Items.AllItemsReceived.Any((ItemInfo item) => item.ItemName == itemName);
		}

		public bool IsLocationChecked(long id)
		{
			if (Session == null || Session.Locations == null)
			{
				return false;
			}
			return Session.Locations.AllLocationsChecked.Contains(id);
		}

		public int CountLocationsCheckedInRange(long start, long end)
		{
			if (Session == null || Session.Locations == null)
			{
				return 0;
			}
			return Session.Locations.AllLocationsChecked.Count((long loc) => loc >= start && loc < end);
		}

		public void UpdateTags(List<string> tags)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: 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_0027: Expected O, but got Unknown
			if (Session != null)
			{
				ConnectUpdatePacket val = new ConnectUpdatePacket
				{
					Tags = tags.ToArray(),
					ItemsHandling = (ItemsHandlingFlags)7
				};
				Session.Socket.SendPacket((ArchipelagoPacketBase)(object)val);
			}
		}

		public void ApplyDeathLinkTag()
		{
			UpdateTags(DeathLinkEnabled ? new List<string> { "DeathLink" } : new List<string>());
		}

		private void OnMessageReceived(LogMessage message)
		{
			if (message.Parts.Any((MessagePart x) => (int)x.Type == 1) && PikunikuAPMod.FilterLog != null && PikunikuAPMod.FilterLog.Value && !message.Parts.Any((MessagePart x) => x.Text.Contains(Session.Players.GetPlayerName(Session.ConnectionInfo.Slot))))
			{
				return;
			}
			string message2;
			if (message.Parts.Length == 1)
			{
				message2 = message.Parts[0].Text;
			}
			else
			{
				StringBuilder stringBuilder = new StringBuilder();
				MessagePart[] parts = message.Parts;
				foreach (MessagePart val in parts)
				{
					string colorHex = GetColorHex(val.PaletteColor);
					stringBuilder.Append("<color=" + colorHex + ">" + val.Text + "</color>");
				}
				message2 = stringBuilder.ToString();
			}
			AddMessageToGameLog(message2);
		}

		public void AddMessageToGameLog(string message)
		{
			Log.Message(message);
			this.OnLogMessage?.Invoke(message);
		}

		private void PacketReceived(ArchipelagoPacketBase packet)
		{
			BouncePacket val = (BouncePacket)(object)((packet is BouncePacket) ? packet : null);
			if (val != null)
			{
				BouncePacketReceived(val);
			}
		}

		public void OnPlayerGameOver()
		{
			if (DeathLinkEnabled)
			{
				int num = PikunikuAPMod.SlotData?.DeathLinkAmnesty ?? 0;
				_gameOversSinceLastSend++;
				if (_gameOversSinceLastSend <= num)
				{
					Log.Message($"DeathLink amnesty {_gameOversSinceLastSend}/{num} — not sending");
					return;
				}
				_gameOversSinceLastSend = 0;
				SendDeath();
			}
		}

		public void SendDeath()
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Expected O, but got Unknown
			if (DeathLinkEnabled)
			{
				BouncePacket val = new BouncePacket();
				DateTime now = DateTime.Now;
				if (!(now - lastDeathLinkTime < TimeSpan.FromSeconds(2.0)))
				{
					val.Tags = new List<string>(1) { "DeathLink" };
					val.Data = new Dictionary<string, JToken>
					{
						{
							"time",
							JToken.op_Implicit(UnixTimeConverter.ToUnixTimeStamp(now))
						},
						{
							"source",
							JToken.op_Implicit(Slot)
						},
						{
							"cause",
							JToken.op_Implicit(Slot + " " + deathMessages[random.Next(deathMessages.Length)])
						}
					};
					lastDeathLinkTime = now;
					Session.Socket.SendPacket((ArchipelagoPacketBase)(object)val);
				}
			}
		}

		private void BouncePacketReceived(BouncePacket packet)
		{
			if (DeathLinkEnabled)
			{
				ProcessBouncePacket(packet, "DeathLink", ref lastDeath, delegate(string source, Dictionary<string, JToken> data)
				{
					JToken value;
					string cause = (data.TryGetValue("cause", out value) ? ((object)value).ToString() : (source + " has died."));
					HandleDeathLink(source, cause);
				});
			}
		}

		private static void ProcessBouncePacket(BouncePacket packet, string tag, ref string lastTime, Action<string, Dictionary<string, JToken>> handler)
		{
			if (packet.Tags.Contains(tag) && packet.Data.TryGetValue("time", out var value) && !(lastTime == ((object)value).ToString()))
			{
				lastTime = ((object)value).ToString();
				if (packet.Data.TryGetValue("source", out var value2))
				{
					string arg = ((object)value2)?.ToString() ?? "Unknown";
					handler(arg, packet.Data);
				}
			}
		}

		private void HandleDeathLink(string source, string cause)
		{
			AddMessageToGameLog(cause);
			if (!(source == Slot))
			{
				PikunikuAPMod.GameHandler.Kill();
			}
		}

		public void ScoutLocation(long locationId, Action<ScoutedItemInfo> callback, bool createHint = false)
		{
			Session.Locations.ScoutLocationsAsync((Action<Dictionary<long, ScoutedItemInfo>>)delegate(Dictionary<long, ScoutedItemInfo> results)
			{
				if (results != null && results.Count > 0)
				{
					callback?.Invoke(results.Values.First());
				}
			}, createHint, new long[1] { locationId });
		}

		public string GetPlayerName(int player)
		{
			return Session.Players.GetPlayerAlias(player) ?? $"Player {player}";
		}

		public string GetLocationName(long locationId)
		{
			return Session.Locations.GetLocationNameFromId(locationId, (string)null) ?? $"Location {locationId}";
		}
	}
	public class ClientView : MonoBehaviour
	{
		private class Message
		{
			public GameObject Go;

			public CanvasGroup Cg;

			public float Born;

			public float Expiry;
		}

		private const float MessageLifetime = 7.5f;

		private const float FadeIn = 0.25f;

		private const float FadeOut = 0.6f;

		private const float PanelWidth = 440f;

		private const float PanelHeight = 300f;

		private const float FontSize = 18f;

		private static readonly Color ShadowColor = new Color(0f, 0f, 0f, 0.9f);

		private static readonly Vector2 ShadowDistance = new Vector2(1f, -1f);

		private Canvas _canvas;

		private RectTransform _content;

		private TMP_FontAsset _font;

		private bool _built;

		private volatile bool _wantVisible;

		private float _systemMessageUntil;

		private readonly List<Message> _messages = new List<Message>();

		private readonly Queue<string> _incoming = new Queue<string>();

		private readonly object _lock = new object();

		private void Awake()
		{
			ArchipelagoHandler archipelagoHandler = PikunikuAPMod.ArchipelagoHandler;
			if ((Object)(object)archipelagoHandler != (Object)null)
			{
				archipelagoHandler.OnLogMessage += OnLogMessage;
				archipelagoHandler.OnConnected += OnConnected;
				archipelagoHandler.OnDisconnected += OnDisconnected;
			}
		}

		private void OnDestroy()
		{
			ArchipelagoHandler archipelagoHandler = PikunikuAPMod.ArchipelagoHandler;
			if ((Object)(object)archipelagoHandler != (Object)null)
			{
				archipelagoHandler.OnLogMessage -= OnLogMessage;
				archipelagoHandler.OnConnected -= OnConnected;
				archipelagoHandler.OnDisconnected -= OnDisconnected;
			}
		}

		private void OnLogMessage(string message)
		{
			lock (_lock)
			{
				_incoming.Enqueue(message);
			}
		}

		private void OnConnected()
		{
			_wantVisible = true;
		}

		private void OnDisconnected()
		{
			_wantVisible = false;
		}

		public void QueueMessage(string text)
		{
			lock (_lock)
			{
				_incoming.Enqueue(text);
			}
			_systemMessageUntil = Mathf.Max(_systemMessageUntil, Time.unscaledTime + 7.5f);
		}

		private void Update()
		{
			float unscaledTime = Time.unscaledTime;
			bool flag = _wantVisible || unscaledTime < _systemMessageUntil;
			if (flag && !_built)
			{
				Build();
			}
			if (!_built)
			{
				return;
			}
			if (((Behaviour)_canvas).enabled != flag)
			{
				((Behaviour)_canvas).enabled = flag;
			}
			lock (_lock)
			{
				while (_incoming.Count > 0)
				{
					AddMessage(_incoming.Dequeue(), unscaledTime);
				}
			}
			for (int num = _messages.Count - 1; num >= 0; num--)
			{
				Message message = _messages[num];
				if (unscaledTime >= message.Expiry)
				{
					if ((Object)(object)message.Go != (Object)null)
					{
						Object.Destroy((Object)(object)message.Go);
					}
					_messages.RemoveAt(num);
				}
				else if ((Object)(object)message.Cg != (Object)null)
				{
					message.Cg.alpha = ComputeAlpha(message, unscaledTime);
				}
			}
		}

		private static float ComputeAlpha(Message m, float now)
		{
			float num = 1f;
			float num2 = now - m.Born;
			if (num2 < 0.25f)
			{
				num = num2 / 0.25f;
			}
			float num3 = m.Expiry - now;
			if (num3 < 0.6f)
			{
				num = Mathf.Min(num, num3 / 0.6f);
			}
			return Mathf.Clamp01(num);
		}

		private void AddMessage(string text, float now)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: 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)
			//IL_006d: 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_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: 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)
			GameObject val = MakeRect("Msg", (Transform)(object)_content);
			TextMeshProUGUI obj = ConfigureText(val);
			((Graphic)obj).color = ShadowColor;
			((TMP_Text)obj).text = StripColorTags(text);
			GameObject val2 = MakeRect("Text", val.transform);
			TextMeshProUGUI obj2 = ConfigureText(val2);
			((Graphic)obj2).color = Color.white;
			((TMP_Text)obj2).text = text;
			RectTransform val3 = (RectTransform)val2.transform;
			val3.anchorMin = Vector2.zero;
			val3.anchorMax = Vector2.one;
			Vector2 val4 = default(Vector2);
			((Vector2)(ref val4))..ctor(0f - ShadowDistance.x, 0f - ShadowDistance.y);
			val3.offsetMax = val4;
			val3.offsetMin = val4;
			CanvasGroup val5 = val.AddComponent<CanvasGroup>();
			val5.alpha = 0f;
			val5.interactable = false;
			val5.blocksRaycasts = false;
			_messages.Add(new Message
			{
				Go = val,
				Cg = val5,
				Born = now,
				Expiry = now + 7.5f
			});
		}

		private TextMeshProUGUI ConfigureText(GameObject go)
		{
			TextMeshProUGUI val = go.AddComponent<TextMeshProUGUI>();
			((TMP_Text)val).fontSize = 18f;
			((TMP_Text)val).richText = true;
			((TMP_Text)val).enableWordWrapping = true;
			((TMP_Text)val).alignment = (TextAlignmentOptions)1025;
			((Graphic)val).raycastTarget = false;
			if ((Object)(object)_font != (Object)null)
			{
				((TMP_Text)val).font = _font;
			}
			return val;
		}

		private static string StripColorTags(string text)
		{
			return Regex.Replace(text, "</?color[^>]*>", string.Empty);
		}

		private void Build()
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Expected O, but got Unknown
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			//IL_011b: Unknown result type (might be due to invalid IL or missing references)
			//IL_011c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_0138: Unknown result type (might be due to invalid IL or missing references)
			//IL_0152: Unknown result type (might be due to invalid IL or missing references)
			_font = FindGameFont();
			GameObject val = new GameObject("AP_ClientView");
			Object.DontDestroyOnLoad((Object)(object)val);
			_canvas = val.AddComponent<Canvas>();
			_canvas.renderMode = (RenderMode)0;
			_canvas.sortingOrder = 1000;
			CanvasScaler obj = val.AddComponent<CanvasScaler>();
			obj.uiScaleMode = (ScaleMode)1;
			obj.referenceResolution = new Vector2(1920f, 1080f);
			obj.screenMatchMode = (ScreenMatchMode)0;
			obj.matchWidthOrHeight = 1f;
			GameObject val2 = MakeRect("Panel", val.transform);
			RectTransform component = val2.GetComponent<RectTransform>();
			Vector2 val3 = (component.pivot = Vector2.zero);
			Vector2 anchorMin = (component.anchorMax = val3);
			component.anchorMin = anchorMin;
			component.anchoredPosition = new Vector2(14f, 14f);
			component.sizeDelta = new Vector2(440f, 300f);
			val2.AddComponent<RectMask2D>();
			GameObject val5 = MakeRect("Content", val2.transform);
			_content = val5.GetComponent<RectTransform>();
			RectTransform content = _content;
			RectTransform content2 = _content;
			val3 = (_content.pivot = Vector2.zero);
			anchorMin = (content2.anchorMax = val3);
			content.anchorMin = anchorMin;
			_content.anchoredPosition = new Vector2(10f, 8f);
			_content.sizeDelta = new Vector2(420f, 0f);
			VerticalLayoutGroup obj2 = val5.AddComponent<VerticalLayoutGroup>();
			((LayoutGroup)obj2).childAlignment = (TextAnchor)6;
			((HorizontalOrVerticalLayoutGroup)obj2).spacing = 3f;
			((HorizontalOrVerticalLayoutGroup)obj2).childControlWidth = true;
			((HorizontalOrVerticalLayoutGroup)obj2).childControlHeight = true;
			((HorizontalOrVerticalLayoutGroup)obj2).childForceExpandWidth = true;
			((HorizontalOrVerticalLayoutGroup)obj2).childForceExpandHeight = false;
			ContentSizeFitter obj3 = val5.AddComponent<ContentSizeFitter>();
			obj3.verticalFit = (FitMode)2;
			obj3.horizontalFit = (FitMode)0;
			((Behaviour)_canvas).enabled = _wantVisible;
			_built = true;
			Log.Info("AP client view built (font=" + (((Object)(object)_font != (Object)null) ? ((Object)_font).name : "default") + ").");
		}

		private static GameObject MakeRect(string name, Transform parent)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: 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_001b: Expected O, but got Unknown
			GameObject val = new GameObject(name);
			val.AddComponent<RectTransform>();
			val.transform.SetParent(parent, false);
			return val;
		}

		private static TMP_FontAsset FindGameFont()
		{
			TextMeshProUGUI[] array = Resources.FindObjectsOfTypeAll<TextMeshProUGUI>();
			foreach (TextMeshProUGUI val in array)
			{
				if ((Object)(object)((TMP_Text)val).font != (Object)null)
				{
					return ((TMP_Text)val).font;
				}
			}
			return null;
		}
	}
	public class LastConnectionInfo
	{
		public string Host;

		public string Port;

		public string SlotName;

		public string Password;
	}
	public class FileWriter : MonoBehaviour
	{
		private const string LastConnectionFileName = "last_connection.txt";

		public static void WriteLastConnection(string host, int port, string slotName, string password)
		{
			try
			{
				string path = Application.persistentDataPath + "/last_connection.txt";
				List<string> list = new List<string>
				{
					host ?? "",
					port.ToString(),
					slotName ?? "",
					password ?? ""
				};
				File.WriteAllLines(path, list.ToArray());
			}
			catch (Exception ex)
			{
				Debug.LogError((object)("Failed to write last connection info: " + ex.Message));
			}
		}

		public static LastConnectionInfo ReadLastConnection()
		{
			try
			{
				string path = Application.persistentDataPath + "/last_connection.txt";
				if (!File.Exists(path))
				{
					return null;
				}
				string[] array = File.ReadAllLines(path);
				return new LastConnectionInfo
				{
					Host = ((array.Length != 0) ? array[0] : null),
					Port = ((array.Length > 1) ? array[1] : null),
					SlotName = ((array.Length > 2) ? array[2] : null),
					Password = ((array.Length > 3) ? array[3] : null)
				};
			}
			catch (Exception ex)
			{
				Debug.LogError((object)("Failed to read last connection info: " + ex.Message));
				return null;
			}
		}
	}
	public class GameHandler : MonoBehaviour
	{
		[HarmonyPatch(typeof(Collectible), "OnDone")]
		private class Collectible_OnDone_Patch
		{
			private static void Prefix()
			{
				if (PikunikuAPMod.SlotData.Coinsanity)
				{
					_suppressCoinCredit = true;
				}
			}

			private static void Postfix(Collectible __instance)
			{
				if (PikunikuAPMod.SlotData.Coinsanity)
				{
					_suppressCoinCredit = false;
					string text = CoinLocationName(__instance);
					if (TryGetLocationId(text, out var locId))
					{
						Log.Message($"Coinsanity check: '{text}' ({locId}) [{CoinLine(__instance)}]");
						PikunikuAPMod.ArchipelagoHandler?.CheckLocation(locId);
					}
					else
					{
						Log.Message("Coin picked up (unmapped): " + CoinLine(__instance));
					}
					__instance.Collected = false;
				}
			}
		}

		[HarmonyPatch(typeof(CoinsManager), "AddCredit")]
		private class CoinsManager_AddCredit_Patch
		{
			private static bool Prefix()
			{
				if (!_suppressCoinCredit)
				{
					return true;
				}
				_suppressCoinCredit = false;
				return false;
			}
		}

		[HarmonyPatch(typeof(Collectible), "Start")]
		private class Collectible_Start_Reskin_Patch
		{
			private static void Postfix(Collectible __instance)
			{
				//IL_008b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0090: Unknown result type (might be due to invalid IL or missing references)
				//IL_0093: Unknown result type (might be due to invalid IL or missing references)
				MeshRenderer meshRenderer = __instance.meshRenderer;
				MeshFilter val = (((Object)(object)meshRenderer != (Object)null) ? ((Component)meshRenderer).GetComponent<MeshFilter>() : null);
				if ((Object)(object)val == (Object)null)
				{
					return;
				}
				if ((Object)(object)_coinMat == (Object)null)
				{
					if ((Object)(object)_coinTex == (Object)null)
					{
						_coinTex = LoadEmbeddedTexture("PikunikuAPMod.Assets.pikuniku_coin_ap_logo.png");
					}
					if ((Object)(object)_coinTex == (Object)null)
					{
						return;
					}
					_coinMat = MakeUnlitMaterial(_coinTex);
				}
				if ((Object)(object)_coinQuad == (Object)null && (Object)(object)val.sharedMesh != (Object)null)
				{
					Bounds bounds = val.sharedMesh.bounds;
					_coinQuad = CreateQuadMesh(((Bounds)(ref bounds)).size);
				}
				if (!((Object)(object)_coinQuad == (Object)null))
				{
					val.sharedMesh = _coinQuad;
					((Renderer)meshRenderer).sharedMaterial = _coinMat;
				}
			}
		}

		[HarmonyPatch(typeof(GiftBox), "SetupTrophy")]
		private class GiftBox_SetupTrophy_Reskin_Patch
		{
			private static void Postfix(GiftBox __instance)
			{
				//IL_0146: Unknown result type (might be due to invalid IL or missing references)
				//IL_014b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0153: Unknown result type (might be due to invalid IL or missing references)
				//IL_0158: Unknown result type (might be due to invalid IL or missing references)
				//IL_0160: Unknown result type (might be due to invalid IL or missing references)
				//IL_0165: Unknown result type (might be due to invalid IL or missing references)
				//IL_0169: Unknown result type (might be due to invalid IL or missing references)
				//IL_0173: Unknown result type (might be due to invalid IL or missing references)
				//IL_01b2: Unknown result type (might be due to invalid IL or missing references)
				//IL_01c1: Unknown result type (might be due to invalid IL or missing references)
				//IL_01d3: Unknown result type (might be due to invalid IL or missing references)
				//IL_01e1: Unknown result type (might be due to invalid IL or missing references)
				//IL_01f0: Unknown result type (might be due to invalid IL or missing references)
				//IL_0202: Unknown result type (might be due to invalid IL or missing references)
				//IL_0212: Unknown result type (might be due to invalid IL or missing references)
				//IL_0217: Unknown result type (might be due to invalid IL or missing references)
				//IL_021f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0224: Unknown result type (might be due to invalid IL or missing references)
				//IL_0228: Unknown result type (might be due to invalid IL or missing references)
				//IL_0236: Unknown result type (might be due to invalid IL or missing references)
				//IL_0244: Unknown result type (might be due to invalid IL or missing references)
				//IL_0268: Unknown result type (might be due to invalid IL or missing references)
				if ((Object)(object)__instance.transform_boxWrapper == (Object)null)
				{
					return;
				}
				List<MeshFilter> list = (from f in ((Component)__instance.transform_boxWrapper).GetComponentsInChildren<MeshFilter>(true)
					where (Object)(object)f.sharedMesh != (Object)null
					select f).ToList();
				if (list.Count == 0)
				{
					return;
				}
				List<MeshFilter> list2 = (from f in list.OrderByDescending((MeshFilter f) => MeshVolume(f.sharedMesh)).Take(2)
					orderby ((Component)f).transform.position.y descending
					select f).ToList();
				foreach (MeshFilter item in list)
				{
					if (!list2.Contains(item))
					{
						MeshRenderer component = ((Component)item).GetComponent<MeshRenderer>();
						if ((Object)(object)component != (Object)null)
						{
							((Renderer)component).enabled = false;
						}
					}
				}
				if (list2.Count == 1)
				{
					ApplyPresentSkin(list2[0], top: false);
					return;
				}
				MeshFilter val = list2[0];
				MeshFilter val2 = list2[1];
				Texture2D val3 = PresentTexture(top: true);
				Texture2D val4 = PresentTexture(top: false);
				if (!((Object)(object)val3 == (Object)null) && !((Object)(object)val4 == (Object)null))
				{
					Vector3 lossyScale = ((Component)val).transform.lossyScale;
					Vector3 lossyScale2 = ((Component)val2).transform.lossyScale;
					Bounds bounds = val.sharedMesh.bounds;
					float num = ((Bounds)(ref bounds)).size.x * Mathf.Abs(lossyScale.x);
					float num2 = num * ((float)((Texture)val3).height / (float)((Texture)val3).width);
					float num3 = num * ((float)((Texture)val4).height / (float)((Texture)val4).width);
					ApplyPresentSkinSized(val, top: true, new Vector3(num / Mathf.Abs(lossyScale.x), num2 / Mathf.Abs(lossyScale.y), 0f));
					ApplyPresentSkinSized(val2, top: false, new Vector3(num / Mathf.Abs(lossyScale2.x), num3 / Mathf.Abs(lossyScale2.y), 0f));
					Vector3 position = ((Component)val).transform.position;
					Vector3 position2 = ((Component)val2).transform.position;
					position2.x = position.x;
					position2.z = position.z;
					position2.y = position.y - num2 * 0.5f - num3 * 0.5f;
					((Component)val2).transform.position = position2;
				}
			}
		}

		[HarmonyPatch(typeof(InventoryManager), "SetupAnimObj")]
		private class InventoryManager_SetupAnimObj_Patch
		{
			private static void Postfix(InventoryManager __instance, Inventory_Object obj)
			{
				if (!((Object)(object)obj != (Object)null) || obj.UniqueID != 1358097203)
				{
					ApplyApPopupOverride(__instance);
				}
			}
		}

		[HarmonyPatch(typeof(InventoryManager), "SetupAnimHat")]
		private class InventoryManager_SetupAnimHat_Patch
		{
			private static void Postfix(InventoryManager __instance)
			{
				ApplyApPopupOverride(__instance);
			}
		}

		[HarmonyPatch(typeof(Piku), "_KillCoroutine")]
		private class Piku_KillCoroutine_DeathLink_Patch
		{
			private static void Prefix(bool hasRespawnPos)
			{
				if (!hasRespawnPos)
				{
					PikunikuAPMod.ArchipelagoHandler?.OnPlayerGameOver();
				}
			}
		}

		[HarmonyPatch(typeof(Piku), "Kill", new Type[] { })]
		private class Piku_Kill_Patch
		{
			private static bool Prefix()
			{
				PikunikuAPMod.ArchipelagoHandler.SendDeath();
				return true;
			}
		}

		[HarmonyPatch(typeof(InventoryManager), "_AddHatWithAnimation")]
		private class InventoryManager_AddHatWithAnimation_Patch
		{
			private static bool Prefix(InventoryManager __instance, HatSO ObjectToAdd, bool hasBeenBought, ref IEnumerator __result)
			{
				if (!hasBeenBought)
				{
					return true;
				}
				if ((Object)(object)ObjectToAdd == (Object)null || !TryGetLocationId(HatLocationName(ObjectToAdd.UniqueID), out var _))
				{
					return true;
				}
				__instance.Hat_Add(ObjectToAdd, true);
				__result = ShopPurchaseNoop();
				return false;
			}
		}

		[HarmonyPatch(typeof(InventoryManager), "_AddObjectWithAnimation")]
		private class InventoryManager_AddObjectWithAnimation_Patch
		{
			private static bool Prefix(InventoryManager __instance, Inventory_Object ObjectToAdd, string WorldName, bool hasBeenBought, ref IEnumerator __result)
			{
				if (!hasBeenBought)
				{
					return true;
				}
				if ((Object)(object)ObjectToAdd == (Object)null || !TryGetLocationId(ObjectLocationName(ObjectToAdd.UniqueID), out var _))
				{
					return true;
				}
				__instance.Object_Add(ObjectToAdd, WorldName, true);
				__result = ShopPurchaseNoop();
				return false;
			}
		}

		[HarmonyPatch(typeof(InventoryManager), "Hat_Add")]
		private class InventoryManager_Hat_Add_Patch
		{
			private static bool Prefix(HatSO ObjectToAdd)
			{
				if ((Object)(object)ObjectToAdd == (Object)null)
				{
					return true;
				}
				if ((Object)(object)PikunikuAPMod.ItemHandler != (Object)null && PikunikuAPMod.ItemHandler.IsReceivingItem)
				{
					return true;
				}
				Log.Info($"Caught Hat Receipt: {((Object)ObjectToAdd).name} (ID: {ObjectToAdd.UniqueID})");
				string text = HatLocationName(ObjectToAdd.UniqueID);
				if (TryGetLocationId(text, out var locId))
				{
					Log.Info($"Sending AP Check for {text} ({locId})");
					PikunikuAPMod.ArchipelagoHandler.CheckLocation(locId);
					return false;
				}
				return true;
			}
		}

		[HarmonyPatch(typeof(Piku), "SetDefaultProperties")]
		private class Piku_SetDefaultProperties_Patch
		{
			private static void Postfix(Piku __instance)
			{
				//IL_001c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0021: Unknown result type (might be due to invalid IL or missing references)
				//IL_0049: 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_0051: Unknown result type (might be due to invalid IL or missing references)
				//IL_0062: Unknown result type (might be due to invalid IL or missing references)
				//IL_0069: Unknown result type (might be due to invalid IL or missing references)
				//IL_006a: Unknown result type (might be due to invalid IL or missing references)
				if (!PikunikuAPMod.ArchipelagoHandler.IsConnected)
				{
					return;
				}
				Color val = Color.HSVToRGB(Random.value, 0.75f, 0.9f);
				string pikuColor = PikunikuAPMod.SlotData.PikuColor;
				if (!(pikuColor == "0"))
				{
					Color val2 = default(Color);
					if (pikuColor == "1")
					{
						__instance.Set_BodyColor(val);
						__instance.default_bodyColor = val;
					}
					else if (ColorUtility.TryParseHtmlString(pikuColor, ref val2))
					{
						__instance.Set_BodyColor(val2);
						__instance.default_bodyColor = val2;
					}
				}
			}
		}

		[HarmonyPatch(typeof(InventoryManager), "Object_Add")]
		private class InventoryManager_Object_Add_Patch
		{
			private static bool Prefix(Inventory_Object ObjectToAdd)
			{
				if ((Object)(object)ObjectToAdd == (Object)null)
				{
					return true;
				}
				if (ObjectToAdd.UniqueID == 1358097203)
				{
					return true;
				}
				if ((Object)(object)PikunikuAPMod.ItemHandler != (Object)null && PikunikuAPMod.ItemHandler.IsReceivingItem)
				{
					return true;
				}
				Log.Info($"Caught Object Receipt: {((Object)ObjectToAdd).name} (ID: {ObjectToAdd.UniqueID})");
				string text = ObjectLocationName(ObjectToAdd.UniqueID);
				if (TryGetLocationId(text, out var locId))
				{
					Log.Info($"Sending AP Check for {text} ({locId})");
					PikunikuAPMod.ArchipelagoHandler.CheckLocation(locId);
					if (ObjectToAdd.UniqueID == 1632897859)
					{
						_appleCheckIndex++;
					}
					return false;
				}
				return true;
			}
		}

		[HarmonyPatch(typeof(TrophiesManager), "CatchTrophy")]
		private class TrophiesManager_CatchTrophy_Patch
		{
			private static bool Prefix(Trophy trophy)
			{
				//IL_0032: Unknown result type (might be due to invalid IL or missing references)
				if ((Object)(object)trophy == (Object)null)
				{
					return true;
				}
				if ((Object)(object)PikunikuAPMod.ItemHandler != (Object)null && PikunikuAPMod.ItemHandler.IsReceivingItem)
				{
					return true;
				}
				Log.Info($"Caught Trophy Receipt: {((Object)trophy).name} (ID: {trophy.achievementID})");
				string text = TrophyLocationName(((object)Unsafe.As<Trophies, Trophies>(ref trophy.achievementID)/*cast due to .constrained prefix*/).ToString());
				if (TryGetLocationId(text, out var locId))
				{
					Log.Info($"Sending AP Check for {text} ({locId})");
					PikunikuAPMod.ArchipelagoHandler.CheckLocation(locId);
				}
				return false;
			}
		}

		[HarmonyPatch(typeof(HatCatch), "CheckIfAlreadyCollected")]
		private class HatCatch_CheckIfAlreadyCollected_Patch
		{
			private static bool Prefix(ref bool __result)
			{
				__result = false;
				return false;
			}
		}

		[HarmonyPatch(typeof(HatCatch), "Start")]
		private class HatCatch_Start_Patch
		{
			private static void Postfix(HatCatch __instance)
			{
				if ((Object)(object)__instance.hat != (Object)null && TryGetLocationId(HatLocationName(__instance.hat.UniqueID), out var locId) && IsChecked(locId))
				{
					__instance.DisableHat();
				}
			}
		}

		[HarmonyPatch(typeof(ObjectCatch), "Start")]
		private class ObjectCatch_Start_Patch
		{
			private static void Postfix(ObjectCatch __instance)
			{
				if ((Object)(object)__instance.obj == (Object)null)
				{
					return;
				}
				long locId;
				if (__instance.obj.UniqueID == 1632897859)
				{
					if (NextAppleLocationName() == null)
					{
						((Component)__instance).gameObject.SetActive(false);
					}
					else
					{
						__instance.Collected = false;
					}
				}
				else if (TryGetLocationId(ObjectLocationName(__instance.obj.UniqueID), out locId))
				{
					if (IsChecked(locId))
					{
						((Component)__instance).gameObject.SetActive(false);
					}
					else
					{
						__instance.Collected = false;
					}
				}
			}
		}

		[HarmonyPatch(typeof(Mine_ComputerRoom), "Start")]
		private class Mine_ComputerRoom_Start_Patch
		{
			private static void Postfix(Mine_ComputerRoom __instance)
			{
				//IL_0063: Unknown result type (might be due to invalid IL or missing references)
				//IL_006d: Expected O, but got Unknown
				if (!((Object)(object)__instance.worm == (Object)null) && TryGetLocationId("A Video Game", out var locId))
				{
					if (IsChecked(locId))
					{
						((NPC)__instance.worm).dialogueModule.customCoroutineDial = null;
						((NPC)__instance.worm).SetDialogues((dialogueSegment[])(object)new dialogueSegment[1] { Mine_ComputerRoom.dial_checkPlayed });
					}
					else
					{
						((NPC)__instance.worm).dialogueModule.customCoroutineDial = new DialCoroutineDelegate(__instance._GiveCartridge);
					}
					((NPC)__instance.worm).canTalk = true;
				}
			}
		}

		[HarmonyPatch(typeof(GiftBox), "hasAlreadyBeenCollected")]
		private class GiftBox_hasAlreadyBeenCollected_Patch
		{
			private static bool Prefix(ref bool __result)
			{
				__result = false;
				return false;
			}
		}

		[HarmonyPatch(typeof(GiftBox), "Start")]
		private class GiftBox_Start_Patch
		{
			private static void Postfix(GiftBox __instance)
			{
				if ((Object)(object)__instance.trophy != (Object)null && TryGetLocationId(TrophyLocationName(((object)Unsafe.As<Trophies, Trophies>(ref __instance.trophy.achievementID)/*cast due to .constrained prefix*/).ToString()), out var locId) && IsChecked(locId))
				{
					((Component)__instance).gameObject.SetActive(false);
				}
			}
		}

		[HarmonyPatch(typeof(Collectible), "Start")]
		private class Collectible_Start_Hide_Patch
		{
			private static void Postfix(Collectible __instance)
			{
				if (TryGetLocationId(CoinLocationName(__instance), out var locId) && IsChecked(locId))
				{
					((Component)__instance).gameObject.SetActive(false);
				}
			}
		}

		[HarmonyPatch(typeof(Mine_RockFall), "Awake")]
		private class Mine_RockFall_Awake_Disable_Patch
		{
			private static void Postfix(Mine_RockFall __instance)
			{
				((Component)__instance).gameObject.SetActive(false);
			}
		}

		[HarmonyPatch(typeof(InsectManager), "OnInsectSeen")]
		private class InsectManager_OnInsectSeen_Patch
		{
			private static void Postfix(Insect insectID)
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				//IL_002c: Unknown result type (might be due to invalid IL or missing references)
				//IL_000f: Unknown result type (might be due to invalid IL or missing references)
				string text = InsectLocationName(insectID);
				if (text != null)
				{
					Log.Message($"Insect danced: {insectID} -> '{text}'");
					SendCheck(text);
				}
				else
				{
					Log.Message($"Insect danced (unmapped): {insectID}");
				}
			}
		}

		[HarmonyPatch(/*Could not decode attribute arguments.*/)]
		private class MainStory_CurrentSegment_Setter_Patch
		{
			private static void Postfix(int value)
			{
				switch (value)
				{
				case 24:
					SendCheck("Defeat the First Giant Robot");
					break;
				case 28:
					SendCheck("Defeat the Second Giant Robot");
					break;
				case 40:
					SendCheck("Defeat the Third Giant Robot");
					break;
				}
			}
		}

		[HarmonyPatch(typeof(HQ_BossManager), "MayorKick")]
		private class HQ_BossManager_MayorKick_Patch
		{
			private static void Prefix()
			{
				ArchipelagoHandler archipelagoHandler = PikunikuAPMod.ArchipelagoHandler;
				if (archipelagoHandler != null && archipelagoHandler.IsConnected)
				{
					Log.Message("Mr. Sunshine defeated - releasing Archipelago goal");
					PikunikuAPMod.ArchipelagoHandler.SetGoal();
				}
			}
		}

		[HarmonyPatch(typeof(PikuPaint), "CloseIt")]
		private class PikuPaint_CloseIt_Patch
		{
			private static void Postfix(DrawingArea drawArea)
			{
				if (!((Object)(object)drawArea == (Object)null) && drawArea.isForest && !drawArea.IsEmpty())
				{
					SendCheck("Draw on the Tree");
				}
			}
		}

		[HarmonyPatch(typeof(UI_PauseMenu), "Launch")]
		private class UI_PauseMenu_Launch_Patch
		{
			private static void Postfix(UI_PauseMenu __instance)
			{
				if (__instance.isTitleScreen)
				{
					UI_MenuPanel_Aventure val = Object.FindObjectOfType<UI_MenuPanel_Aventure>();
					if (!((Object)(object)val == (Object)null))
					{
						APConnectionPanel.CreateFor(__instance, val);
					}
				}
			}
		}

		[HarmonyPatch(typeof(UI_PauseMenu), "SwitchToPanelFromBack")]
		private class UI_PauseMenu_Back_Disconnect_Patch
		{
			[HarmonyPrefix]
			private static void Prefix(UI_PauseMenu __instance, UI_MenuPanel sourcePanel)
			{
				if (__instance.isTitleScreen)
				{
					Log.Info("Disconnecting from Archipelago, hit back on title screen");
					PikunikuAPMod.ArchipelagoHandler?.Disconnect();
				}
			}
		}

		[HarmonyPatch(typeof(UI_PauseMenu), "SwitchToPanel", new Type[]
		{
			typeof(UI_MenuPanel),
			typeof(int)
		})]
		private class UI_PauseMenu_SwitchToPanel_Patch
		{
			private static void Prefix(UI_PauseMenu __instance, ref UI_MenuPanel nextPanel, int direction)
			{
				UI_MenuPanel obj = nextPanel;
				UI_MenuPanel_Aventure val = (UI_MenuPanel_Aventure)(object)((obj is UI_MenuPanel_Aventure) ? obj : null);
				if (val == null)
				{
					return;
				}
				ArchipelagoHandler archipelagoHandler = PikunikuAPMod.ArchipelagoHandler;
				if (archipelagoHandler == null || !archipelagoHandler.IsConnected)
				{
					APConnectionPanel aPConnectionPanel = APConnectionPanel.Instance;
					if ((Object)(object)aPConnectionPanel == (Object)null)
					{
						Log.Info("APConnectionPanel.Instance was null in SwitchToPanel prefix, attempting to create...");
						aPConnectionPanel = APConnectionPanel.CreateFor(__instance, val);
					}
					if ((Object)(object)aPConnectionPanel == (Object)null)
					{
						Log.Error("Failed to ensure APConnectionPanel instance");
						return;
					}
					((UI_MenuPanel)aPConnectionPanel).panelOnBack = __instance.currentPanel;
					((UI_MenuPanel)aPConnectionPanel).panelOnBack_position = -direction;
					nextPanel = (UI_MenuPanel)(object)aPConnectionPanel;
				}
			}
		}

		[HarmonyPatch(typeof(InventoryManager), "Start")]
		public class InventoryManager_Start_Patch
		{
			public static void Postfix()
			{
				if ((Object)(object)PikunikuAPMod.ItemHandler != (Object)null)
				{
					Log.Debug("InventoryManager started, flushing item queue...");
					PikunikuAPMod.ItemHandler.FlushQueue();
				}
			}
		}

		[HarmonyPatch(typeof(Event_MountainVillage_Boss), "EventsCoroutine")]
		private class Event_MountainVillage_Boss_EventsCoroutine_Patch
		{
			private static IEnumerator EmptyCoroutine()
			{
				yield break;
			}

			private static bool Prefix(ref IEnumerator __result)
			{
				ArchipelagoHandler archipelagoHandler = PikunikuAPMod.ArchipelagoHandler;
				if ((Object)(object)archipelagoHandler == (Object)null || !archipelagoHandler.IsConnected)
				{
					return true;
				}
				if (archipelagoHandler.HasReceivedItem("Water Hat"))
				{
					return true;
				}
				Log.Message("Blocked second robot boss: Water Hat not received from AP");
				PikunikuAPMod.ClientView?.QueueMessage("You need the Water Hat to fight the second robot!");
				__result = EmptyCoroutine();
				return false;
			}
		}

		[HarmonyPatch(typeof(BuyableObject), "Buy")]
		private class BuyableObject_Buy_Patch
		{
			private static bool Prefix(BuyableObject __instance)
			{
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				//IL_000d: Invalid comparison between Unknown and I4
				HideBuyableIfChecked(__instance);
				string locationName = (((int)__instance.buyType != 1) ? (((Object)(object)__instance.obj != (Object)null) ? ObjectLocationName(__instance.obj.UniqueID) : null) : (((Object)(object)__instance.hat != (Object)null) ? HatLocationName(__instance.hat.UniqueID) : null));
				if (TryGetLocationId(locationName, out var locId))
				{
					return !IsChecked(locId);
				}
				return true;
			}
		}

		[HarmonyPatch(typeof(InventoryManager), "PutHatOnLoading")]
		private class InventoryManager_PutHatOnLoading_Patch
		{
			private static void Prefix()
			{
				_suppressHatOwnershipCheck = true;
			}

			private static void Postfix()
			{
				_suppressHatOwnershipCheck = false;
			}
		}

		[HarmonyPatch(typeof(InventoryManager), "Hat_AlreadyInInventory")]
		private class InventoryManager_Hat_AlreadyInInventory_Patch
		{
			private static void Postfix(HatSO hatToCheck, ref bool __result)
			{
				if (__result && !_suppressHatOwnershipCheck && !((Object)(object)hatToCheck == (Object)null))
				{
					string text = HatLocationName(hatToCheck.UniqueID);
					if (text != null && text.IndexOf("Purchase", StringComparison.Ordinal) >= 0)
					{
						__result = false;
					}
				}
			}
		}

		[HarmonyPatch(typeof(InventoryManager), "Object_CheckForTypePossession")]
		private class InventoryManager_Object_CheckForTypePossession_Patch
		{
			private static void Postfix(Inventory_Object ObjectToCheck, ref bool __result)
			{
				if (__result && !((Object)(object)ObjectToCheck == (Object)null))
				{
					string text = ObjectLocationName(ObjectToCheck.UniqueID);
					if (text != null && text.IndexOf("Purchase", StringComparison.Ordinal) >= 0)
					{
						__result = false;
					}
				}
			}
		}

		private const int ScarecrowFaceId = 1358097203;

		private const int StorySegment_WakeUp = 0;

		private const int StorySegment_WhereAmI = 2;

		private static bool _suppressCoinCredit;

		private static Texture2D _coinTex;

		private static Texture2D _presentTex;

		private static Texture2D _presentTopTex;

		private static Material _coinMat;

		private static Material _presentMat;

		private static Material _presentTopMat;

		private static Mesh _coinQuad;

		private static Texture2D _apLogoTex;

		private static Material _apLogoMat;

		private static int _appleCheckIndex;

		private volatile bool _pendingDeathLinkKill;

		private static bool _suppressHatOwnershipCheck;

		private void Awake()
		{
			SceneManager.sceneLoaded += OnSceneLoaded;
		}

		private void OnDestroy()
		{
			SceneManager.sceneLoaded -= OnSceneLoaded;
		}

		private static void OnSceneLoaded(Scene scene, LoadSceneMode _)
		{
			if (((Scene)(ref scene)).name == "66_PROLOGUE")
			{
				PikunikuAPMod.ClientView?.QueueMessage("Tip: Press F2 to skip the intro, and press F1 to unstuck yourself.");
			}
			BuyableObject[] array = Object.FindObjectsOfType<BuyableObject>();
			for (int i = 0; i < array.Length; i++)
			{
				HideBuyableIfChecked(array[i]);
			}
		}

		private static void HideBuyableIfChecked(BuyableObject b)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Invalid comparison between Unknown and I4
			string locationName = (((int)b.buyType != 1) ? (((Object)(object)b.obj != (Object)null) ? ObjectLocationName(b.obj.UniqueID) : null) : (((Object)(object)b.hat != (Object)null) ? HatLocationName(b.hat.UniqueID) : null));
			if (TryGetLocationId(locationName, out var locId) && IsChecked(locId))
			{
				((Component)b).gameObject.SetActive(false);
			}
		}

		private void Start()
		{
		}

		private void Update()
		{
			if (Input.GetKeyDown((KeyCode)288))
			{
				DumpIds();
			}
			if (Input.GetKeyDown((KeyCode)282))
			{
				ForceRestartArea();
			}
			if (Input.GetKeyDown((KeyCode)283))
			{
				TrySkipCutscene();
			}
			if (_pendingDeathLinkKill)
			{
				_pendingDeathLinkKill = false;
				ApplyDeathLinkKill();
			}
		}

		private static void TrySkipCutscene()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			Scene activeScene = SceneManager.GetActiveScene();
			if (((Scene)(ref activeScene)).name == "66_PROLOGUE" && !((Object)(object)MainStory_Manager.S != (Object)null))
			{
				Log.Message("Skipping prologue cutscene -> Mountain Village");
				if ((Object)(object)MainStory_Manager.S != (Object)null)
				{
					MainStory_Manager.S.CurrentSegment = 2;
				}
				SceneManager.LoadScene("02_MOUNTAINVILLAGE");
			}
		}

		private static void ForceRestartArea()
		{
			if (!((Object)(object)LevelSpecific.S == (Object)null) && !((Object)(object)TransitionModule.S == (Object)null) && !TransitionModule.S.isPlaying)
			{
				string currentSceneName = GameManager.CurrentSceneName;
				string text = ((currentSceneName == "04_MINE") ? "04.1_LAKE" : currentSceneName);
				Log.Message("Force restart: loading '" + text + "'");
				TransitionModule.S.SceneTransition_Smooth(text, false, 1.3f, (TransitionFX)null, (AnimationCurve)null);
			}
		}

		private static void DumpIds()
		{
			//IL_0192: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c1: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				StringBuilder stringBuilder = new StringBuilder();
				stringBuilder.AppendLine("===== Pikuniku AP — F7 ID Dump =====");
				HatSO[] array = Resources.FindObjectsOfTypeAll<HatSO>().OrderBy<HatSO, string>((HatSO h) => ((Object)h).name, StringComparer.OrdinalIgnoreCase).ToArray();
				stringBuilder.AppendLine($"--- Hats (HatSO) [{array.Length}] ---");
				HatSO[] array2 = array;
				foreach (HatSO val in array2)
				{
					stringBuilder.AppendLine($"  {val.UniqueID,-12} {((Object)val).name}");
				}
				Inventory_Object[] array3 = Resources.FindObjectsOfTypeAll<Inventory_Object>().OrderBy<Inventory_Object, string>((Inventory_Object o) => ((Object)o).name, StringComparer.OrdinalIgnoreCase).ToArray();
				stringBuilder.AppendLine($"--- Key Items (Inventory_Object) [{array3.Length}] ---");
				Inventory_Object[] array4 = array3;
				foreach (Inventory_Object val2 in array4)
				{
					stringBuilder.AppendLine($"  {val2.UniqueID,-12} {((Object)val2).name}");
				}
				Trophy[] array5 = Resources.FindObjectsOfTypeAll<Trophy>().OrderBy<Trophy, string>((Trophy t) => ((Object)t).name, StringComparer.OrdinalIgnoreCase).ToArray();
				stringBuilder.AppendLine($"--- Trophies (Trophy) [{array5.Length}] ---");
				Trophy[] array6 = array5;
				foreach (Trophy val3 in array6)
				{
					stringBuilder.AppendLine($"  {val3.achievementID,-16} {((Object)val3).name}");
				}
				Scene activeScene = SceneManager.GetActiveScene();
				string name = ((Scene)(ref activeScene)).name;
				Collectible[] array7 = (from val4 in Resources.FindObjectsOfTypeAll<Collectible>().Where(delegate(Collectible val4)
					{
						//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)
						Scene scene = ((Component)val4).gameObject.scene;
						return ((Scene)(ref scene)).IsValid();
					})
					orderby ((Component)val4).transform.position.y descending, ((Component)val4).transform.position.x
					select val4).ToArray();
				stringBuilder.AppendLine($"--- Coins (Collectible) in scene '{name}' [{array7.Length}] ---");
				Collectible[] array8 = array7;
				foreach (Collectible c in array8)
				{
					stringBuilder.AppendLine("  " + CoinLine(c));
				}
				stringBuilder.Append("===== end dump =====");
				Log.Message(stringBuilder.ToString());
			}
			catch (Exception arg)
			{
				Log.Error($"F7 ID dump failed: {arg}");
			}
		}

		private static string CoinLine(Collectible c)
		{
			//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_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			Vector3 position = ((Component)c).transform.position;
			return $"{c.UniqueID} (Loc: {position.x:0.0},{position.y:0.0})";
		}

		private static Material MakeUnlitMaterial(Texture2D tex)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Expected O, but got Unknown
			return new Material(Shader.Find("Sprites/Default"))
			{
				mainTexture = (Texture)(object)tex
			};
		}

		private static float MeshVolume(Mesh m)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: 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)
			Bounds bounds = m.bounds;
			Vector3 size = ((Bounds)(ref bounds)).size;
			return size.x * size.y * size.z;
		}

		private static void ApplyPresentSkin(MeshFilter mf, bool top)
		{
			//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_001f: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)mf.sharedMesh == (Object)null))
			{
				Bounds bounds = mf.sharedMesh.bounds;
				ApplyPresentSkinSized(mf, top, ((Bounds)(ref bounds)).size);
			}
		}

		private static void ApplyPresentSkinSized(MeshFilter mf, bool top, Vector3 localSize)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			Material val = PresentMaterial(top);
			if (!((Object)(object)val == (Object)null))
			{
				mf.sharedMesh = CreateQuadMesh(localSize);
				MeshRenderer component = ((Component)mf).GetComponent<MeshRenderer>();
				if ((Object)(object)component != (Object)null)
				{
					((Renderer)component).sharedMaterial = val;
				}
			}
		}

		private static Texture2D PresentTexture(bool top)
		{
			if (top)
			{
				if ((Object)(object)_presentTopTex == (Object)null)
				{
					_presentTopTex = LoadEmbeddedTexture("PikunikuAPMod.Assets.pikuniku_present_archipelago_top.png");
				}
				return _presentTopTex;
			}
			if ((Object)(object)_presentTex == (Object)null)
			{
				_presentTex = LoadEmbeddedTexture("PikunikuAPMod.Assets.pikuniku_present_archipelago.png");
			}
			return _presentTex;
		}

		private static Material PresentMaterial(bool top)
		{
			Texture2D val = PresentTexture(top);
			if ((Object)(object)val == (Object)null)
			{
				return null;
			}
			if (top)
			{
				if (!((Object)(object)_presentTopMat != (Object)null))
				{
					return _presentTopMat = MakeUnlitMaterial(val);
				}
				return _presentTopMat;
			}
			if (!((Object)(object)_presentMat != (Object)null))
			{
				return _presentMat = MakeUnlitMaterial(val);
			}
			return _presentMat;
		}

		private static void ApplyApPopupOverride(InventoryManager inv)
		{
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)PikunikuAPMod.ItemHandler != (Object)null && PikunikuAPMod.ItemHandler.IsReceivingItem)
			{
				return;
			}
			if ((Object)(object)_apLogoMat == (Object)null)
			{
				if ((Object)(object)_apLogoTex == (Object)null)
				{
					_apLogoTex = LoadEmbeddedTexture("PikunikuAPMod.Assets.archipelago_logo.png");
				}
				if ((Object)(object)_apLogoTex != (Object)null)
				{
					_apLogoMat = MakeUnlitMaterial(_apLogoTex);
				}
			}
			if ((Object)(object)_apLogoMat != (Object)null && (Object)(object)inv.Anim_meshFilter != (Object)null && (Object)(object)inv.Anim_meshRenderer != (Object)null)
			{
				Mesh sharedMesh = inv.Anim_meshFilter.sharedMesh;
				if ((Object)(object)sharedMesh != (Object)null)
				{
					if ((Object)(object)inv.Anim_ObjectRect != (Object)null)
					{
						((Transform)inv.Anim_ObjectRect).localEulerAngles = Vector3.zero;
					}
					MeshFilter anim_meshFilter = inv.Anim_meshFilter;
					Bounds bounds = sharedMesh.bounds;
					anim_meshFilter.sharedMesh = CreateQuadMeshForTexture(((Bounds)(ref bounds)).size, _apLogoTex);
				}
				((Renderer)inv.Anim_meshRenderer).sharedMaterial = _apLogoMat;
			}
			AutoText_UI anim_AutoText = inv.Anim_AutoText;
			if ((Object)(object)anim_AutoText != (Object)null && (Object)(object)anim_AutoText.text != (Object)null)
			{
				anim_AutoText.TextID = "";
				((TMP_Text)anim_AutoText.text).SetText("archipelago item");
			}
		}

		private static Mesh CreateQuadMeshForTexture(Vector3 footprint, Texture2D tex)
		{
			//IL_0000: 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_001b: 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_0078: Unknown result type (might be due to invalid IL or missing references)
			float num = ((footprint.x > 0f) ? footprint.x : 1f);
			float num2 = ((footprint.y > 0f) ? footprint.y : 1f);
			if ((Object)(object)tex != (Object)null && ((Texture)tex).width > 0 && ((Texture)tex).height > 0)
			{
				float num3 = (float)((Texture)tex).width / (float)((Texture)tex).height;
				if (num / num2 > num3)
				{
					num = num2 * num3;
				}
				else
				{
					num2 = num / num3;
				}
			}
			return CreateQuadMesh(new Vector3(num, num2, 0f));
		}

		private static Mesh CreateQuadMesh(Vector3 size)
		{
			//IL_0000: 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_0021: 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_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Expected O, but got Unknown
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: 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_0082: 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_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_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
			float num = ((size.x > 0f) ? (size.x * 0.5f) : 0.5f);
			float num2 = ((size.y > 0f) ? (size.y * 0.5f) : 0.5f);
			Mesh val = new Mesh();
			val.vertices = (Vector3[])(object)new Vector3[4]
			{
				new Vector3(0f - num, 0f - num2, 0f),
				new Vector3(num, 0f - num2, 0f),
				new Vector3(0f - num, num2, 0f),
				new Vector3(num, num2, 0f)
			};
			val.uv = (Vector2[])(object)new Vector2[4]
			{
				new Vector2(0f, 0f),
				new Vector2(1f, 0f),
				new Vector2(0f, 1f),
				new Vector2(1f, 1f)
			};
			val.triangles = new int[6] { 0, 2, 1, 2, 3, 1 };
			val.RecalculateNormals();
			val.RecalculateBounds();
			return val;
		}

		private static Texture2D LoadEmbeddedTexture(string resourceName)
		{
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Expected O, but got Unknown
			try
			{
				using Stream stream = Assembly.GetExecutingAssembly().GetManifestResourceStream(resourceName);
				if (stream == null)
				{
					Log.Error("Embedded texture not found: " + resourceName);
					return null;
				}
				byte[] array = new byte[stream.Length];
				stream.Read(array, 0, (int)stream.Length);
				Texture2D val = new Texture2D(2, 2);
				if (ImageConversion.LoadImage(val, array))
				{
					((Texture)val).wrapMode = (TextureWrapMode)1;
					Log.Info($"Loaded embedded texture {resourceName} ({((Texture)val).width}x{((Texture)val).height})");
					return val;
				}
				Log.Error("Failed to decode embedded texture: " + resourceName);
			}
			catch (Exception ex)
			{
				Log.Error("Error loading embedded texture " + resourceName + ": " + ex.Message);
			}
			return null;
		}

		public void InitOnConnect()
		{
		}

		public void SetupSeedSlot(string seed, string apSlot)
		{
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Expected O, but got Unknown
			try
			{
				if ((Object)(object)SlotManager.S == (Object)null)
				{
					Log.Warning("SlotManager not ready; cannot set per-seed save slot");
					return;
				}
				string text = MakeSlotName(apSlot, seed);
				Settings.S.CurrentSlotName = text;
				SlotManager.S.Slot = new Slot(text);
				Log.Info("Using per-seed game save slot: " + text);
			}
			catch (Exception arg)
			{
				Log.Error($"Failed to set per-seed save slot: {arg}");
			}
		}

		private static string MakeSlotName(string apSlot, string seed)
		{
			StringBuilder stringBuilder = new StringBuilder("AP_");
			AppendSanitized(stringBuilder, apSlot);
			stringBuilder.Append('_');
			AppendSanitized(stringBuilder, seed);
			return stringBuilder.ToString();
		}

		private static void AppendSanitized(StringBuilder sb, string s)
		{
			if (!string.IsNullOrEmpty(s))
			{
				foreach (char c in s)
				{
					sb.Append(char.IsLetterOrDigit(c) ? c : '_');
				}
			}
		}

		private static bool IsChecked(long locId)
		{
			if ((Object)(object)PikunikuAPMod.ArchipelagoHandler != (Object)null)
			{
				return PikunikuAPMod.ArchipelagoHandler.IsLocationChecked(locId);
			}
			return false;
		}

		private static bool TryGetLocationId(string locationName, out long locId)
		{
			locId = 0L;
			if (locationName != null)
			{
				return ArchipelagoConstants.Locations.TryGetValue(locationName, out locId);
			}
			return false;
		}

		private static string HatLocationName(int uniqueId)
		{
			return uniqueId switch
			{
				1477252700 => "Pencil Hat", 
				1042229131 => "Water Hat", 
				1070275662 => "Forest Sunglasses Purchase", 
				440003900 => "Forest X-Ray Goggles Purchase", 
				1370948795 => "Flower Hat", 
				1008585758 => "Beast Mask", 
				1531897703 => "Some Arms", 
				_ => null, 
			};
		}

		private static string NextAppleLocationName()
		{
			if (TryGetLocationId("Apple 1", out var locId) && IsChecked(locId) && _appleCheckIndex < 1)
			{
				_appleCheckIndex = 1;
			}
			if (TryGetLocationId("Apple 2", out var locId2) && IsChecked(locId2) && _appleCheckIndex < 2)
			{
				_appleCheckIndex = 2;
			}
			if (TryGetLocationId("Apple 3", out var locId3) && IsChecked(locId3) && _appleCheckIndex < 3)
			{
				_appleCheckIndex = 3;
			}
			if (_appleCheckIndex >= 3)
			{
				return null;
			}
			return "Apple " + (_appleCheckIndex + 1);
		}

		private static string ObjectLocationName(int uniqueId)
		{
			return uniqueId switch
			{
				1632897859 => NextAppleLocationName(), 
				132530138 => "A Video Game", 
				1533686085 => "Magnetic Card", 
				178453624 => "The Cabin Key", 
				70335859 => "A Detonator", 
				1363662089 => "Golden Tooth from the Silver Frog", 
				682565281 => "Valley Plush Purchase", 
				471216775 => "Forest Postcard Purchase", 
				_ => null, 
			};
		}

		private static string TrophyLocationName(string achievementId)
		{
			return achievementId switch
			{
				"WALKING_PIKU" => "Walking Piku Trophy", 
				"HIDDEN_ROCK" => "The Hidden Rock Trophy", 
				"BASKICK" => "Baskick Champion Trophy", 
				"SAM_SLIME" => "Sam The Slime Trophy", 
				"RESISTANCE" => "The Resistance Trophy", 
				"GIANT_ROBOT" => "A Giant Robot Trophy", 
				"GIANT_TOAST" => "Demonic Toast Trophy", 
				"PIKDUG" => "PikDug Trophy", 
				"BEACH" => "Piku at The Beach Trophy", 
				"WORMS" => "The Worms Trophy", 
				"ERNIE" => "Ernie the Worm Trophy", 
				"ROBOT" => "Sunshine Inc. Robot Trophy", 
				"MR_SUNSHINE" => "Mr. Sunshine Trophy", 
				"PIKU_NIKU_1" => "Piku & Niku I Trophy", 
				"PIKU_NIKU_2" => "Piku & Niku II Trophy", 
				"PIKU_NIKU_3" => "Piku & Niku III Trophy", 
				"PIKU_NIKU_4" => "Piku & Niku IV Trophy", 
				"PIKU_NIKU_5" => "Piku & Niku V Trophy", 
				_ => null, 
			};
		}

		private static string CoinLocationName(Collectible c)
		{
			//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_0012: 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)
			Vector3 position = ((Component)c).transform.position;
			return ArchipelagoConstants.ResolveCoinLocation(c.UniqueID, position.x, position.y);
		}

		private static string InsectLocationName(Insect insectId)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Expected I4, but got Unknown
			return (int)insectId switch
			{
				4 => "Sunshine HQ Dancing Bug", 
				2 => "Forest Dancing Bug", 
				3 => "Cave Dancing Bug", 
				0 => "Valley Dancing Bug", 
				1 => "Road to Forest Dancing Bug", 
				_ => null, 
			};
		}

		private static void SendCheck(string locationName)
		{
			if (TryGetLocationId(locationName, out var locId))
			{
				Log.Info($"Sending AP Check for {locationName} ({locId})");
				PikunikuAPMod.ArchipelagoHandler?.CheckLocation(locId);
			}
		}

		public void Kill()
		{
			_pendingDeathLinkKill = true;
		}

		private static void ApplyDeathLinkKill()
		{
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)LevelSpecific.S == (Object)null || (Object)(object)LevelSpecific.S.Piku == (Object)null)
			{
				return;
			}
			if (IsGameOverScene())
			{
				if ((Object)(object)TransitionModule.S != (Object)null && !TransitionModule.S.isPlaying)
				{
					Log.Message("DeathLink received — game over (restarting the encounter)");
					TransitionModule.S.SceneTransition_Smooth(GameManager.CurrentSceneName, false, 1.3f, (TransitionFX)null, (AnimationCurve)null);
				}
			}
			else
			{
				Log.Message("DeathLink received — spike kill");
				Piku piku = LevelSpecific.S.Piku;
				piku.Kill(((NPC)piku).bodyRb.position);
			}
		}

		private static bool IsGameOverScene()
		{
			if (!((Object)(object)Object.FindObjectOfType<Forest_BossManager>() != (Object)null) && !((Object)(object)Object.FindObjectOfType<Lake_Boss_Manager>() != (Object)null) && !((Object)(object)Object.FindObjectOfType<RunnerManager>() != (Object)null))
			{
				return (Object)(object)Object.FindObjectOfType<HQ_BossManager>() != (Object)null;
			}
			return true;
		}

		private static IEnumerator ShopPurchaseNoop()
		{
			yield break;
		}
	}
	public enum PikunikuItem
	{

	}
	public class ItemHandler : MonoBehaviour
	{
		private struct PendingPopup
		{
			public int Index;

			public long InternalId;

			public bool IsHat;

			public bool IsTrophy;

			public Trophies TrophyId;

			public int Credits;
		}

		private readonly Queue<KeyValuePair<int, ItemInfo>> cachedItems = new Queue<KeyValuePair<int, ItemInfo>>();

		private readonly Queue<PendingPopup> popupQueue = new Queue<PendingPopup>();

		private readonly object popupLock = new object();

		private bool isShowingPopups;

		public bool IsReceivingItem { get; set; }

		private bool IsGameReady()
		{
			if (PikunikuAPMod.SaveDataHandler?.SaveData == null)
			{
				Log.Debug("SaveData not ready");
				return false;
			}
			if (PikunikuAPMod.SlotData == null)
			{
				Log.Debug("SlotData not ready");
				return false;
			}
			if ((Object)(object)InventoryManager.S == (Object)null)
			{
				Log.Debug("InventoryManager not ready");
				return false;
			}
			return true;
		}

		public void HandleItem(int index, ItemInfo item, bool save = true)
		{
			try
			{
				if (!IsGameReady())
				{
					Log.Debug($"Game not ready, caching item: {item.ItemName} (index {index})");
					cachedItems.Enqueue(new KeyValuePair<int, ItemInfo>(index, item));
					return;
				}
				if (index < PikunikuAPMod.SaveDataHandler.SaveData.ItemIndex)
				{
					Log.Debug($"Item {index} already processed (current: {PikunikuAPMod.SaveDataHandler.SaveData.ItemIndex}), skipping");
					return;
				}
				if (cachedItems.Count > 0)
				{
					Log.Message($"Processing {cachedItems.Count} cached items...");
					FlushQueue();
				}
				ProcessItem(index, item, save);
			}
			catch (Exception arg)
			{
				Log.Error($"HandleItem Error: {arg}");
			}
		}

		public void FlushQueue()
		{
			if (!IsGameReady())
			{
				Log.Warning("Attempted to flush queue but game is not ready");
				return;
			}
			int num = 0;
			while (cachedItems.Count > 0)
			{
				KeyValuePair<int, ItemInfo> keyValuePair = cachedItems.Dequeue();
				ProcessItem(keyValuePair.Key, keyValuePair.Value, save: false);
				num++;
			}
			if (num > 0)
			{
				Log.Message($"Flushed {num} cached items");
				PikunikuAPMod.SaveDataHandler.SaveGame();
			}
		}

		private void ProcessItem(int index, ItemInfo item, bool save = true)
		{
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			CustomSaveData customSaveData = PikunikuAPMod.SaveDataHandler?.SaveData;
			if (customSaveData != null && index < customSaveData.ItemIndex)
			{
				Log.Debug($"Item {index} already processed (current: {customSaveData.ItemIndex}), skipping");
				return;
			}
			Log.Message($"Received item: {item.ItemName} (index {index}, ID {item.ItemId})");
			if (TryGetTrophy(item.ItemName, out var trophyId))
			{
				lock (popupLock)
				{
					popupQueue.Enqueue(new PendingPopup
					{
						Index = index,
						IsTrophy = true,
						TrophyId = trophyId
					});
					return;
				}
			}
			if (item.ItemName == "5 Coins")
			{
				lock (popupLock)
				{
					popupQueue.Enqueue(new PendingPopup
					{
						Index = index,
						Credits = 5
					});
					return;
				}
			}
			long num = 0L;
			bool isHat = false;
			switch (item.ItemName)
			{
			case "Pencil Hat":
				num = 1477252700L;
				isHat = true;
				break;
			case "Water Hat":
				num = 1042229131L;
				isHat = true;
				break;
			case "Sunglasses":
				num = 1070275662L;
				isHat = true;
				break;
			case "X-Ray Glasses":
				num = 440003900L;
				isHat = true;
				break;
			case "Flower Hat":
				num = 1370948795L;
				isHat = true;
				break;
			case "Beast Mask":
				num = 1008585758L;
				isHat = true;
				break;
			case "Some Arms":
				num = 1531897703L;
				isHat = true;
				break;
			case "Magnetic Card":
				num = 1533686085L;
				break;
			case "The Cabin Key":
				num = 178453624L;
				break;
			case "A Detonator":
				num = 70335859L;
				break;
			case "Apple":
				num = 1632897859L;
				break;
			case "The Golden Tooth from the Silver Frog":
				num = 1363662089L;
				break;
			case "A Video Game":
				num = 132530138L;
				break;
			case "A Scary Plush":
				num = 682565281L;
				break;
			case "Forest Postcard":
				num = 471216775L;
				break;
			}
			if (num == 0L)
			{
				Log.Warning($"Unhandled item: {item.ItemName} (ID {item.ItemId})");
			}
			lock (popupLock)
			{
				popupQueue.Enqueue(new PendingPopup
				{
					Index = index,
					InternalId = num,
					IsHat = isHat
				});
			}
		}

		private void Update()
		{
			if (!isShowingPopups)
			{
				bool flag;
				lock (popupLock)
				{
					flag = popupQueue.Count > 0;
				}
				if (flag)
				{
					((MonoBehaviour)this).StartCoroutine(DrainPopupQueue());
				}
			}
		}

		private IEnumerator DrainPopupQueue()
		{
			isShowingPopups = true;
			try
			{
				while (true)
				{
					PendingPopup pending;
					lock (popupLock)
					{
						if (popupQueue.Count == 0)
						{
							break;
						}
						pending = popupQueue.Dequeue();
						goto IL_0066;
					}
					IL_0066:
					yield return ShowPopup(pending);
				}
				PikunikuAPMod.SaveDataHandler?.SaveGame();
			}
			finally
			{
				isShowingPopups = false;
			}
		}

		private IEnumerator ShowPopup(PendingPopup pending)
		{
			if (pending.IsTrophy)
			{
				GrantTrophy(pending.TrophyId);
				AdvanceIndex(pending.Index);
				yield break;
			}
			if (pending.Credits > 0)
			{
				while ((Object)(object)InventoryManager.S == (Object)null || (Object)(object)InventoryManager.S.Coins == (Object)null)
				{
					yield return null;
				}
				GrantCoins(pending.Credits);
				AdvanceIndex(pending.Index);
				yield break;
			}
			HatSO hat = null;
			Inventory_Object obj = null;
			if (pending.InternalId != 0L)
			{
				if (pending.IsHat)
				{
					hat = ((IEnumerable<HatSO>)Resources.FindObjectsOfTypeAll<HatSO>()).FirstOrDefault((Func<HatSO, bool>)((HatSO h) => h.UniqueID == pending.InternalId));
					if ((Object)(object)hat == (Object)null)
					{
						Log.Warning($"Could not find HatSO with UniqueID {pending.InternalId}");
					}
				}
				else
				{
					obj = ((IEnumerable<Inventory_Object>)Resources.FindObjectsOfTypeAll<Inventory_Object>()).FirstOrDefault((Func<Inventory_Object, bool>)((Inventory_Object o) => o.UniqueID == pending.InternalId));
					if ((Object)(object)obj == (Object)null)
					{
						Log.Warning($"Could not find Inventory_Object with UniqueID {pending.InternalId}");
					}
				}
			}
			if ((Object)(object)hat != (Object)null || (Object)(object)obj != (Object)null)
			{
				while ((Object)(object)InventoryManager.S == (Object)null || InventoryManager.S.isAddingObject || InventoryManager.S.isOpen)
				{
					yield return null;
				}
				InventoryManager s = InventoryManager.S;
				IsReceivingItem = true;
				try
				{
					if ((Object)(object)hat != (Object)null)
					{
						yield return ((MonoBehaviour)s).StartCoroutine(s._AddHatWithAnimation(hat, false));
					}
					else
					{
						yield return ((MonoBehaviour)s).StartCoroutine(s._AddObjectWithAnimation(obj, "", false));
					}
				}
				finally
				{
					IsReceivingItem = false;
				}
			}
			AdvanceIndex(pending.Index);
		}

		private void AdvanceIndex(int index)
		{
			try
			{
				CustomSaveData customSaveData = PikunikuAPMod.SaveDataHandler?.SaveData;
				if (customSaveData != null && index >= customSaveData.ItemIndex)
				{
					customSaveData.ItemIndex = index + 1;
				}
			}
			catch (Exception arg)
			{
				Log.Error($"Failed to advance item index: {arg}");
			}
		}

		private void GrantTrophy(Trophies trophyId)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				Trophy val = ScriptableObject.CreateInstance<Trophy>();
				val.achievementID = trophyId;
				IsReceivingItem = true;
				try
				{
					TrophiesManager.S.CatchTrophy(val);
				}
				finally
				{
					IsReceivingItem = false;
				}
				Object.Destroy((Object)(object)val);
				Log.Message($"Granted trophy: {trophyId}");
			}
			catch (Exception arg)
			{
				Log.Error($"Failed to grant trophy {trophyId}: {arg}");
			}
		}

		private void GrantCoins(int amount)
		{
			try
			{
				InventoryManager.S.Coins.AddCredit(amount, true);
				Log.Message($"Granted {amount} coins");
			}
			catch (Exception arg)
			{
				Log.Error($"Failed to grant {amount} coins: {arg}");
			}
		}

		private static bool TryGetTrophy(string itemName, out Trophies trophyId)
		{
			switch (itemName)
			{
			case "Walking Piku Trophy":
				trophyId = (Trophies)0;
				return true;
			case "The Hidden Rock Trophy":
				trophyId = (Trophies)5;
				return true;
			case "Baskick Champion Trophy":
				trophyId = (Trophies)2;
				return true;
			case "Sam the Slime Trophy":
				trophyId = (Trophies)11;
				return true;
			case "The Resistance Trophy":
				trophyId = (Trophies)6;
				return true;
			case "A Giant Robot Trophy":
				trophyId = (Trophies)4;
				return true;
			case "The Demonic Toast Trophy":
				trophyId = (Trophies)12;
				return true;
			case "PikDug Trophy":
				trophyId = (Trophies)10;
				return true;
			case "Piku at the Beach Trophy":
				trophyId = (Trophies)3;
				return true;
			case "The Worms Trophy":
				trophyId = (Trophies)8;
				return true;
			case "Ernie the Worm Trophy":
				trophyId = (Trophies)9;
				return true;
			case "Sunshine Inc. Robot Trophy":
				trophyId = (Trophies)1;
				return true;
			case "Mr. Sunshine Trophy":
				trophyId = (Trophies)7;
				return true;
			case "Piku & Niku I Trophy":
				trophyId = (Trophies)13;
				return true;
			case "Piku & Niku II Trophy":
				trophyId = (Trophies)14;
				return true;
			case "Piku & Niku III Trophy":
				trophyId = (Trophies)15;
				return true;
			case "Piku & Niku IV Trophy":
				trophyId = (Trophies)16;
				return true;
			case "Piku & Niku V Trophy":
				trophyId = (Trophies)17;
				return true;
			default:
				trophyId = (Trophies)0;
				return false;
			}
		}
	}
	internal static class Log
	{
		private static ManualLogSource _logSource;

		internal static void Init(ManualLogSource logSource)
		{
			_logSource = logSource;
		}

		internal static void Debug(object data)
		{
			_logSource.LogDebug(data);
		}

		internal static void Error(object data)
		{
			_logSource.LogError(data);
		}

		internal static void Fatal(object data)
		{
			_logSource.LogFatal(data);
		}

		internal static void Info(object data)
		{
			_logSource.LogInfo(data);
		}

		internal static void Message(object data)
		{
			_logSource.LogMessage(data);
		}

		internal static void Warning(object data)
		{
			_logSource.LogWarning(data);
		}
	}
	public enum DeathLinkMode
	{
		On,
		Off,
		YamlSetting
	}
	[BepInPlugin("PikunikuAPMod", "Pikuniku Archipelago Mod", "0.3.1")]
	public class PikunikuAPMod : BaseUnityPlugin
	{
		private const string PluginGuid = "PikunikuAPMod";

		private const string PluginName = "Pikuniku Archipelago Mod";

		private const string PluginVersion = "0.3.1";

		private const string PluginAuthor = "Jeffdev";

		public static string PluginDir;

		private readonly Harmony harmony = new Harmony("PikunikuAPMod");

		public static ConfigEntry<bool> FilterLog;

		public static ConfigEntry<DeathLinkMode> DeathLink;

		public static SlotData SlotData;

		private static readonly Dictionary<string, Assembly> _resolvedDeps = new Dictionary<string, Assembly>();

		private static readonly string[] ForcedDeps = new string[3] { "Newtonsoft.Json", "websocket-sharp", "Archipelago.MultiClient.Net" };

		public static ArchipelagoHandler ArchipelagoHandler { get; private set; }

		public static GameHandler GameHandler { get; private set; }

		public static ItemHandler ItemHandler { get; private set; }

		public static ClientView ClientView { get; private set; }

		public static SaveDataHandler SaveDataHandler { get; private set; }

		public void Awake()
		{
			PluginDir = Path.GetDirectoryName(((BaseUnityPlugin)this).Info.Location);
			Log.Init(((BaseUnityPlugin)this).Logger);
			Log.Message("Pikuniku Archipelago Mod v0.3.1 — Release build");
			SetupDependencyResolver();
			Application.runInBackground = true;
			harmony.PatchAll();
			((Component)this).gameObject.AddComponent<FileWriter>();
			ArchipelagoHandler = ((Component)this).gameObject.AddComponent<ArchipelagoHandler>();
			GameHandler = ((Component)this).gameObject.AddComponent<GameHandler>();
			ItemHandler = ((Component)this).gameObject.AddComponent<ItemHandler>();
			ClientView = ((Component)this).gameObject.AddComponent<ClientView>();
			SaveDataHandler = new SaveDataHandler();
			ArchipelagoHandler.OnConnected += delegate
			{
				Log.Message("Connected to Archipelago - loading items");
			};
			ArchipelagoHandler.OnDisconnected += delegate
			{
				Log.Message("Disconnected from Archipelago");
			};
			FilterLog = ((BaseUnityPlugin)this).Config.Bind<bool>("Logging", "FilterLog", false, "Filter the archipelago log to only show messages relevant to you.");
			DeathLink = ((BaseUnityPlugin)this).Config.Bind<DeathLinkMode>("Archipelago", "DeathLink", DeathLinkMode.YamlSetting, "DeathLink (share deaths with the multiworld): On = always on, Off = always off, YamlSetting = follow the slot's yaml option.");
		}

		private void SetupDependencyResolver()
		{
			AppDomain.CurrentDomain.AssemblyResolve += ResolveBundledDependency;
			string[] forcedDeps = ForcedDeps;
			for (int i = 0; i < forcedDeps.Length; i++)
			{
				TryLoadFromPluginDir(forcedDeps[i]);
			}
		}

		private static Assembly ResolveBundledDependency(object sender, ResolveEventArgs args)
		{
			string name = new AssemblyName(args.Name).Name;
			string[] forcedDeps = ForcedDeps;
			foreach (string text in forcedDeps)
			{
				if (string.Equals(name, text, StringComparison.OrdinalIgnoreCase))
				{
					return TryLoadFromPluginDir(text);
				}
			}
			return null;
		}

		private static Assembly TryLoadFromPluginDir(string simpleName)
		{
			if (_resolvedDeps.TryGetValue(simpleName, out var value))
			{
				return value;
			}
			try
			{
				string text = Path.Combine(PluginDir, simpleName + ".dll");
				if (!File.Exists(text))
				{
					return null;
				}
				Assembly assembly = Assembly.LoadFrom(text);
				_resolvedDeps[simpleName] = assembly;
				Log.Info($"Loaded bundled dependency {simpleName} v{assembly.GetName().Version} from plugin folder");
				return assembly;
			}
			catch (Exception ex)
			{
				Log.Error("Failed to load bundled dependency " + simpleName + ": " + ex.Message);
				return null;
			}
		}

		public void OnDestroy()
		{
			ArchipelagoHandler?.Disconnect();
			AppDomain.CurrentDomain.AssemblyResolve -= ResolveBundledDependency;
			Harmony obj = harmony;
			if (obj != null)
			{
				obj.UnpatchSelf();
			}
		}
	}
	public class CustomSaveData
	{
		public int ItemIndex;

		public List<long> HintedLocationIds = new List<long>();
	}
	public class SaveDataHandler
	{
		private string folderName;

		private string fileName;

		public CustomSaveData SaveData;

		public void GetSaveGame(string seed, string slot)
		{
			if (SaveData == null)
			{
				PikunikuAPMod.ArchipelagoHandler.OnDisconnected += delegate
				{
					SaveGame();
					SaveData = null;
				};
				folderName = Application.persistentDataPath + "/ArchipelagoSaves";
				fileName = folderName + "/" + slot + seed + ".json";
				if (File.Exists(fileName))
				{
					LoadGame();
				}
				else
				{
					CreateNewGame();
				}
				PikunikuAPMod.ItemHandler.FlushQueue();
			}
		}

		private void LoadGame()
		{
			Log.Debug("Loading game...");
			try
			{
				using FileStream stream = new FileStream(fileName, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
				using StreamReader streamReader = new StreamReader(stream);
				string text = streamReader.ReadToEnd();
				SaveData = JsonUtility.FromJson<CustomSaveData>(text);
			}
			catch (Exception ex)
			{
				Log.Debug("Save file is corrupted or locked: " + ex.Message + ". Starting new game...");
				CreateNewGame();
				return;
			}
			Log.Debug("Game loaded!");
		}

		private void CreateNewGame()
		{
			Log.Debug("Creating new game...");
			SaveData = new CustomSaveData
			{
				ItemIndex = 0
			};
			SaveGame();
		}

		public void SaveGame()
		{
			if (SaveData == null)
			{
				return;
			}
			Log.Debug("Saving game...");
			Directory.CreateDirectory(folderName);
			using StreamWriter streamWriter = File.CreateText(fileName);
			streamWriter.Write(JsonUtility.ToJson((object)SaveData));
			streamWriter.Close();
		}
	}
	public class SlotData
	{
		public readonly bool DeathLink;

		public readonly int DeathLinkAmnesty;

		public readonly string PikuColor;

		public readonly bool Coinsanity;

		public readonly bool CoopLevels;

		public SlotData(Dictionary<string, object> slotDict)
		{
			if (slotDict.TryGetValue("coinsanity", out var value))
			{
				Coinsanity = (int)(long)value == 1;
			}
			if (slotDict.TryGetValue("coop_levels", out var value2))
			{
				CoopLevels = (int)(long)value2 == 1;
			}
			if (slotDict.TryGetValue("death_link_amnesty", out var value3))
			{
				DeathLinkAmnesty = (int)(long)value3;
			}
			if (slotDict.TryGetValue("death_link", out var value4))
			{
				DeathLink = (int)(long)value4 == 1;
			}
			if (slotDict.TryGetValue("piku_color", out var value5))
			{
				PikuColor = (string)value5;
			}
			PikunikuAPMod.ItemHandler.FlushQueue();
		}
	}
	[Serializable]
	public class SlotDataException : ApplicationException
	{
		public SlotDataException()
		{
		}

		public SlotDataException(string message)
			: base(message)
		{
		}

		public SlotDataException(string message, Exception innerException)
			: base(message, innerException)
		{
		}
	}
}
namespace System.Runtime.CompilerServices
{
	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
	internal sealed class IgnoresAccessChecksToAttribute : Attribute
	{
		internal IgnoresAccessChecksToAttribute(string assemblyName)
		{
		}
	}
}