using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Threading.Tasks;
using Archipelago.MultiClient.Net;
using Archipelago.MultiClient.Net.BounceFeatures.DeathLink;
using Archipelago.MultiClient.Net.Enums;
using Archipelago.MultiClient.Net.Helpers;
using Archipelago.MultiClient.Net.Models;
using BepInEx;
using BepInEx.Logging;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using POKModManager;
using Rewired;
using Steamworks;
using UnityEngine;
using UnityEngine.Events;
using UnityEngine.SceneManagement;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETStandard,Version=v2.0", FrameworkDisplayName = ".NET Standard 2.0")]
[assembly: AssemblyCompany("PeaksOfArchipelago")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.3.0.0")]
[assembly: AssemblyInformationalVersion("1.3.0+53313e97dd26b1f23afbd9ad20335c3ab4a94cae")]
[assembly: AssemblyProduct("Peaks Of Archipelago")]
[assembly: AssemblyTitle("PeaksOfArchipelago")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.3.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

		public NullableAttribute(byte P_0)
		{
			NullableFlags = new byte[1] { P_0 };
		}

		public NullableAttribute(byte[] P_0)
		{
			NullableFlags = P_0;
		}
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableContextAttribute : Attribute
	{
		public readonly byte Flag;

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.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 Archipelago.MultiClient.Net
{
	[AttributeUsage(AttributeTargets.Field, Inherited = false, AllowMultiple = false)]
	internal sealed class DataStoragePropertyAttribute : Attribute
	{
		public string? SessionVariable { get; }

		public Scope Scope { get; }

		public string Key { get; }

		public DataStoragePropertyAttribute(string sessionVariable, Scope scope, string key)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			SessionVariable = sessionVariable;
			Scope = scope;
			Key = key;
		}

		public DataStoragePropertyAttribute(string sessionVariable, string key)
			: this(sessionVariable, (Scope)0, key)
		{
		}
	}
}
namespace PeaksOfArchipelago
{
	public static class ModInfo
	{
		public const string MOD_GUID = "PeaksOfArchipelago";

		public const string MOD_NAME = "Peaks Of Archipelago";

		public const string MOD_DESC = "An Archipelago Implementation for Peaks Of Yore!";

		public const string MOD_VERSION = "1.3.0";
	}
	[BepInPlugin("PeaksOfArchipelago", "Peaks Of Archipelago", "1.3.0")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public class PeaksOfArchipelago : BaseUnityPlugin
	{
		internal static ManualLogSource Logger;

		private void Awake()
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Expected O, but got Unknown
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Expected O, but got Unknown
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			Logger = ((BaseUnityPlugin)this).Logger;
			Logger.LogInfo((object)"Plugin PeaksOfArchipelago is loaded!");
			Harmony val = new Harmony("PeaksOfArchipelago_Paths");
			MethodInfo methodInfo = AccessTools.PropertyGetter(AccessTools.TypeByName("POKModManager.Paths"), "GameFolder");
			MethodInfo method = typeof(Patch_Paths).GetMethod("Prefix", BindingFlags.Static | BindingFlags.Public);
			val.Patch((MethodBase)methodInfo, new HarmonyMethod(method), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			new POKManager(true);
		}

		private void Start()
		{
			POKManager.RegisterMod((ModClass)(object)new PeaksOfArchipelagoMod(), "Peaks Of Archipelago", "1.3.0", "An Archipelago Implementation for Peaks Of Yore!", true);
		}
	}
	public class Patch_Paths
	{
		public static bool Prefix(ref string __result)
		{
			__result = Directory.GetParent(Paths.BepInExRootPath).ToString();
			return false;
		}
	}
	public class PeaksOfArchipelagoMod : ModClass
	{
		[HarmonyPatch(typeof(StamperPeakSummit), "StampJournal")]
		public class PeakSummitedPatch
		{
			private static void Postfix(StamperPeakSummit __instance)
			{
				Peaks peaks = session.CompletePeakCheck(__instance);
			}
		}

		[HarmonyPatch(typeof(ArtefactOnPeak), "PickUpItem")]
		public class ArtefactOnPeakPatch
		{
			private static void Postfix(ArtefactOnPeak __instance)
			{
				Artefacts artefact = session.CompleteArtefactCheck(__instance);
				SimpleItemInfo locationDetails = session.GetLocationDetails(Utils.ArtefactToId(artefact));
				UnityUtils.SetArtefactText("Found " + locationDetails.playerName + "'s " + locationDetails.itemName);
			}
		}

		[HarmonyPatch(typeof(RopeCollectable), "PickUpRope")]
		public class RopeCollectablePatch
		{
			private static void Prefix(RopeCollectable __instance)
			{
				Ropes rope = session.CompleteRopeCheck(__instance);
				SimpleItemInfo locationDetails = session.GetLocationDetails(Utils.RopeToId(rope));
				UnityUtils.SetRopeText("Found " + locationDetails.playerName + "'s " + locationDetails.itemName);
			}

			private static void Postfix(ref IEnumerator __result, RopeCollectable __instance)
			{
				__result = MyWrapper(__result, __instance);
			}

			private static IEnumerator MyWrapper(IEnumerator original, RopeCollectable __instance)
			{
				while (original.MoveNext())
				{
					yield return original.Current;
				}
				UnityUtils.UndoRopeProgress(__instance);
				yield return null;
			}
		}

		[HarmonyPatch(typeof(BirdSeedCollectable), "PickUpBirdSeed")]
		public class BirdSeedCollectablePatch
		{
			private static void Prefix(BirdSeedCollectable __instance)
			{
				BirdSeeds birdSeed = session.CompleteSeedCheck(__instance);
				SimpleItemInfo locationDetails = session.GetLocationDetails(Utils.BirdSeedToId(birdSeed));
				UnityUtils.SetSeedText("Found " + locationDetails.playerName + "'s " + locationDetails.itemName);
				GameManager control = GameManager.control;
				control.extraBirdSeedUses--;
			}

			private static void Postfix(ref IEnumerator __result, RopeCollectable __instance)
			{
				__result = MyWrapper(__result, __instance);
			}

			private static IEnumerator MyWrapper(IEnumerator original, RopeCollectable __instance)
			{
				while (original.MoveNext())
				{
					yield return original.Current;
				}
				yield return null;
			}
		}

		[HarmonyPatch(typeof(FallingEvent), "FellToDeath")]
		public class FellToDeathPatch
		{
			private static void Postfix()
			{
				session.HandleDeath();
			}
		}

		[HarmonyPatch(typeof(ResetPosition), "FadeToBlack")]
		public class ResetPositionPatch
		{
			private static void Prefix(ResetPosition __instance)
			{
				if (!__instance.isSea)
				{
					session.HandleDeath();
				}
			}
		}

		[HarmonyPatch(typeof(ArtefactLoaderCabin), "LoadArtefacts")]
		public class ArtefactLoaderPatch
		{
			private static CheckList<Artefacts> savestate = new CheckList<Artefacts>();

			public static void Prefix(ArtefactLoaderCabin __instance)
			{
				foreach (Artefacts value in Enum.GetValues(typeof(Artefacts)))
				{
					savestate.SetCheck(value, UnityUtils.GetGameManagerArtefactCollected(value));
					UnityUtils.SetGameManagerArtefactCollected(value, session.playerData.items.artefacts.IsChecked(value));
					if (session.playerData.items.artefacts.IsChecked(value))
					{
						UnityUtils.SetGameManagerArtefactDirty(value, value: false);
					}
				}
			}

			public static void Postfix()
			{
				foreach (Artefacts value in Enum.GetValues(typeof(Artefacts)))
				{
					UnityUtils.SetGameManagerArtefactCollected(value, savestate.IsChecked(value));
					if (UnityUtils.GetGameManagerArtefactCollected(value) != savestate.IsChecked(value))
					{
						Debug.LogWarning((object)$"Error: {value} should be {savestate.IsChecked(value)} but is {!savestate.IsChecked(value)}!");
					}
				}
				GameManager.control.Save();
			}
		}

		[HarmonyPatch(typeof(NPCEvents), "CheckProgress")]
		public class CheckProgressPatch
		{
			private static bool usingPipe;

			public static void Prefix(NPCEvents __instance)
			{
				usingPipe = GameManager.control.isUsingPipe;
				ItemEventsPatch.isCustomEvent = false;
				session.CheckWin();
				session.UpdateReceivedItems();
				if (session.uncollectedItems.Count != 0 && !__instance.runningEvent && session.currentScene != "TitleScreen")
				{
					Debug.Log((object)"starting custom event");
					ItemEventsPatch.isCustomEvent = true;
					__instance.eventName = "AllArtefacts";
					__instance.runningEvent = true;
					((MonoBehaviour)__instance.npcParcelDeliverySystem).StartCoroutine("FadeScreenAndStartUnpackEvent");
				}
				else if (session.finished && !session.seenFinishedCutScene)
				{
					ItemEventsPatch.isFinishEvent = true;
					session.seenFinishedCutScene = true;
					__instance.eventName = "CompleteGame_Base";
					((MonoBehaviour)__instance).StartCoroutine("GlowDoorEvent");
				}
			}

			public static void Postfix(NPCEvents __instance)
			{
				session.SetFundamentalsBookActive(session.playerData.items.books.IsChecked(Books.Fundamentals));
				GameManager.control.monocular = session.playerData.items.monocular;
				if (!GameManager.control.monocular)
				{
					((MonoBehaviour)__instance).StopCoroutine("MissedMonocularTooltip");
				}
				if (!ItemEventsPatch.isCustomEvent && !ItemEventsPatch.isFinishEvent && __instance.runningEvent)
				{
					switch (__instance.eventName)
					{
					case "Rope":
					case "RopesUpgrade":
					case "ArtefactMap":
					case "Pocketwatch":
					case "Crampons":
					case "CramponsUpgrade":
					case "Chalkbag":
					case "AllArtefacts":
					case "TimeAttack_Event1":
					case "Category_2":
					case "Category_3":
					case "Category_4":
					case "Phonograph":
						__instance.runningEvent = false;
						Debug.Log((object)("Blocking event: " + __instance.eventName));
						((MonoBehaviour)__instance).StopCoroutine("GlowDoorEvent");
						break;
					}
				}
				if (session.playerData.items.pipe)
				{
					GameManager.control.smokingpipe = true;
					GameManager.control.isUsingPipe = usingPipe;
					__instance.cabinPipe.SetActive(true);
				}
			}
		}

		[HarmonyPatch(typeof(NPCSystem), "GivePlayerMonocular")]
		public class GivePlayerMonocularPatch
		{
			public static void Postfix()
			{
				GameManager.control.monocular = session.playerData.items.monocular;
				GameManager.control.Save();
			}
		}

		[HarmonyPatch(typeof(NPCSystem), "GivePlayerCoffee")]
		public class GivePlayerCoffeePatch
		{
			public static void Postfix()
			{
				GameManager.control.coffee = session.playerData.items.coffee;
				GameManager.control.Save();
			}
		}

		[HarmonyPatch(typeof(NPCSystem), "GivePlayerRope")]
		public class GivePlayerRopePatch
		{
			public static void Postfix(NPCSystem __instance)
			{
				Ropes rope = (Ropes)(-1);
				if (__instance.isStHaelga)
				{
					rope = Ropes.StHaelga;
				}
				if (__instance.isGreatGaol)
				{
					rope = Ropes.GreatGaol;
				}
				GameManager control = GameManager.control;
				control.ropesCollected--;
				RopeAnchor component = GameObject.FindGameObjectWithTag("Player").GetComponent<RopeAnchor>();
				component.anchorsInBackpack--;
				session.CompleteRopeCheck(rope);
				SimpleItemInfo locationDetails = session.GetLocationDetails(Utils.RopeToId(rope));
				UnityUtils.SetRopeText("Found " + locationDetails.playerName + "'s " + locationDetails.itemName);
			}
		}

		[HarmonyPatch(typeof(NPC_Climber), "GivePlayerRope")]
		public class ClimberGivePlayerRopePatch
		{
			public static void Postfix(NPC_Climber __instance)
			{
				Ropes rope = (Ropes)(-1);
				if (__instance.isWaltersCrag)
				{
					rope = Ropes.WaltersCrag;
				}
				if (__instance.isWalkersPillar)
				{
					rope = Ropes.WalkersPillar;
				}
				GameManager control = GameManager.control;
				control.ropesCollected--;
				RopeAnchor component = GameObject.FindGameObjectWithTag("Player").GetComponent<RopeAnchor>();
				component.anchorsInBackpack--;
				session.CompleteRopeCheck(rope);
				SimpleItemInfo locationDetails = session.GetLocationDetails(Utils.RopeToId(rope));
				UnityUtils.SetRopeText("Found " + locationDetails.playerName + "'s " + locationDetails.itemName);
			}
		}

		[HarmonyPatch(typeof(NPCEvents), "ItemEvents")]
		public class ItemEventsPatch
		{
			public static bool isCustomEvent = false;

			public static bool isFinishEvent = false;

			private static bool hasAllArtefacts = false;

			private static string tempText = "";

			private static bool usingPipe;

			private static Text textElement;

			private static void Prefix(NPCEvents __instance)
			{
				usingPipe = GameManager.control.isUsingPipe;
				hasAllArtefacts = GameManager.control.allArtefactsUnlocked;
				Text componentInChildren = __instance.allArtefactsInfo.GetComponentInChildren<Text>();
				tempText = componentInChildren.text;
				textElement = componentInChildren;
				string text = "You got: ";
				session.UpdateReceivedItems();
				SimpleItemInfo simpleItemInfo = session.uncollectedItems.Last();
				foreach (SimpleItemInfo uncollectedItem in session.uncollectedItems)
				{
					text += uncollectedItem.itemName;
					if (uncollectedItem.id != simpleItemInfo.id || uncollectedItem.itemName != simpleItemInfo.itemName || uncollectedItem.playerName != simpleItemInfo.playerName)
					{
						text += ", ";
					}
				}
				componentInChildren.text = text;
			}

			private static void Postfix(ref IEnumerator __result, NPCEvents __instance)
			{
				__result = MyWrapper(__result, __instance);
			}

			private static IEnumerator MyWrapper(IEnumerator original, NPCEvents __instance)
			{
				while (original.MoveNext())
				{
					yield return original.Current;
				}
				if (isCustomEvent)
				{
					isCustomEvent = false;
					GameManager.control.allArtefactsUnlocked = hasAllArtefacts;
					GameManager control = GameManager.control;
					control.ropesCollected -= 5;
					GameManager control2 = GameManager.control;
					control2.extraCoffeeUses -= 999999999;
					GameManager control3 = GameManager.control;
					control3.extraChalkUses -= 999999999;
					textElement.text = tempText;
					session.UpdateReceivedItems();
					List<SimpleItemInfo> items = session.uncollectedItems;
					session.uncollectedItems = new List<SimpleItemInfo>();
					foreach (SimpleItemInfo item in items)
					{
						session.UnlockById(item.id);
					}
					RopeCabinDescription[] array = Object.FindObjectsOfType<RopeCabinDescription>();
					foreach (RopeCabinDescription ropeCabinDescription in array)
					{
						ropeCabinDescription.UpdateCoffeeChalk();
					}
					ArtefactLoaderCabin obj = Object.FindObjectOfType<ArtefactLoaderCabin>();
					if (obj != null)
					{
						obj.LoadArtefacts();
					}
					RopeCabinDescription obj2 = Object.FindObjectOfType<RopeCabinDescription>();
					if (obj2 != null)
					{
						obj2.CheckCabinItems();
					}
				}
				if (session.playerData.items.pipe)
				{
					GameManager.control.smokingpipe = true;
					GameManager.control.isUsingPipe = usingPipe;
					__instance.cabinPipe.SetActive(true);
				}
				yield return null;
			}
		}

		[HarmonyPatch(typeof(Pipe), "CheckLoad")]
		public class PipeCheckPatch
		{
			private static bool isUsingPipe;

			private static void Prefix()
			{
				isUsingPipe = GameManager.control.isUsingPipe;
			}

			private static void Postfix(Pipe __instance)
			{
				if (session.playerData.items.pipe)
				{
					GameManager.control.isUsingPipe = isUsingPipe;
					GameManager.control.smokingpipe = true;
					((Component)__instance).gameObject.SetActive(isUsingPipe);
				}
			}
		}

		[HarmonyPatch(typeof(PipeCabin), "CheckLoad")]
		public class PipeCheck2Patch
		{
			private static bool isUsingPipe;

			private static void Prefix()
			{
				isUsingPipe = GameManager.control.isUsingPipe;
			}

			private static void Postfix(PipeCabin __instance)
			{
				if (session.playerData.items.pipe)
				{
					GameManager.control.isUsingPipe = isUsingPipe;
					GameManager.control.smokingpipe = true;
					((Component)__instance).gameObject.SetActive(true);
					__instance.playerPipe.SetActive(isUsingPipe);
				}
			}
		}

		[HarmonyPatch(typeof(EnterPeakScene), "Awake")]
		public class EnterPeakScenePatch
		{
			private static void Postfix(EnterPeakScene __instance)
			{
				string text = ((object)(PeakNames)(ref GameObject.FindGameObjectWithTag("SummitBox").GetComponent<StamperPeakSummit>().peakNames)).ToString();
				Debug.Log((object)("Entering peak: " + text));
			}
		}

		[HarmonyPatch(typeof(OilLamp), "OilLampLightUp")]
		public class OilLampLightUpPatch
		{
			private static void Postfix(OilLamp __instance, ref IEnumerator __result)
			{
				if (!session.playerData.items.lamp)
				{
					__result = Wrapper(__instance);
				}
			}

			private static IEnumerator Wrapper(OilLamp __instance)
			{
				__instance.oilLampLight.intensity = 0f;
				yield return null;
			}
		}

		[HarmonyPatch(typeof(Player), "GetButton", new Type[] { typeof(string) })]
		public class HandPatch
		{
			private static bool Prefix(ref bool __result, string actionName)
			{
				if (actionName == "Arm Right" && !session.playerData.items.rightHand)
				{
					return false;
				}
				if (actionName == "Arm Left" && !session.playerData.items.leftHand)
				{
					return false;
				}
				return true;
			}
		}

		[HarmonyPatch(typeof(StatsAndAchievements), "SetAchievement")]
		[HarmonyPatch(typeof(StatsAndAchievements), "SetStatFloat")]
		[HarmonyPatch(typeof(StatsAndAchievements), "SetStatInt")]
		[HarmonyPatch(typeof(StatsAndAchievements), "ResetStatsAndAchievements")]
		public class SetAchievementPatch
		{
			private static bool Prefix()
			{
				Debug.Log((object)"Game wants to do something with achievements, but I say no");
				return false;
			}
		}

		[HarmonyPatch(typeof(SteamUserStats), "SetAchievement")]
		[HarmonyPatch(typeof(SteamUserStats), "StoreStats")]
		public class SetSteamAchievementPatch
		{
			private static bool Prefix(ref bool __result)
			{
				Debug.Log((object)"Game wants to do something with achievements, but I say no");
				__result = true;
				return false;
			}
		}

		[HarmonyPatch(typeof(RopeAnchor), "Start")]
		public class StartTranspiler
		{
			private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions)
			{
				List<CodeInstruction> codes = new List<CodeInstruction>(instructions);
				for (int i = 0; i < codes.Count; i++)
				{
					if (i != 76 && i != 77 && i != 78)
					{
						yield return codes[i];
					}
				}
			}
		}

		[HarmonyPatch(/*Could not decode attribute arguments.*/)]
		public class DetachThenAttachToNewTranspiler
		{
			private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions)
			{
				List<CodeInstruction> codes = new List<CodeInstruction>(instructions);
				for (int i = 0; i < codes.Count; i++)
				{
					if (i != 120 && i != 121 && i != 122 && i != 123)
					{
						yield return codes[i];
					}
				}
			}
		}

		[HarmonyPatch(/*Could not decode attribute arguments.*/)]
		public class PullOutAnchorTranspiler
		{
			private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions)
			{
				List<CodeInstruction> codes = new List<CodeInstruction>(instructions);
				for (int i = 0; i < codes.Count; i++)
				{
					if (i != 79 && i != 80 && i != 81 && i != 82)
					{
						yield return codes[i];
					}
				}
			}
		}

		[HarmonyPatch(typeof(RopeCollectable), "CheckRope")]
		public class CheckRopeTranspiler
		{
			private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions)
			{
				List<CodeInstruction> codes = new List<CodeInstruction>(instructions);
				for (int i = 0; i < codes.Count; i++)
				{
					if (i != 267 && i != 268 && i != 269 && i != 270)
					{
						yield return codes[i];
					}
				}
			}
		}

		[HarmonyPatch(typeof(BirdSeedCollectable), "CheckBirdSeed")]
		public class CheckBirdSeedTranspler
		{
			private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions)
			{
				List<CodeInstruction> codes = new List<CodeInstruction>(instructions);
				for (int i = 0; i < codes.Count; i++)
				{
					if (i != 83 && i != 84 && i != 85 && i != 86)
					{
						yield return codes[i];
					}
				}
			}
		}

		private bool justConnected = false;

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

		private PlayerData playerData;

		private static POASession session;

		[Editable]
		public string Hostname { get; set; } = "archipelago.gg";


		[Editable]
		public string Port { get; set; } = "123456";


		[Editable]
		public string SlotName { get; set; } = "";


		[Editable]
		public string Password { get; set; } = "";


		[Editable]
		public bool AutoConnect { get; set; } = false;


		[Editable]
		public UnityEvent Connect { get; set; } = new UnityEvent();


		public override void OnEnabled()
		{
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Expected O, but got Unknown
			playerData = new PlayerData();
			session = new POASession(playerData);
			harmony.PatchAll();
			Connect.AddListener(new UnityAction(OnConnect));
			if (AutoConnect)
			{
				OnConnect();
			}
			Debug.Log((object)"Enabled Peaks of Archipelago!");
		}

		public override void OnDisabled()
		{
			harmony.UnpatchSelf();
		}

		public override void Start()
		{
			//IL_0069: 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)
			if (session.currentScene == "TitleScreen" && justConnected)
			{
				justConnected = false;
				Debug.Log((object)"entering cabin from main menu, resetting ropes, coffee, chalk and bird uses to zero");
				GameManager.control.ropesCollected = 0;
				GameManager.control.extraCoffeeUses = 0;
				GameManager.control.extraChalkUses = 0;
				GameManager.control.extraBirdSeedUses = 0;
			}
			POASession pOASession = session;
			Scene activeScene = SceneManager.GetActiveScene();
			pOASession.currentScene = ((Scene)(ref activeScene)).name;
			Debug.Log((object)("Entering Scene" + session.currentScene));
			if (session.currentScene == "Cabin")
			{
				session.fundamentalsBook = GameObject.Find("PEAKJOURNAL");
			}
			Debug.Log((object)$"You have {GameManager.control.extraBirdSeedUses} birdseeds");
		}

		private string GetUri()
		{
			return Hostname + ":" + Port;
		}

		private void OnConnect()
		{
			justConnected = true;
			session.Connect(GetUri(), SlotName, Password);
		}
	}
	public enum Ropes
	{
		WaltersCrag,
		WalkersPillar,
		GreatGaol,
		StHaelga,
		ExtraFirst,
		ExtraSecond,
		ExtraThird,
		ExtraFourth,
		Extra5,
		Extra6,
		Extra7,
		Extra8,
		Extra9,
		Extra10,
		Extra11,
		Extra12
	}
	public enum Artefacts
	{
		Hat1,
		Hat2,
		Helmet,
		Shoe,
		Shovel,
		Sleepingbag,
		Backpack,
		Coffebox_1,
		Coffebox_2,
		Chalkbox_1,
		Chalkbox_2,
		ClimberStatue1,
		ClimberStatue2,
		ClimberStatue3,
		Photograph_1,
		Photograph_2,
		Photograph_3,
		Photograph_4,
		PhotographFrame,
		ClimberStatue0
	}
	public enum BirdSeeds
	{
		ExtraSeed1,
		ExtraSeed2,
		ExtraSeed3,
		ExtraSeed4,
		ExtraSeed5
	}
	public enum Peaks
	{
		GreenhornsTop,
		PaltryPeak,
		OldMill,
		GrayGully,
		Lighthouse,
		OldManOfSjor,
		GiantsShelf,
		EvergreensEnd,
		TheTwins,
		OldGrovesSkelf,
		LandsEnd,
		HangmansLeap,
		OldLangr,
		AldrGrotto,
		ThreeBrothers,
		WaltersCrag,
		GreatCrevice,
		OldHagger,
		UgsomeStorr,
		WutheringCrest,
		PortersBoulders,
		JotunnsThumb,
		OldSkerry,
		HamarrStone,
		GiantsNose,
		WaltersBoulder,
		SunderedSons,
		OldWealdsBoulder,
		LeaningSpire,
		Cromlech,
		WalkersPillar,
		Eldenhorn,
		GreatGaol,
		StHaelga,
		YmirsShadow,
		GreatBulwark,
		SolemnTempest
	}
	public enum Books
	{
		Fundamentals,
		Intermediate,
		Advanced,
		Expert
	}
	public enum Tools
	{
		Pipe,
		RopeLengthUpgrade,
		Barometer,
		ProgressiveCrampons,
		Monocular,
		Phonograph,
		Pocketwatch,
		Chalkbag,
		Rope,
		Coffee,
		Lamp,
		leftHand,
		RightHand
	}
	public enum ExtraItems
	{
		ExtraRope,
		ExtraChalk,
		ExtraCoffee,
		ExtraSeed
	}
	internal struct SimpleItemInfo
	{
		public string playerName;

		public string itemName;

		public long id;
	}
	internal class CheckList<T> where T : struct, Enum
	{
		private readonly Dictionary<T, bool> checks;

		public CheckList(bool value = false)
		{
			checks = new Dictionary<T, bool>();
			foreach (T value2 in Enum.GetValues(typeof(T)))
			{
				checks.Add(value2, value);
			}
		}

		public void SetCheck(T value, bool check)
		{
			checks[value] = check;
		}

		public bool IsChecked(T value)
		{
			return checks[value];
		}

		public T[] GetUncheckedValues()
		{
			List<T> list = new List<T>();
			foreach (T value in Enum.GetValues(typeof(T)))
			{
				if (!checks[value])
				{
					list.Add(value);
				}
			}
			return list.ToArray();
		}

		public T[] GetCheckedValues()
		{
			List<T> list = new List<T>();
			foreach (T value in Enum.GetValues(typeof(T)))
			{
				if (checks[value])
				{
					list.Add(value);
				}
			}
			return list.ToArray();
		}

		public Dictionary<T, bool> GetChecks()
		{
			return checks;
		}
	}
	public static class Utils
	{
		private struct Location
		{
			public string name;

			public string type;

			public int id;

			public int region;
		}

		private struct Item
		{
			public string name;

			public string type;

			public int id;
		}

		private struct Data
		{
			public Location[] locations;

			public Item[] items;
		}

		public const int peakOffset = 1;

		public const int ropeOffset = 1000;

		public const int artefactOffset = 2000;

		public const int bookOffset = 3000;

		public const int birdSeedOffset = 4000;

		public const int toolOffset = 5000;

		public const int extraItemOffset = 6000;

		public static readonly Dictionary<Artefacts, string> artefactToVariableName = new Dictionary<Artefacts, string>
		{
			{
				Artefacts.Hat1,
				"Hat1"
			},
			{
				Artefacts.Hat2,
				"Hat2"
			},
			{
				Artefacts.Helmet,
				"Helmet"
			},
			{
				Artefacts.Shoe,
				"Shoe"
			},
			{
				Artefacts.Shovel,
				"Shovel"
			},
			{
				Artefacts.Sleepingbag,
				"Sleepingbag"
			},
			{
				Artefacts.Backpack,
				"Backpack"
			},
			{
				Artefacts.Coffebox_1,
				"Coffeebox1"
			},
			{
				Artefacts.Coffebox_2,
				"Coffeebox2"
			},
			{
				Artefacts.Chalkbox_1,
				"Chalkbox1"
			},
			{
				Artefacts.Chalkbox_2,
				"Chalkbox2"
			},
			{
				Artefacts.ClimberStatue1,
				"Statue1"
			},
			{
				Artefacts.ClimberStatue2,
				"Statue2"
			},
			{
				Artefacts.ClimberStatue3,
				"Statue3"
			},
			{
				Artefacts.Photograph_1,
				"Photograph1"
			},
			{
				Artefacts.Photograph_2,
				"Photograph2"
			},
			{
				Artefacts.Photograph_3,
				"Photograph3"
			},
			{
				Artefacts.Photograph_4,
				"Photograph4"
			},
			{
				Artefacts.PhotographFrame,
				"PhotographFrame"
			},
			{
				Artefacts.ClimberStatue0,
				"Statue0"
			}
		};

		public static Peaks GetPeakFromCollectable(StamperPeakSummit peakStamper)
		{
			//IL_0002: 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_000a: Expected I4, but got Unknown
			int num = peakStamper.peakNames - 1;
			if (num >= 36)
			{
				num--;
			}
			return (Peaks)num;
		}

		public static Ropes GetRopeFromCollectable(RopeCollectable ropeCollectable)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Expected I4, but got Unknown
			if (!ropeCollectable.isSingleRope)
			{
				return (Ropes)(ropeCollectable.extraRopeNumber + 4);
			}
			if (ropeCollectable.isWaltersCrag)
			{
				return Ropes.WaltersCrag;
			}
			if (ropeCollectable.isWalkersPillar)
			{
				return Ropes.WalkersPillar;
			}
			if (ropeCollectable.isGreatGaol)
			{
				return Ropes.GreatGaol;
			}
			if (ropeCollectable.isStHaelga)
			{
				return Ropes.StHaelga;
			}
			throw new Exception("unknown rope");
		}

		public static Artefacts GetArtefactFromCollectable(ArtefactOnPeak artefactOnPeak)
		{
			//IL_0002: 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_000a: Expected I4, but got Unknown
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Invalid comparison between Unknown and I4
			int num = artefactOnPeak.peakArtefact - 1;
			if ((int)artefactOnPeak.peakArtefact >= 20)
			{
				num -= 3;
			}
			return (Artefacts)num;
		}

		public static int ArtefactToId(Artefacts artefact)
		{
			return (int)(artefact + 2000);
		}

		public static int RopeToId(Ropes rope)
		{
			return (int)(rope + 1000);
		}

		public static int PeakToId(Peaks peak)
		{
			return (int)(peak + 1);
		}

		public static int BookToId(Books book)
		{
			return (int)(book + 3000);
		}

		public static int BirdSeedToId(BirdSeeds birdSeed)
		{
			return (int)(birdSeed + 4000);
		}

		public static int ToolToId(Tools tool)
		{
			return (int)(tool + 5000);
		}

		public static int ExtraItemToId(ExtraItems extraItem)
		{
			return (int)(extraItem + 6000);
		}

		public static Peaks IdtoPeak(long id)
		{
			return (Peaks)(id - 1);
		}

		public static Ropes IdtoRope(long id)
		{
			return (Ropes)(id - 1000);
		}

		public static Artefacts IdtoArtefact(long id)
		{
			return (Artefacts)(id - 2000);
		}

		public static Books IdToBook(long id)
		{
			return (Books)(id - 3000);
		}

		public static BirdSeeds IdToBirdSeed(long id)
		{
			return (BirdSeeds)(id - 4000);
		}

		public static Tools IdToTool(long id)
		{
			return (Tools)(id - 5000);
		}

		public static ExtraItems IdToExtraItem(long id)
		{
			return (ExtraItems)(id - 6000);
		}

		public static string GetNameById(long id)
		{
			if (id < 2000)
			{
				return IdtoRope(id).ToString();
			}
			if (id < 3000)
			{
				return IdtoArtefact(id).ToString();
			}
			if (id < 6000)
			{
				return IdToBook(id).ToString();
			}
			return IdToExtraItem(id).ToString();
		}

		public static string GetDataAsJson()
		{
			Data data = default(Data);
			data.locations = Array.Empty<Location>();
			data.items = Array.Empty<Item>();
			List<Location> list = new List<Location>();
			List<Item> list2 = new List<Item>();
			foreach (Peaks value in Enum.GetValues(typeof(Peaks)))
			{
				int id = PeakToId(value);
				string name = value.ToString();
				string type = "Peak";
				Location location = default(Location);
				location.name = name;
				location.type = type;
				location.id = id;
				location.region = 0;
				Location item = location;
				list.Add(item);
			}
			foreach (Ropes value2 in Enum.GetValues(typeof(Ropes)))
			{
				int id2 = RopeToId(value2);
				string name2 = value2.ToString();
				string type2 = "Rope";
				Location location = default(Location);
				location.name = name2;
				location.type = type2;
				location.id = id2;
				location.region = 0;
				Location item2 = location;
				Item item3 = default(Item);
				item3.name = name2;
				item3.type = type2;
				item3.id = id2;
				Item item4 = item3;
				list.Add(item2);
				list2.Add(item4);
			}
			foreach (Artefacts value3 in Enum.GetValues(typeof(Artefacts)))
			{
				int id3 = ArtefactToId(value3);
				string name3 = value3.ToString();
				string type3 = "Artefact";
				Location location = default(Location);
				location.name = name3;
				location.type = type3;
				location.id = id3;
				location.region = 0;
				Location item5 = location;
				Item item3 = default(Item);
				item3.name = name3;
				item3.type = type3;
				item3.id = id3;
				Item item6 = item3;
				list.Add(item5);
				list2.Add(item6);
			}
			foreach (Books value4 in Enum.GetValues(typeof(Books)))
			{
				int id4 = BookToId(value4);
				string name4 = value4.ToString();
				string type4 = "Book";
				Item item3 = default(Item);
				item3.name = name4;
				item3.type = type4;
				item3.id = id4;
				Item item7 = item3;
				list2.Add(item7);
			}
			foreach (BirdSeeds value5 in Enum.GetValues(typeof(BirdSeeds)))
			{
				int id5 = BirdSeedToId(value5);
				string name5 = value5.ToString();
				string type5 = "Bird Seed";
				Location location = default(Location);
				location.name = name5;
				location.type = type5;
				location.id = id5;
				location.region = 0;
				Location item8 = location;
				Item item3 = default(Item);
				item3.name = name5;
				item3.type = type5;
				item3.id = id5;
				Item item9 = item3;
				list.Add(item8);
				list2.Add(item9);
			}
			foreach (Tools value6 in Enum.GetValues(typeof(Tools)))
			{
				int id6 = ToolToId(value6);
				string name6 = value6.ToString();
				string type6 = "Tool";
				Item item3 = default(Item);
				item3.name = name6;
				item3.type = type6;
				item3.id = id6;
				Item item10 = item3;
				list2.Add(item10);
			}
			foreach (ExtraItems value7 in Enum.GetValues(typeof(ExtraItems)))
			{
				int id7 = ExtraItemToId(value7);
				string name7 = value7.ToString();
				string type7 = "Extra Item";
				Item item3 = default(Item);
				item3.name = name7;
				item3.type = type7;
				item3.id = id7;
				Item item11 = item3;
				list2.Add(item11);
			}
			data.locations = list.ToArray();
			data.items = list2.ToArray();
			return JsonConvert.SerializeObject((object)data);
		}

		public static Type GetTypeById(long id)
		{
			if (id >= 6000)
			{
				return typeof(ExtraItems);
			}
			if (id >= 5000)
			{
				return typeof(Tools);
			}
			if (id >= 4000)
			{
				return typeof(BirdSeeds);
			}
			if (id >= 3000)
			{
				return typeof(Books);
			}
			if (id >= 2000)
			{
				return typeof(Artefacts);
			}
			if (id >= 1000)
			{
				return typeof(Ropes);
			}
			if (id >= 1)
			{
				return typeof(Peaks);
			}
			return null;
		}

		public static BirdSeeds GetSeedFromCollectable(BirdSeedCollectable seedCollectable)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Expected I4, but got Unknown
			return (BirdSeeds)seedCollectable.extraBirdSeedNumber;
		}
	}
	internal class PlayerData
	{
		public class Locations
		{
			public CheckList<Ropes> ropes = new CheckList<Ropes>();

			public CheckList<Artefacts> artefacts = new CheckList<Artefacts>();

			public CheckList<Peaks> peaks = new CheckList<Peaks>();

			public CheckList<BirdSeeds> seeds = new CheckList<BirdSeeds>();
		}

		public class Items
		{
			public CheckList<Ropes> ropes = new CheckList<Ropes>();

			public CheckList<Artefacts> artefacts = new CheckList<Artefacts>();

			public CheckList<Books> books = new CheckList<Books>();

			public CheckList<BirdSeeds> seeds = new CheckList<BirdSeeds>();

			public int extraropeItemCount = 0;

			public int extraChalkItemCount = 0;

			public int extraCoffeeItemCount = 0;

			public int extraSeedItemCount = 0;

			public int progressiveCrampons;

			public bool pipe;

			public bool ropeLengthUpgrade;

			public bool barometer;

			public bool monocular;

			public bool phonograph;

			public bool pocketwatch;

			public bool chalkbag;

			public bool rope;

			public bool coffee;

			public bool lamp;

			public bool rightHand;

			public bool leftHand;
		}

		public Locations locations = new Locations();

		public Items items = new Items();
	}
	internal class POASession
	{
		[Serializable]
		[CompilerGenerated]
		private sealed class <>c
		{
			public static readonly <>c <>9 = new <>c();

			public static ItemReceivedHandler <>9__15_1;

			public static Func<ItemInfo, SimpleItemInfo> <>9__16_1;

			public static Func<ItemInfo, SimpleItemInfo> <>9__16_0;

			internal void <Connect>b__15_1(ReceivedItemsHelper receivedItemsHelper)
			{
				Debug.Log((object)("Received Item: " + receivedItemsHelper.PeekItem().ItemName));
			}

			internal SimpleItemInfo <UpdateReceivedItems>b__16_1(ItemInfo item)
			{
				SimpleItemInfo result = default(SimpleItemInfo);
				result.playerName = item.Player.Name;
				result.id = item.ItemId;
				result.itemName = item.ItemName;
				return result;
			}

			internal SimpleItemInfo <UpdateReceivedItems>b__16_0(ItemInfo item)
			{
				SimpleItemInfo result = default(SimpleItemInfo);
				result.playerName = item.Player.Name;
				result.id = item.ItemId;
				result.itemName = item.ItemName;
				return result;
			}
		}

		private ArchipelagoSession session;

		private DeathLinkService deathLinkService;

		private bool instantRope;

		private bool playerKilled = false;

		private Dictionary<long, ScoutedItemInfo> scoutedItems;

		public readonly PlayerData playerData;

		private int itemcount;

		public List<SimpleItemInfo> uncollectedItems;

		public string currentScene;

		public GameObject fundamentalsBook;

		private LoginSuccessful loginSuccessful;

		private bool firstLogin;

		public bool finished;

		public bool seenFinishedCutScene;

		public POASession(PlayerData playerData)
		{
			this.playerData = playerData;
			itemcount = 0;
			uncollectedItems = new List<SimpleItemInfo>();
			firstLogin = false;
			finished = false;
			seenFinishedCutScene = false;
			base..ctor();
		}

		public async Task<bool> Connect(string uri, string SlotName, string Password)
		{
			loginSuccessful = null;
			uncollectedItems = new List<SimpleItemInfo>();
			deathLinkService = null;
			Debug.Log((object)("Connecting to " + uri));
			session = ArchipelagoSessionFactory.CreateSession(uri, 38281);
			LoginResult result = session.TryConnectAndLogin("Peaks of Yore", SlotName, (ItemsHandlingFlags)7, (Version)null, (string[])null, (string)null, Password, true);
			if (!result.Successful)
			{
				Debug.LogError((object)"unsuccessful connect, aborting");
				Debug.LogError((object)"Something went wrong and you are not connected");
				string[] errors = ((LoginFailure)result).Errors;
				foreach (string error in errors)
				{
					Debug.LogError((object)error);
				}
				return false;
			}
			session.SetClientState((ArchipelagoClientState)5);
			loginSuccessful = (LoginSuccessful)result;
			if (loginSuccessful.SlotData.TryGetValue("deathLink", out var enableDeathLink) && Convert.ToInt32(enableDeathLink) == 1)
			{
				deathLinkService = DeathLinkProvider.CreateDeathLinkService(session);
				deathLinkService.EnableDeathLink();
				Debug.Log((object)"Enabling Death Link");
				deathLinkService.OnDeathLinkReceived += (DeathLinkReceivedHandler)delegate(DeathLink deathLinkObject)
				{
					Debug.Log((object)(deathLinkObject.Source + deathLinkObject.Cause));
					KillPlayer();
				};
			}
			if (loginSuccessful.SlotData.TryGetValue("ropeUnlockMode", out var ropeUnlockMode))
			{
				instantRope = Convert.ToInt32(ropeUnlockMode) == 0;
			}
			await LoadLocationDetails();
			IReceivedItemsHelper items = session.Items;
			object obj = <>c.<>9__15_1;
			if (obj == null)
			{
				ItemReceivedHandler val = delegate(ReceivedItemsHelper receivedItemsHelper)
				{
					Debug.Log((object)("Received Item: " + receivedItemsHelper.PeekItem().ItemName));
				};
				<>c.<>9__15_1 = val;
				obj = (object)val;
			}
			items.ItemReceived += (ItemReceivedHandler)obj;
			firstLogin = true;
			session.DataStorage["ItemCount"].Initialize(JToken.op_Implicit(0));
			Debug.Log((object)("Login result: " + result.Successful));
			return result.Successful;
		}

		public void UpdateReceivedItems()
		{
			if (session == null)
			{
				return;
			}
			if (firstLogin)
			{
				firstLogin = false;
				Debug.Log((object)"Getting previously unlocked items");
				itemcount = DataStorageElement.op_Implicit(session.DataStorage["ItemCount"]);
				Debug.Log((object)$"found {itemcount} already unlocked items");
				List<SimpleItemInfo> list = session.Items.AllItemsReceived.Take(itemcount).Select(delegate(ItemInfo item)
				{
					SimpleItemInfo result2 = default(SimpleItemInfo);
					result2.playerName = item.Player.Name;
					result2.id = item.ItemId;
					result2.itemName = item.ItemName;
					return result2;
				}).ToList();
				foreach (SimpleItemInfo item in list)
				{
					UnlockById(item.id);
				}
			}
			if (session.Items.AllItemsReceived.Count != itemcount)
			{
				List<SimpleItemInfo> list2 = session.Items.AllItemsReceived.Select(delegate(ItemInfo item)
				{
					SimpleItemInfo result = default(SimpleItemInfo);
					result.playerName = item.Player.Name;
					result.id = item.ItemId;
					result.itemName = item.ItemName;
					return result;
				}).ToList();
				uncollectedItems = uncollectedItems.Concat(list2.Skip(itemcount)).ToList();
				Debug.Log((object)$"Received {uncollectedItems.Count} items");
				itemcount = list2.Count;
				session.DataStorage["ItemCount"] = DataStorageElement.op_Implicit(itemcount);
			}
		}

		public async Task LoadLocationDetails()
		{
			ILocationCheckHelper locations = session.Locations;
			ReadOnlyCollection<long> allLocations = session.Locations.AllLocations;
			int num = 0;
			long[] array = new long[allLocations.Count];
			foreach (long item in allLocations)
			{
				array[num] = item;
				num++;
			}
			scoutedItems = await locations.ScoutLocationsAsync((HintCreationPolicy)0, array);
		}

		public void HandleDeath()
		{
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Expected O, but got Unknown
			if (deathLinkService == null)
			{
				return;
			}
			if (playerKilled)
			{
				playerKilled = false;
				return;
			}
			Debug.Log((object)"Sending Deathlink");
			if (session != null)
			{
				deathLinkService.SendDeathLink(new DeathLink(session.Players.GetPlayerAliasAndName(session.ConnectionInfo.Slot), "Fell off."));
			}
		}

		public void CheckWin()
		{
			if (session == null || !loginSuccessful.SlotData.TryGetValue("goal", out var value))
			{
				return;
			}
			string text = value.ToString();
			bool flag = text == "0" || text == "2";
			bool flag2 = text == "1" || text == "2";
			bool flag3 = text == "3";
			ReadOnlyCollection<long> allMissingLocations = session.Locations.AllMissingLocations;
			if (flag3)
			{
				if (allMissingLocations.Count() == 0)
				{
					Debug.Log((object)"Win condition achieved, unlocking items!");
					session.SetClientState((ArchipelagoClientState)30);
					session.SetGoalAchieved();
					finished = true;
				}
				return;
			}
			foreach (long item in allMissingLocations)
			{
				Type typeById = Utils.GetTypeById(item);
				if ((typeById == typeof(Peaks) && flag) || (typeById == typeof(Artefacts) && flag2))
				{
					return;
				}
			}
			Debug.Log((object)"Win condition achieved, unlocking items!");
			session.SetClientState((ArchipelagoClientState)30);
			session.SetGoalAchieved();
			finished = true;
		}

		public void KillPlayer()
		{
			FallingEvent[] array = Object.FindObjectsOfType<FallingEvent>();
			FallingEvent[] array2 = array;
			foreach (FallingEvent obj in array2)
			{
				MethodInfo method = typeof(FallingEvent).GetMethod("FellToDeath", BindingFlags.Instance | BindingFlags.NonPublic);
				if (method == null)
				{
					break;
				}
				Debug.Log((object)"killing player");
				playerKilled = true;
				method.Invoke(obj, null);
			}
		}

		public SimpleItemInfo GetLocationDetails(long loc)
		{
			SimpleItemInfo result;
			if (scoutedItems == null)
			{
				result = default(SimpleItemInfo);
				result.playerName = "NoPlayer";
				result.itemName = "NoItem";
				return result;
			}
			result = default(SimpleItemInfo);
			result.playerName = scoutedItems[loc].Player.Name;
			result.itemName = ((ItemInfo)scoutedItems[loc]).ItemDisplayName;
			return result;
		}

		public Ropes CompleteRopeCheck(Ropes rope)
		{
			playerData.locations.ropes.SetCheck(rope, check: true);
			Debug.Log((object)("Completing rope " + rope));
			if (session == null)
			{
				return (Ropes)(-1);
			}
			session.Locations.CompleteLocationChecks(new long[1] { Utils.RopeToId(rope) });
			return rope;
		}

		public Ropes CompleteRopeCheck(RopeCollectable ropeCollectable)
		{
			Ropes ropeFromCollectable = Utils.GetRopeFromCollectable(ropeCollectable);
			CompleteRopeCheck(ropeFromCollectable);
			return ropeFromCollectable;
		}

		public Artefacts CompleteArtefactCheck(ArtefactOnPeak artefactOnPeak)
		{
			Artefacts artefactFromCollectable = Utils.GetArtefactFromCollectable(artefactOnPeak);
			Debug.Log((object)("Completing artefact " + artefactFromCollectable));
			playerData.locations.artefacts.SetCheck(artefactFromCollectable, check: true);
			if (session == null)
			{
				return (Artefacts)(-1);
			}
			session.Locations.CompleteLocationChecks(new long[1] { Utils.ArtefactToId(artefactFromCollectable) });
			return artefactFromCollectable;
		}

		public BirdSeeds CompleteSeedCheck(BirdSeedCollectable seedCollectable)
		{
			BirdSeeds seedFromCollectable = Utils.GetSeedFromCollectable(seedCollectable);
			Debug.Log((object)("Completing seed " + seedFromCollectable));
			playerData.locations.seeds.SetCheck(seedFromCollectable, check: true);
			if (session == null)
			{
				return (BirdSeeds)(-1);
			}
			session.Locations.CompleteLocationChecks(new long[1] { Utils.BirdSeedToId(seedFromCollectable) });
			return seedFromCollectable;
		}

		public Peaks CompletePeakCheck(StamperPeakSummit peakStamper)
		{
			if (session == null)
			{
				return (Peaks)(-1);
			}
			Peaks peakFromCollectable = Utils.GetPeakFromCollectable(peakStamper);
			session.Locations.CompleteLocationChecks(new long[1] { Utils.PeakToId(peakFromCollectable) });
			playerData.locations.peaks.SetCheck(peakFromCollectable, check: true);
			Debug.Log((object)("Completing peak " + peakFromCollectable));
			return peakFromCollectable;
		}

		internal string UnlockById(long id)
		{
			if (id < 2000)
			{
				Ropes rope = Utils.IdtoRope(id);
				UnlockRope(rope);
				return rope.ToString();
			}
			if (id < 3000)
			{
				Artefacts artefact = Utils.IdtoArtefact(id);
				UnlockArtefact(artefact);
				return artefact.ToString();
			}
			if (id < 4000)
			{
				Books book = Utils.IdToBook(id);
				UnlockBook(book);
				return book.ToString();
			}
			if (id < 5000)
			{
				BirdSeeds birdSeed = Utils.IdToBirdSeed(id);
				UnlockBirdSeed(birdSeed);
			}
			if (id < 6000)
			{
				Tools tool = Utils.IdToTool(id);
				UnlockTool(tool);
			}
			ExtraItems extraItem = Utils.IdToExtraItem(id);
			UnlockExtraItem(extraItem);
			return extraItem.ToString();
		}

		private void UnlockRope(Ropes rope)
		{
			if (instantRope)
			{
				GameManager.control.rope = true;
				playerData.items.rope = true;
			}
			playerData.items.ropes.SetCheck(rope, check: true);
			if (rope < Ropes.ExtraFirst)
			{
				GameManager control = GameManager.control;
				control.ropesCollected++;
			}
			else
			{
				GameManager control2 = GameManager.control;
				control2.ropesCollected += 2;
			}
			GameManager.control.Save();
		}

		private void UnlockArtefact(Artefacts artefact)
		{
			playerData.items.artefacts.SetCheck(artefact, check: true);
			switch (artefact)
			{
			case Artefacts.Coffebox_1:
			case Artefacts.Coffebox_2:
			{
				GameManager control2 = GameManager.control;
				control2.extraCoffeeUses += 2;
				break;
			}
			case Artefacts.Chalkbox_1:
			case Artefacts.Chalkbox_2:
			{
				GameManager control = GameManager.control;
				control.extraChalkUses += 2;
				break;
			}
			}
		}

		private void UnlockBook(Books book)
		{
			playerData.items.books.SetCheck(book, check: true);
			NPCEvents val = Object.FindObjectOfType<NPCEvents>();
			switch (book)
			{
			case Books.Fundamentals:
				SetFundamentalsBookActive(enabled: true);
				break;
			case Books.Intermediate:
				GameManager.control.category_2_unlocked = true;
				val.cabin_Category2.SetActive(true);
				break;
			case Books.Advanced:
				GameManager.control.category_3_unlocked = true;
				val.cabin_Category3.SetActive(true);
				break;
			case Books.Expert:
				GameManager.control.category_4_unlocked = true;
				val.cabinIceaxes.SetActive(true);
				GameManager.control.iceAxes = true;
				((MonoBehaviour)val.category4Ticket).StartCoroutine("GlowTicket");
				break;
			}
			GameManager.control.Save();
		}

		public void SetFundamentalsBookActive(bool enabled)
		{
			fundamentalsBook.SetActive(enabled);
		}

		private void UnlockBirdSeed(BirdSeeds birdSeed)
		{
			GameManager control = GameManager.control;
			control.extraBirdSeedUses++;
			playerData.items.seeds.SetCheck(birdSeed, check: true);
		}

		private void UnlockTool(Tools tool)
		{
			switch (tool)
			{
			case Tools.Pipe:
				GameManager.control.smokingpipe = true;
				playerData.items.pipe = true;
				break;
			case Tools.RopeLengthUpgrade:
				GameManager.control.ropesUpgrade = true;
				playerData.items.ropeLengthUpgrade = true;
				break;
			case Tools.Barometer:
				GameManager.control.barometer = true;
				GameManager.control.artefactMap = true;
				playerData.items.barometer = true;
				break;
			case Tools.ProgressiveCrampons:
				if (playerData.items.progressiveCrampons == 0)
				{
					playerData.items.progressiveCrampons++;
					GameManager.control.crampons = true;
				}
				else
				{
					playerData.items.progressiveCrampons++;
					GameManager.control.cramponsUpgrade = true;
				}
				break;
			case Tools.Monocular:
				GameManager.control.monocular = true;
				playerData.items.monocular = true;
				break;
			case Tools.Phonograph:
				GameManager.control.phonograph = true;
				playerData.items.phonograph = true;
				break;
			case Tools.Pocketwatch:
				GameManager.control.pocketwatch = true;
				playerData.items.pocketwatch = true;
				break;
			case Tools.Chalkbag:
				GameManager.control.chalkBag = true;
				playerData.items.chalkbag = true;
				break;
			case Tools.Rope:
				GameManager.control.rope = true;
				playerData.items.rope = true;
				break;
			case Tools.Coffee:
				GameManager.control.coffee = true;
				playerData.items.coffee = true;
				break;
			case Tools.Lamp:
				playerData.items.lamp = true;
				break;
			case Tools.RightHand:
				playerData.items.rightHand = true;
				break;
			case Tools.leftHand:
				playerData.items.leftHand = true;
				break;
			}
			GameManager.control.Save();
		}

		private void UnlockExtraItem(ExtraItems extraItem)
		{
			switch (extraItem)
			{
			case ExtraItems.ExtraRope:
			{
				if (instantRope)
				{
					GameManager.control.rope = true;
					playerData.items.rope = true;
				}
				playerData.items.extraropeItemCount++;
				GameManager control4 = GameManager.control;
				control4.ropesCollected++;
				break;
			}
			case ExtraItems.ExtraCoffee:
			{
				playerData.items.extraCoffeeItemCount++;
				GameManager control3 = GameManager.control;
				control3.extraCoffeeUses++;
				break;
			}
			case ExtraItems.ExtraChalk:
			{
				playerData.items.extraChalkItemCount++;
				GameManager control2 = GameManager.control;
				control2.extraChalkUses++;
				break;
			}
			case ExtraItems.ExtraSeed:
			{
				playerData.items.extraSeedItemCount++;
				GameManager control = GameManager.control;
				control.extraBirdSeedUses++;
				break;
			}
			}
			GameManager.control.Save();
		}
	}
	internal static class UnityUtils
	{
		public static void SetRopeText(string message)
		{
			GameObject obj = GameObject.Find("RopeCollectedTxt");
			Text val = ((obj != null) ? obj.GetComponentInChildren<Text>() : null);
			GameObject obj2 = GameObject.Find("NPCRopeCollectedTxt");
			Text val2 = ((obj2 != null) ? obj2.GetComponentInChildren<Text>() : null);
			if ((Object)(object)val != (Object)null)
			{
				val.text = message;
			}
			else
			{
				Debug.LogWarning((object)"didnt find RopeCollectedText");
			}
			if ((Object)(object)val2 != (Object)null)
			{
				val2.text = message;
			}
			else
			{
				Debug.LogWarning((object)"didnt find NPCRopeCollectedText");
			}
		}

		internal static void SetArtefactText(string message)
		{
			GameObject obj = GameObject.Find("ArtefactCollected");
			Text val = ((obj != null) ? obj.GetComponentInChildren<Text>() : null);
			if ((Object)(object)val != (Object)null)
			{
				val.text = message;
			}
			else
			{
				Debug.LogWarning((object)"didnt find artefactcollectedtext");
			}
		}

		public static void SetSeedText(string message)
		{
			GameObject obj = GameObject.Find("BirdSeedCollectedTxt");
			Text val = ((obj != null) ? obj.GetComponentInChildren<Text>() : null);
			if ((Object)(object)val != (Object)null)
			{
				val.text = message;
			}
			else
			{
				Debug.LogWarning((object)"didnt find BirdSeedCollectedTxt");
			}
		}

		public static void UndoRopeProgress(RopeCollectable ropeCollectable)
		{
			RopeAnchor component = GameObject.FindGameObjectWithTag("Player").GetComponent<RopeAnchor>();
			if (ropeCollectable.isSingleRope)
			{
				GameManager control = GameManager.control;
				control.ropesCollected--;
				component.anchorsInBackpack--;
				component.UpdateRopesCollected();
			}
			else
			{
				GameManager control2 = GameManager.control;
				control2.ropesCollected -= 2;
				component.anchorsInBackpack -= 2;
				component.UpdateRopesCollected();
			}
		}

		public static void SetGameManagerArtefactCollected(Artefacts artefact, bool value)
		{
			string text = "hasArtefact_" + Utils.artefactToVariableName[artefact];
			FieldInfo field = typeof(GameManager).GetField(text, BindingFlags.Instance | BindingFlags.Public);
			if (field != null && field.FieldType == typeof(bool))
			{
				field.SetValue(GameManager.control, value);
				return;
			}
			throw new Exception("No boolean field " + text + "found in GameManager");
		}

		public static void SetGameManagerArtefactDirty(Artefacts artefact, bool value)
		{
			string text = "artefact_" + Utils.artefactToVariableName[artefact] + "_IsDirty";
			FieldInfo field = typeof(GameManager).GetField(text, BindingFlags.Instance | BindingFlags.Public);
			if (field != null && field.FieldType == typeof(bool))
			{
				field.SetValue(GameManager.control, value);
				return;
			}
			throw new Exception("No boolean field " + text + "found in GameManager");
		}

		public static bool GetGameManagerArtefactCollected(Artefacts artefact)
		{
			string text = "hasArtefact_" + Utils.artefactToVariableName[artefact];
			FieldInfo field = typeof(GameManager).GetField(text, BindingFlags.Instance | BindingFlags.Public);
			if (field != null && field.FieldType == typeof(bool))
			{
				return (bool)field.GetValue(GameManager.control);
			}
			throw new Exception("No boolean field " + text + "found in GameManager");
		}

		public static void PrintObjectData(GameObject gameObject)
		{
			//IL_004d: 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_011d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0124: Expected O, but got Unknown
			Debug.Log((object)"---------");
			Debug.Log((object)("name: " + ((Object)gameObject).name));
			Debug.Log((object)("parent: " + ((Object)gameObject.transform.parent).name));
			Debug.Log((object)$"pos: {gameObject.transform.position}");
			Debug.Log((object)$"rot: {gameObject.transform.rotation}");
			Component[] components = gameObject.GetComponents<Component>();
			foreach (Component val in components)
			{
				Type type = ((object)val).GetType();
				Debug.Log((object)("---" + type.Name + "---"));
				FieldInfo[] fields = type.GetFields(BindingFlags.Instance | BindingFlags.Public);
				foreach (FieldInfo fieldInfo in fields)
				{
					Debug.Log((object)$"{fieldInfo.Name}: {fieldInfo.GetValue(val)}");
				}
			}
			foreach (Transform item in gameObject.transform)
			{
				Transform val2 = item;
				PrintObjectData(((Component)val2).gameObject);
			}
		}
	}
	public static class MyPluginInfo
	{
		public const string PLUGIN_GUID = "PeaksOfArchipelago";

		public const string PLUGIN_NAME = "Peaks Of Archipelago";

		public const string PLUGIN_VERSION = "1.3.0";
	}
}