using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Resources;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text.RegularExpressions;
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.MessageLog.Messages;
using Archipelago.MultiClient.Net.MessageLog.Parts;
using Archipelago.MultiClient.Net.Models;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Newtonsoft.Json.Linq;
using PeaksOfArchipelago.Assets;
using PeaksOfArchipelago.CabinHandlers;
using PeaksOfArchipelago.Extensions;
using PeaksOfArchipelago.GameData;
using PeaksOfArchipelago.MonoBehaviours;
using PeaksOfArchipelago.Session;
using PeaksOfArchipelago.Traps;
using PeaksOfArchipelago.UI;
using Rewired;
using UnityEngine;
using UnityEngine.Events;
using UnityEngine.SceneManagement;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.0", FrameworkDisplayName = ".NET Standard 2.0")]
[assembly: AssemblyCompany("com.c0der23.PeaksOfArchipelago")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("2.2.1+6832846bbcf8eb30c38874dcc366f00060ffbc81")]
[assembly: AssemblyProduct("Peaks Of Archipelago")]
[assembly: AssemblyTitle("com.c0der23.PeaksOfArchipelago")]
[assembly: NeutralResourcesLanguage("en-US")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.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_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)
			SessionVariable = sessionVariable;
			Scope = scope;
			Key = key;
		}

		public DataStoragePropertyAttribute(string sessionVariable, string key)
			: this(sessionVariable, (Scope)0, key)
		{
		}
	}
}
namespace PeaksOfArchipelago
{
	[BepInPlugin("com.c0der23.PeaksOfArchipelago", "Peaks Of Archipelago", "2.2.1")]
	public class PeaksOfArchipelago : BaseUnityPlugin
	{
		public enum PlayerState
		{
			InMainMenu,
			InCabin,
			InPeak
		}

		internal static ManualLogSource Logger;

		public static UIManager ui;

		private Harmony harmony;

		private Connection connection;

		public ConfigEntry<string> Username;

		public ConfigEntry<string> ServerIP;

		public ConfigEntry<string> Password;

		public bool hasDLCInstalled;

		public ConfigEntry<bool> hasSeenProgressScreenTutorial;

		public static PeaksOfArchipelago Instance { get; private set; }

		public static PlayerState playerState { get; private set; }

		public event EventHandler<Cabins> OnEnterCabin;

		public event EventHandler OnExitCabin;

		public void Awake()
		{
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Expected O, but got Unknown
			Username = ((BaseUnityPlugin)this).Config.Bind<string>("Session", "Username", "", "The last username used to connect to an Archipelago session.");
			ServerIP = ((BaseUnityPlugin)this).Config.Bind<string>("Session", "ServerIP", "", "The last server IP used to connect to an Archipelago session.");
			Password = ((BaseUnityPlugin)this).Config.Bind<string>("Session", "Password", "", "The last password used to connect to an Archipelago session.");
			hasSeenProgressScreenTutorial = ((BaseUnityPlugin)this).Config.Bind<bool>("HasSeenProgressScreenTutorial", "Misc", false, "Whether the player has seen the progress screen tutorial or not.");
			Instance = this;
			Logger = ((BaseUnityPlugin)this).Logger;
			PeaksOfAssets.LoadAssets();
			harmony = new Harmony("com.c0der23.PeaksOfArchipelago_Patcher");
			try
			{
				Logger.LogInfo((object)"Patching...");
				harmony.PatchAll();
				Logger.LogInfo((object)"Patch complete!");
			}
			catch (Exception arg)
			{
				Logger.LogError((object)$"Error during patching: {arg}");
			}
			ui = new UIManager();
			SceneManager.sceneLoaded += OnSceneLoad;
			Logger.LogMessage((object)"Plugin com.c0der23.PeaksOfArchipelago is loaded!");
		}

		public void OnSceneLoad(Scene scene, LoadSceneMode loadSceneMode)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Invalid comparison between Unknown and I4
			if ((int)loadSceneMode == 1)
			{
				Logger.LogInfo((object)"Scene loaded in additive mode, might want to disable this");
			}
			if (connection == null && ((Scene)(ref scene)).buildIndex == 0)
			{
				UIManager.CreateLoginUI(AttemptLogin);
			}
			Logger.LogInfo((object)$"Loaded scene index: {((Scene)(ref scene)).buildIndex}, named: {((Scene)(ref scene)).name}");
			if (connection == null && ((Scene)(ref scene)).buildIndex != 0)
			{
				throw new Exception("How tf did you enter the game without connecting??");
			}
			ui.OnSceneLoaded(connection);
			switch (((Scene)(ref scene)).buildIndex)
			{
			case 0:
				playerState = PlayerState.InMainMenu;
				this.OnExitCabin?.Invoke(this, EventArgs.Empty);
				break;
			case 1:
				playerState = PlayerState.InCabin;
				this.OnEnterCabin?.Invoke(this, Cabins.Cabin);
				break;
			case 37:
				playerState = PlayerState.InCabin;
				this.OnEnterCabin?.Invoke(this, Cabins.CabinExpert);
				break;
			case 67:
				playerState = PlayerState.InCabin;
				this.OnEnterCabin?.Invoke(this, Cabins.CabinAlps);
				break;
			default:
				playerState = PlayerState.InPeak;
				this.OnExitCabin?.Invoke(this, EventArgs.Empty);
				break;
			}
		}

		internal void OnConnectionSuccesful(SessionSettings settings)
		{
			CheckGameVersion val = Object.FindObjectOfType<CheckGameVersion>();
			if ((Object)(object)val == (Object)null)
			{
				Logger.LogError((object)"Couldn't find version checker object in scene!");
			}
			else if (val.CheckGOGDLCInstall() || val.CheckDLCInstall())
			{
				hasDLCInstalled = true;
				Logger.LogInfo((object)"DLC detected!");
			}
			ui.SetDLCWarning(!hasDLCInstalled && settings.enableDLC);
		}

		public void SaveUserCredentials(string username, string uri, string password)
		{
			Username.Value = username;
			ServerIP.Value = uri;
			Password.Value = password;
			((BaseUnityPlugin)this).Config.Save();
		}

		private async Task<bool> AttemptLogin(string username, string ip, string password)
		{
			Logger.LogInfo((object)"creating session");
			connection = new Connection();
			Logger.LogInfo((object)"Session Created");
			return await connection.ConnectAndLogin(username, ip, password);
		}
	}
	public static class MyPluginInfo
	{
		public const string PLUGIN_GUID = "com.c0der23.PeaksOfArchipelago";

		public const string PLUGIN_NAME = "Peaks Of Archipelago";

		public const string PLUGIN_VERSION = "2.2.1";
	}
}
namespace PeaksOfArchipelago.UI
{
	internal class LoginUI
	{
		private InputField usernameField;

		private InputField ipField;

		private InputField passwordField;

		private Text statusText;

		private Button connectButton;

		private GameObject panel;

		private Func<string, string, string, Task<bool>> attemptLogin;

		private bool isConnecting;

		public void CreateLoginUI(Func<string, string, string, Task<bool>> attemptLogin)
		{
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Expected O, but got Unknown
			GameObject val = GameObject.Find("InGameMenuObj_DisableMe");
			if (!((Object)(object)val == (Object)null))
			{
				this.attemptLogin = attemptLogin;
				panel = Object.Instantiate<GameObject>(PeaksOfAssets.LoginScreen, val.transform);
				Transform child = panel.transform.GetChild(0);
				usernameField = ((Component)child.GetChild(0)).GetComponent<InputField>();
				ipField = ((Component)child.GetChild(1)).GetComponent<InputField>();
				passwordField = ((Component)child.GetChild(2)).GetComponent<InputField>();
				statusText = ((Component)child.GetChild(3).GetChild(0)).GetComponent<Text>();
				connectButton = ((Component)child.GetChild(4)).GetComponent<Button>();
				((UnityEvent)connectButton.onClick).AddListener((UnityAction)delegate
				{
					OnConnectClickedAsync();
				});
				usernameField.text = PeaksOfArchipelago.Instance.Username.Value;
				ipField.text = PeaksOfArchipelago.Instance.ServerIP.Value;
				passwordField.text = PeaksOfArchipelago.Instance.Password.Value;
			}
		}

		private async Task OnConnectClickedAsync()
		{
			if (!isConnecting)
			{
				statusText.text = "Connecting...";
				isConnecting = true;
				PeaksOfArchipelago.Logger.LogInfo((object)"Button buttonning");
				PeaksOfArchipelago.Logger.LogInfo((object)attemptLogin.ToString());
				if (await attemptLogin(usernameField.text, ipField.text, passwordField.text))
				{
					Object.Destroy((Object)(object)panel.gameObject);
				}
				else
				{
					statusText.text = "<color=red>Error, please check the console and try again</color>";
				}
				isConnecting = false;
			}
		}
	}
	public class UIManager
	{
		private static Font _gameFont;

		private Canvas canvas;

		private GameObject scriptholder;

		private ManualLogSource logger;

		private ChatBox chat;

		private GameObject notificationSystemObject;

		private Notificator notificationSystem;

		private ProgressDisplay progressDisplay;

		private GameObject noDLCAlert;

		private bool showDLCAlert;

		public GameObject trapDisplay;

		public UIManager()
		{
			logger = PeaksOfArchipelago.Logger;
		}

		private void MakeUI()
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Expected O, but got Unknown
			canvas = GetBestCanvas();
			scriptholder = new GameObject("UIManager_ScriptHolder");
			chat = scriptholder.AddComponent<ChatBox>();
			chat.Initialize(canvas);
			notificationSystemObject = Object.Instantiate<GameObject>(PeaksOfAssets.Notificator, ((Component)canvas).transform);
			notificationSystem = notificationSystemObject.AddComponent<Notificator>();
			notificationSystem.notificationPrefab = PeaksOfAssets.Notification;
			noDLCAlert = Object.Instantiate<GameObject>(PeaksOfAssets.DLCWarning, ((Component)canvas).transform);
			noDLCAlert.SetActive(showDLCAlert);
			trapDisplay = Object.Instantiate<GameObject>(PeaksOfAssets.TrapDisplay, ((Component)canvas).transform);
		}

		private Canvas GetBestCanvas()
		{
			Canvas[] array = Object.FindObjectsOfType<Canvas>();
			Canvas val = null;
			Canvas val2 = null;
			bool flag = false;
			Canvas[] array2 = array;
			foreach (Canvas val3 in array2)
			{
				if (((Behaviour)val3).isActiveAndEnabled)
				{
					val2 = val3;
					ManualLogSource obj = logger;
					string name = ((Object)val3).name;
					Transform parent = ((Component)val3).transform.parent;
					obj.LogInfo((object)("Canvas found: " + name + "\nParents: " + ((parent != null) ? ((Object)parent).name : null)));
					if (((Object)val3).name.ToLower() == "canvas")
					{
						val = val3;
					}
					if (((Object)(object)((Component)val3).transform.parent == (Object)null || ((Object)((Component)val3).transform.parent).name.ToLower() == "sceneobjects") && ((Object)val3).name.ToLower() == "canvas")
					{
						flag = true;
						break;
					}
				}
			}
			if (!flag)
			{
				logger.LogInfo((object)"Didn't find rootcanvas, using some other canvas");
				val2 = val;
			}
			if ((Object)(object)val2 == (Object)null)
			{
				logger.LogError((object)"No Canvases Found");
				throw new Exception("Error: could not find any Canvas");
			}
			return val2;
		}

		public void SendChatMessage(string message)
		{
			if (!((Object)(object)chat == (Object)null))
			{
				chat.AddChatMessage(message);
			}
		}

		public void SendNotification(string message, float duration = 2f)
		{
			if (!((Object)(object)notificationSystem == (Object)null))
			{
				notificationSystem.CreateNotification(message, duration);
			}
		}

		public void OnSceneLoaded()
		{
			MakeUI();
		}

		internal void OnSceneLoaded(Connection connection)
		{
			MakeUI();
			scriptholder.AddComponent<TrapHandler>();
			if (connection != null)
			{
				progressDisplay = scriptholder.AddComponent<ProgressDisplay>();
				progressDisplay.Initialize(canvas, connection);
			}
		}

		public void OnSceneUnloaded()
		{
		}

		public static Font GetFont()
		{
			if ((Object)(object)_gameFont == (Object)null)
			{
				Text val = null;
				GameObject val2 = GameObject.Find("BeginMain");
				if (!Object.op_Implicit((Object)(object)val2))
				{
					GameObject val3 = GameObject.Find("Text");
					if ((Object)(object)val3 != (Object)null)
					{
						val = val3.GetComponent<Text>();
					}
					return null;
				}
				val = val2.GetComponentInChildren<Text>();
				_gameFont = val.font;
			}
			return _gameFont;
		}

		public static void CreateLoginUI(Func<string, string, string, Task<bool>> attemptLogin)
		{
			new LoginUI().CreateLoginUI(attemptLogin);
		}

		public void SetDLCWarning(bool show)
		{
			showDLCAlert = show;
			noDLCAlert.SetActive(showDLCAlert);
		}
	}
}
namespace PeaksOfArchipelago.Traps
{
	internal class InstantTrap : Trap
	{
		private readonly Action _action;

		private readonly Func<bool> _condition;

		public InstantTrap(string message, Action action, Func<bool> condition = null)
		{
			Message = message;
			_action = action;
			_condition = condition;
		}

		public override bool IsAvailable()
		{
			if (_condition != null)
			{
				return _condition();
			}
			return true;
		}

		public override void Execute(TrapHandler handler)
		{
			_action?.Invoke();
		}
	}
	internal class TimedTrap : Trap
	{
		private readonly Action _onStart;

		private readonly Action _onEnd;

		private readonly float _duration;

		private Func<bool> _condition;

		public bool IsRunning { get; private set; }

		public TimedTrap(string name, string message, Action onStart, Action onEnd, float duration, Func<bool> condition = null)
		{
			Name = name;
			Message = message;
			_onStart = onStart;
			_duration = duration;
			_condition = condition;
			_onEnd = onEnd;
		}

		public void SetCondition(Func<bool> condition)
		{
			_condition = condition;
		}

		public override bool IsAvailable()
		{
			if (!IsRunning)
			{
				if (_condition != null)
				{
					return _condition();
				}
				return true;
			}
			return false;
		}

		public override void Execute(TrapHandler handler)
		{
			IsRunning = true;
			_onStart?.Invoke();
			handler.StartTimer(Name, _duration, delegate
			{
				_onEnd?.Invoke();
				IsRunning = false;
			});
		}
	}
	internal abstract class Trap
	{
		public string Name = "";

		public string Message;

		public virtual bool IsAvailable()
		{
			return true;
		}

		public abstract void Execute(TrapHandler handler);
	}
}
namespace PeaksOfArchipelago.Session
{
	internal enum SlotType
	{
		None,
		Normal,
		YFYD
	}
	internal class Connection
	{
		[Serializable]
		[CompilerGenerated]
		private sealed class <>c
		{
			public static readonly <>c <>9 = new <>c();

			public static MessageReceivedHandler <>9__18_3;

			public static Func<ItemInfo, bool> <>9__24_0;

			public static Func<ItemInfo, bool> <>9__24_1;

			internal void <ConnectAndLogin>b__18_3(LogMessage logMessage)
			{
				//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_0028: Unknown result type (might be due to invalid IL or missing references)
				//IL_002d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0038: Unknown result type (might be due to invalid IL or missing references)
				//IL_003d: 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)
				string text = "";
				MessagePart[] parts = logMessage.Parts;
				Color val2 = default(Color);
				foreach (MessagePart val in parts)
				{
					Color color = val.Color;
					float num = (int)((Color)(ref color)).R;
					color = val.Color;
					float num2 = (int)((Color)(ref color)).G;
					color = val.Color;
					((Color)(ref val2))..ctor(num, num2, (float)(int)((Color)(ref color)).B);
					text = text + "<color=#" + ColorUtility.ToHtmlStringRGB(val2) + ">" + val.Text + "</color>";
				}
				PeaksOfArchipelago.ui.SendChatMessage(text);
			}

			internal bool <LoadData>b__24_0(ItemInfo item)
			{
				return item.ItemName != "Trap";
			}

			internal bool <LoadData>b__24_1(ItemInfo item)
			{
				return item.ItemName != "Trap";
			}
		}

		private CabinHandler cabinHandler;

		private ArchipelagoSession session;

		private readonly ManualLogSource logger;

		private Dictionary<string, object> slotOptions;

		public ISlotData slotData;

		private List<ItemInfo> uncollectedItems;

		private List<ItemInfo> instantCollectItems;

		internal SessionSettings settings;

		private DeathLinkService deathLinkService;

		private bool playerKilled;

		private bool hasWon;

		private Dictionary<long, ScoutedItemInfo> scoutedItems;

		private int itemCount;

		public static Connection Instance { get; private set; }

		public Connection()
		{
			logger = PeaksOfArchipelago.Logger;
			PeaksOfArchipelago.Instance.OnEnterCabin += OnEnterCabin;
			PeaksOfArchipelago.Instance.OnExitCabin += OnExitCabin;
			Instance = this;
		}

		public async Task<bool> ConnectAndLogin(string username, string uri, string password)
		{
			session = ArchipelagoSessionFactory.CreateSession(uri, 38281);
			session.Socket.ErrorReceived += (ErrorReceivedHandler)delegate(Exception e, string message)
			{
				logger.LogInfo((object)"Socket error");
				logger.LogError((object)("message: " + message));
				logger.LogError((object)e);
			};
			logger.LogInfo((object)$"connecting to {session.Socket.Uri}");
			Task connectTask = session.ConnectAsync();
			if (await Task.WhenAny(new Task[2]
			{
				connectTask,
				Task.Delay(4000)
			}) != connectTask)
			{
				logger.LogError((object)"Connection timed out");
				logger.LogInfo((object)"Pushing to chat");
				PeaksOfArchipelago.ui.SendChatMessage("<color=red>Connection timed out.</color>");
				return false;
			}
			logger.LogInfo((object)$"Connected to {session.Socket.Uri}");
			logger.LogInfo((object)("Logging in as " + username));
			LoginResult val = await session.LoginAsync("Peaks of Yore", username, (ItemsHandlingFlags)7, (Version)null, (string[])null, (string)null, password, true);
			if (!val.Successful)
			{
				logger.LogInfo((object)"Couldn't log in");
				string[] errors = ((LoginFailure)val).Errors;
				foreach (string text in errors)
				{
					logger.LogError((object)text);
				}
				ConnectionRefusedError[] errorCodes = ((LoginFailure)val).ErrorCodes;
				foreach (ConnectionRefusedError val2 in errorCodes)
				{
					logger.LogError((object)val2);
				}
				return false;
			}
			PeaksOfArchipelago.Instance.SaveUserCredentials(username, uri, password);
			logger.LogInfo((object)("Logged in as " + username));
			session.SetClientState((ArchipelagoClientState)5);
			slotOptions = ((LoginSuccessful)val).SlotData;
			session.DataStorage["ItemCount"].Initialize(JToken.op_Implicit(0));
			session.DataStorage["SaveSlot"].Initialize(JToken.op_Implicit(-1));
			session.DataStorage["SlotType"].Initialize(JToken.op_Implicit(0));
			LoadData();
			if (settings.deathLinkEnabled)
			{
				deathLinkService = DeathLinkProvider.CreateDeathLinkService(session);
				deathLinkService.EnableDeathLink();
				deathLinkService.OnDeathLinkReceived += (DeathLinkReceivedHandler)delegate(DeathLink deathLinkObject)
				{
					logger.LogInfo((object)(deathLinkObject.Source + deathLinkObject.Cause));
					KillPlayer();
				};
			}
			session.Items.ItemReceived += (ItemReceivedHandler)delegate(ReceivedItemsHelper h)
			{
				OnItemReceived(h.AllItemsReceived.Last());
			};
			IMessageLogHelper messageLog = session.MessageLog;
			object obj = <>c.<>9__18_3;
			if (obj == null)
			{
				MessageReceivedHandler val3 = delegate(LogMessage logMessage)
				{
					//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_0028: Unknown result type (might be due to invalid IL or missing references)
					//IL_002d: Unknown result type (might be due to invalid IL or missing references)
					//IL_0038: Unknown result type (might be due to invalid IL or missing references)
					//IL_003d: 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)
					string text2 = "";
					MessagePart[] parts = logMessage.Parts;
					Color val5 = default(Color);
					foreach (MessagePart val4 in parts)
					{
						Color color = val4.Color;
						float num = (int)((Color)(ref color)).R;
						color = val4.Color;
						float num2 = (int)((Color)(ref color)).G;
						color = val4.Color;
						((Color)(ref val5))..ctor(num, num2, (float)(int)((Color)(ref color)).B);
						text2 = text2 + "<color=#" + ColorUtility.ToHtmlStringRGB(val5) + ">" + val4.Text + "</color>";
					}
					PeaksOfArchipelago.ui.SendChatMessage(text2);
				};
				<>c.<>9__18_3 = val3;
				obj = (object)val3;
			}
			messageLog.OnMessageReceived += (MessageReceivedHandler)obj;
			ScoutLocations();
			PeaksOfArchipelago.Instance.OnConnectionSuccesful(settings);
			return true;
		}

		public bool CheckCompletion()
		{
			IReadOnlyCollection<long> allMissingLocations = session.Locations.AllMissingLocations;
			bool flag = settings.goal == SessionSettings.Goal.ALL_PEAKS || settings.goal == SessionSettings.Goal.ALL_ARTEFACTS_AND_PEAKS;
			bool flag2 = settings.goal == SessionSettings.Goal.ALL_ARTEFACTS || settings.goal == SessionSettings.Goal.ALL_ARTEFACTS_AND_PEAKS;
			bool flag3 = settings.goal == SessionSettings.Goal.ALL_TIME_ATTACK;
			if (settings.goal == SessionSettings.Goal.ALL)
			{
				if (allMissingLocations.Count == 0)
				{
					return true;
				}
				return false;
			}
			if (settings.goal == SessionSettings.Goal.PEAK)
			{
				return !allMissingLocations.Contains(LocationIDs.GetPeakLocationID(settings.targetPeak));
			}
			foreach (long item in allMissingLocations)
			{
				ItemTypes.Types itemType = ItemTypes.GetItemType(item);
				if ((itemType == ItemTypes.Types.Peak && flag) || (itemType == ItemTypes.Types.Artefact && flag2) || ((itemType == ItemTypes.Types.TATime || itemType == ItemTypes.Types.TAHolds || itemType == ItemTypes.Types.TARope) && flag3))
				{
					return false;
				}
			}
			return true;
		}

		public void CompleteWinCheck()
		{
			session.SetClientState((ArchipelagoClientState)30);
			session.SetGoalAchieved();
			hasWon = true;
		}

		private void KillPlayer()
		{
			FallingEvent[] array = Object.FindObjectsOfType<FallingEvent>();
			foreach (FallingEvent obj in array)
			{
				MethodInfo method = typeof(FallingEvent).GetMethod("FellToDeath", BindingFlags.Instance | BindingFlags.NonPublic);
				if (method == null)
				{
					return;
				}
				logger.LogInfo((object)"killing player");
				playerKilled = true;
				method.Invoke(obj, null);
			}
			Climbing[] array2 = Object.FindObjectsOfType<Climbing>();
			foreach (Climbing obj2 in array2)
			{
				obj2.ReleaseLHand(true);
				obj2.ReleaseRHand(true);
			}
		}

		public async Task ScoutLocations()
		{
			logger.LogInfo((object)"Scouting items");
			scoutedItems = await session.Locations.ScoutLocationsAsync((HintCreationPolicy)0, session.Locations.AllLocations.ToArray());
			logger.LogInfo((object)"Items scouted");
		}

		internal void HandleDeath()
		{
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Expected O, but got Unknown
			if (playerKilled)
			{
				playerKilled = false;
				return;
			}
			logger.LogInfo((object)"sending Deathlink");
			DeathLinkService obj = deathLinkService;
			if (obj != null)
			{
				obj.SendDeathLink(new DeathLink(session.Players.GetPlayerAliasAndName(session.ConnectionInfo.Slot), "Fell off."));
			}
		}

		private void LoadData()
		{
			settings = new SessionSettings(slotOptions);
			slotData = new SlotData(settings);
			itemCount = DataStorageElement.op_Implicit(session.DataStorage["ItemCount"]);
			instantCollectItems = session.Items.AllItemsReceived.Where((ItemInfo item) => item.ItemName != "Trap").Take(itemCount).ToList();
			uncollectedItems = session.Items.AllItemsReceived.Where((ItemInfo item) => item.ItemName != "Trap").Skip(itemCount).ToList();
			logger.LogInfo((object)$"Loaded {instantCollectItems.Count} old items and {uncollectedItems.Count} new items");
		}

		public void OnEnterCabin(object sender, Cabins cabin)
		{
			if (instantCollectItems.Count > 0)
			{
				logger.LogInfo((object)"Collecting previously unlocked items...");
				GameManager.control.ropesCollected = 0;
				GameManager.control.extraChalkUses = 0;
				GameManager.control.extraCoffeeUses = 0;
				GameManager.control.extraBirdSeedUses = 0;
				foreach (ItemInfo instantCollectItem in instantCollectItems)
				{
					logger.LogInfo((object)("Unlocking Item: " + instantCollectItem.ItemName));
					UnlockItem(instantCollectItem);
				}
				if (instantCollectItems.Count != DataStorageElement.op_Implicit(session.DataStorage["ItemCount"]))
				{
					int num = DataStorageElement.op_Implicit(session.DataStorage["ItemCount"]);
					logger.LogInfo((object)($"Warning: Item count mismatch! Expected {num}, " + $"got {instantCollectItems.Count}"));
				}
				session.DataStorage["ItemCount"] = DataStorageElement.op_Implicit(itemCount);
				instantCollectItems.Clear();
			}
			cabinHandler = CabinHandler.New(cabin, slotData);
			if (!hasWon && CheckCompletion() && cabinHandler.HandleCompletion())
			{
				CompleteWinCheck();
				return;
			}
			if (uncollectedItems.Count > 0)
			{
				logger.LogInfo((object)"Collecting new items...");
				if (cabinHandler.CollectItems(uncollectedItems))
				{
					foreach (ItemInfo uncollectedItem in uncollectedItems)
					{
						UnlockItem(uncollectedItem);
						if (ItemTypes.GetItemType(uncollectedItem.ItemId) == ItemTypes.Types.Artefact)
						{
							SetArtefactDirty(ItemIDs.GetArtefactFromID(uncollectedItem.ItemId));
						}
					}
					itemCount += uncollectedItems.Count;
					session.DataStorage["ItemCount"] = DataStorageElement.op_Implicit(itemCount);
					uncollectedItems.Clear();
				}
			}
			GameManager.control.Save();
			cabinHandler.LoadProgress();
		}

		public void OnExitCabin(object sender, EventArgs args)
		{
			cabinHandler = null;
		}

		public void ReloadCabin()
		{
			if (cabinHandler != null)
			{
				cabinHandler.LoadProgress();
			}
		}

		private void OnItemReceived(ItemInfo item)
		{
			if (item.ItemName == "Trap")
			{
				if (PeaksOfArchipelago.playerState == PeaksOfArchipelago.PlayerState.InPeak)
				{
					if ((Object)(object)TrapHandler.Instance == (Object)null)
					{
						logger.LogError((object)"Error: Tried activating trap but handler is null??");
						return;
					}
					logger.LogInfo((object)"Activating trap");
					TrapHandler.Instance?.StartRandomTrap();
				}
				else
				{
					logger.LogInfo((object)"Trap received but player is not in peak!");
				}
			}
			else
			{
				uncollectedItems.Add(item);
				logger.LogInfo((object)("Recieving Item: " + item.ItemName));
			}
		}

		private void UnlockItem(ItemInfo item)
		{
			ArchipelagoItem.Create(item).Unlock(slotData);
		}

		public void CompletePeakLocation(Peaks peak)
		{
			CompleteCheck(LocationIDs.GetPeakLocationID(peak));
		}

		public void CompleteFSPeakLocation(Peaks peak)
		{
			CompleteCheck(LocationIDs.GetFSPeakLocationID(peak));
		}

		public void CompleteArtefactLocation(Artefacts artefact)
		{
			CompleteCheck(LocationIDs.GetArtefactLocationID(artefact));
		}

		internal void CompleteRopeLocation(Ropes rope)
		{
			CompleteCheck(LocationIDs.GetRopeLocationID(rope));
		}

		internal void CompleteBirdSeedLocation(BirdSeeds seed)
		{
			CompleteCheck(LocationIDs.GetBirdSeedLocationID(seed));
		}

		internal void CompleteTimePBLocation(Peaks peak)
		{
			CompleteCheck(LocationIDs.GetTATimePBLocationID(peak));
		}

		internal void CompleteRopePBLocation(Peaks peak)
		{
			CompleteCheck(LocationIDs.GetTARopeLocationID(peak));
		}

		internal void CompleteHoldPBLocation(Peaks peak)
		{
			CompleteCheck(LocationIDs.GetTAHoldsLocationID(peak));
		}

		internal void CompleteMermaidLocation(Mermaids merm)
		{
			CompleteCheck(LocationIDs.GetMermaidLocationID(merm));
		}

		private void CompleteCheck(long locationID)
		{
			if (session != null)
			{
				if (scoutedItems != null && scoutedItems.ContainsKey(locationID) && session.Locations.AllMissingLocations.Contains(locationID))
				{
					ScoutedItemInfo val = scoutedItems[locationID];
					PeaksOfArchipelago.ui.SendNotification("Found " + val.Player.Name + "'s " + ((ItemInfo)val).ItemName);
				}
				session.Locations.CompleteLocationChecks(new long[1] { locationID });
			}
		}

		internal bool HasLocation(long v)
		{
			if (session != null)
			{
				return !session.Locations.AllMissingLocations.Contains(v);
			}
			return false;
		}

		internal int GetSaveSlot()
		{
			if (session == null)
			{
				return -1;
			}
			return DataStorageElement.op_Implicit(session.DataStorage["SaveSlot"]);
		}

		internal void SetSaveSlot(int slot)
		{
			if (session != null)
			{
				session.DataStorage["SaveSlot"] = DataStorageElement.op_Implicit(slot);
			}
		}

		internal SlotType GetSlotType()
		{
			if (session == null)
			{
				return SlotType.None;
			}
			return (SlotType)DataStorageElement.op_Implicit(session.DataStorage["SlotType"]);
		}

		internal void SetSlotType(SlotType type)
		{
			if (session != null)
			{
				session.DataStorage["SlotType"] = DataStorageElement.op_Implicit((int)type);
			}
		}

		internal void loadArtefacts()
		{
			cabinHandler?.LoadArtefacts();
		}

		private void SetArtefactDirty(Artefacts artefact)
		{
			switch (artefact)
			{
			case Artefacts.Hat1:
				GameManager.control.artefact_Hat1_IsDirty = true;
				break;
			case Artefacts.Hat2:
				GameManager.control.artefact_Hat2_IsDirty = true;
				break;
			case Artefacts.Helmet:
				GameManager.control.artefact_Helmet_IsDirty = true;
				break;
			case Artefacts.Shoe:
				GameManager.control.artefact_Shoe_IsDirty = true;
				break;
			case Artefacts.Shovel:
				GameManager.control.artefact_Shovel_IsDirty = true;
				break;
			case Artefacts.Sleepingbag:
				GameManager.control.artefact_Sleepingbag_IsDirty = true;
				break;
			case Artefacts.Backpack:
				GameManager.control.artefact_Backpack_IsDirty = true;
				break;
			case Artefacts.Coffebox_1:
				GameManager.control.artefact_Coffeebox1_IsDirty = true;
				break;
			case Artefacts.Coffebox_2:
				GameManager.control.artefact_Coffeebox2_IsDirty = true;
				break;
			case Artefacts.Chalkbox_1:
				GameManager.control.artefact_Chalkbox1_IsDirty = true;
				break;
			case Artefacts.Chalkbox_2:
				GameManager.control.artefact_Chalkbox2_IsDirty = true;
				break;
			case Artefacts.ClimberStatue1:
				GameManager.control.artefact_Statue1_IsDirty = true;
				break;
			case Artefacts.ClimberStatue2:
				GameManager.control.artefact_Statue2_IsDirty = true;
				break;
			case Artefacts.ClimberStatue3:
				GameManager.control.artefact_Statue3_IsDirty = true;
				break;
			case Artefacts.Photograph_1:
				GameManager.control.artefact_Photograph1_IsDirty = true;
				break;
			case Artefacts.Photograph_2:
				GameManager.control.artefact_Photograph2_IsDirty = true;
				break;
			case Artefacts.Photograph_3:
				GameManager.control.artefact_Photograph3_IsDirty = true;
				break;
			case Artefacts.Photograph_4:
				GameManager.control.artefact_Photograph4_IsDirty = true;
				break;
			case Artefacts.PhotographFrame:
				GameManager.control.artefact_PhotographFrame_IsDirty = true;
				break;
			case Artefacts.ClimberStatue0:
				GameManager.control.artefact_Statue0_IsDirty = true;
				break;
			}
		}
	}
	internal class Player
	{
		public enum PlayerState
		{
			InMainMenu,
			InCabin,
			InPeak
		}

		public PlayerState state;
	}
}
namespace PeaksOfArchipelago.Patches
{
	[HarmonyPatch(typeof(StatsAndAchievements))]
	internal class AchievementBlockPatches
	{
		[HarmonyPrefix]
		[HarmonyPatch("OnEnable")]
		public static bool AchievementDisabler()
		{
			PeaksOfArchipelago.Logger.LogInfo((object)"Disabled Achievements!");
			return false;
		}
	}
	[HarmonyPatch(typeof(NPCEvents))]
	internal class NPCEventsPatches
	{
		[CompilerGenerated]
		private sealed class <Wrapper>d__2 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public IEnumerator original;

			public NPCEvents __instance;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <Wrapper>d__2(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					goto IL_0045;
				case 1:
					<>1__state = -1;
					goto IL_0045;
				case 2:
					{
						<>1__state = -1;
						return false;
					}
					IL_0045:
					if (original.MoveNext())
					{
						<>2__current = original.Current;
						<>1__state = 1;
						return true;
					}
					if (__instance.eventName == "AllArtefacts")
					{
						GameManager control = GameManager.control;
						control.ropesCollected -= 5;
						GameManager control2 = GameManager.control;
						control2.extraCoffeeUses -= 999999999;
						GameManager control3 = GameManager.control;
						control3.extraChalkUses -= 999999999;
						GameManager.control.allArtefactsUnlocked = false;
						__instance.cabinallArtefacts.SetActive(false);
						GameManager.control.Save();
					}
					Connection.Instance.ReloadCabin();
					<>2__current = null;
					<>1__state = 2;
					return true;
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch("CheckProgress")]
		public static bool CabinEventDisabler()
		{
			PeaksOfArchipelago.Logger.LogInfo((object)"Disabled Cabin CheckProgress!");
			return false;
		}

		[HarmonyPostfix]
		[HarmonyPatch("ItemEvents")]
		public static void UndoAllArtefactsEffects(ref IEnumerator __result, NPCEvents __instance)
		{
			__result = Wrapper(__result, __instance);
		}

		[IteratorStateMachine(typeof(<Wrapper>d__2))]
		private static IEnumerator Wrapper(IEnumerator original, NPCEvents __instance)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <Wrapper>d__2(0)
			{
				original = original,
				__instance = __instance
			};
		}
	}
	[HarmonyPatch(typeof(RopeCabinDescription))]
	internal class RopeCabinPatches
	{
		private struct State
		{
			public bool p1;

			public bool p2;

			public bool p1d;

			public bool p2d;
		}

		[HarmonyPrefix]
		[HarmonyPatch("Update")]
		private static void UpdatePrefix(out State __state)
		{
			__state = default(State);
			__state.p1 = GameManager.control.alps_hasStatue_crimps_pt1;
			__state.p2 = GameManager.control.alps_hasStatue_crimps_pt2;
			__state.p1d = GameManager.control.alps_statue_crimps_IsDirty_pt1;
			__state.p2d = GameManager.control.alps_statue_crimps_IsDirty_pt2;
			GameManager.control.alps_hasStatue_crimps_pt1 = true;
			GameManager.control.alps_hasStatue_crimps_pt2 = true;
			GameManager.control.alps_statue_crimps_IsDirty_pt1 = false;
			GameManager.control.alps_statue_crimps_IsDirty_pt2 = false;
		}

		[HarmonyPostfix]
		[HarmonyPatch("Update")]
		private static void UpdatePostfix(State __state)
		{
			GameManager.control.alps_hasStatue_crimps_pt1 = __state.p1;
			GameManager.control.alps_hasStatue_crimps_pt2 = __state.p2;
			GameManager.control.alps_statue_crimps_IsDirty_pt1 = __state.p1d;
			GameManager.control.alps_statue_crimps_IsDirty_pt2 = __state.p2d;
		}
	}
	[HarmonyPatch(typeof(AlpsEvents))]
	internal class AlpsEventsPatches
	{
		[CompilerGenerated]
		private sealed class <Wrapper>d__2 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public IEnumerator original;

			public NPCEvents __instance;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <Wrapper>d__2(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					goto IL_0045;
				case 1:
					<>1__state = -1;
					goto IL_0045;
				case 2:
					{
						<>1__state = -1;
						return false;
					}
					IL_0045:
					if (original.MoveNext())
					{
						<>2__current = original.Current;
						<>1__state = 1;
						return true;
					}
					if (__instance.eventName == "Alps_Medal1")
					{
						GameManager.control.alps_Medal1 = false;
						GameManager.control.Save();
					}
					Connection.Instance.ReloadCabin();
					<>2__current = null;
					<>1__state = 2;
					return true;
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch("CheckProgress")]
		public static bool CabinEventDisabler()
		{
			PeaksOfArchipelago.Logger.LogInfo((object)"Disabled Alps Cabin CheckProgress!");
			return false;
		}

		[HarmonyPostfix]
		[HarmonyPatch("UnpackParcel")]
		public static void UndoAllArtefactsEffects(ref IEnumerator __result, NPCEvents __instance)
		{
			__result = Wrapper(__result, __instance);
		}

		[IteratorStateMachine(typeof(<Wrapper>d__2))]
		private static IEnumerator Wrapper(IEnumerator original, NPCEvents __instance)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <Wrapper>d__2(0)
			{
				original = original,
				__instance = __instance
			};
		}
	}
	[HarmonyPatch(typeof(ArtefactLoaderCabin))]
	internal class ArtefactLoaderCabinPatches
	{
		[HarmonyPrefix]
		[HarmonyPatch("LoadArtefacts")]
		public static bool ArtefactLoaderCabinDisabler()
		{
			Connection.Instance?.loadArtefacts();
			PeaksOfArchipelago.Logger.LogInfo((object)"Disabled artefact loading!");
			return false;
		}
	}
	[HarmonyPatch(typeof(DisableCabin4Flag))]
	internal class STGatewayPatches
	{
		[HarmonyPostfix]
		[HarmonyPatch("CheckFlag")]
		public static void STGatewayEnabler(DisableCabin4Flag __instance)
		{
			__instance.solemnTempestGateway.SetActive(Connection.Instance.slotData.HasPeak(Peaks.SolemnTempest));
		}
	}
	[HarmonyPatch(typeof(Cabin4Map))]
	internal class STGatewayEnabler
	{
		[HarmonyPrefix]
		[HarmonyPatch("Update")]
		public static void STEnablePrefix(out bool __state)
		{
			__state = GameManager.control.greatbulwark;
			GameManager.control.greatbulwark = Connection.Instance.slotData.HasPeak(Peaks.SolemnTempest);
		}

		[HarmonyPostfix]
		[HarmonyPatch("Update")]
		public static void STEnablePostfix(bool __state)
		{
			GameManager.control.greatbulwark = __state;
		}
	}
	[HarmonyPatch(typeof(TimeAttack_CheckScoreboard))]
	internal class TimeAttackCheckScoreboardPatches
	{
		[HarmonyPrefix]
		[HarmonyPatch("CheckOwned")]
		public static bool CheckOwnedPrefix(TimeAttack_CheckScoreboard __instance)
		{
			if (__instance.isAlps)
			{
				if (!GameManager.control.pocketwatch)
				{
					((Component)((Component)__instance).transform.parent).gameObject.SetActive(false);
				}
				return false;
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(EnterRoomSegmentScene))]
	internal class BaseIntroBlocker
	{
		[HarmonyPrefix]
		[HarmonyPatch("StartScene")]
		public static void IntroBlocker()
		{
			GameManager.control.hasPlayedGameIntro = true;
			GameManager.control.hasPlayedAlpsIntro = true;
		}
	}
	[HarmonyPatch(typeof(PeakSelection))]
	internal class PeakSelectionPatches
	{
		[HarmonyPrefix]
		[HarmonyPatch("OnMouseSpriteDown")]
		private static bool DisableClick(PeakSelection __instance)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Expected O, but got Unknown
			PeakJournal val = (PeakJournal)((object)__instance).GetType().GetField("peakJournal", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(__instance);
			if ((__instance.leftPage && !Connection.Instance.slotData.IsJournalPageUnlocked(val.currentPage, Books.Fundamentals)) || (!__instance.leftPage && !Connection.Instance.slotData.IsJournalPageUnlocked(val.currentPage + 1, Books.Fundamentals)))
			{
				return false;
			}
			return true;
		}

		[HarmonyPrefix]
		[HarmonyPatch("OnMouseSpriteOver")]
		public static void ColorHighLight(PeakSelection __instance)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Expected O, but got Unknown
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: 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)
			PeakJournal val = (PeakJournal)((object)__instance).GetType().GetField("peakJournal", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(__instance);
			MeshRenderer component = val.leftSelectOutlineOBJ.GetComponent<MeshRenderer>();
			MeshRenderer component2 = val.rightSelectOutlineOBJ.GetComponent<MeshRenderer>();
			if (__instance.leftPage && !Connection.Instance.slotData.IsJournalPageUnlocked(val.currentPage, Books.Fundamentals))
			{
				((Renderer)component).material.color = new Color(2f, 0f, 0f);
			}
			else
			{
				((Renderer)component).material.color = new Color(1f, 1f, 1f, 0.349f);
			}
			if (!__instance.leftPage && !Connection.Instance.slotData.IsJournalPageUnlocked(val.currentPage + 1, Books.Fundamentals))
			{
				((Renderer)component2).material.color = new Color(2f, 0f, 0f);
			}
			else
			{
				((Renderer)component2).material.color = new Color(1f, 1f, 1f, 0.349f);
			}
		}
	}
	[HarmonyPatch(typeof(PeakJournal))]
	internal class PageColorationPatches
	{
		[HarmonyPostfix]
		[HarmonyPatch("PageTurnSound")]
		public static void PageTurnColoration(PeakJournal __instance)
		{
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_010f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: 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_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			Animation journalPageAnim = __instance.journalPageAnim;
			AnimationClip journalPage_TurnLeft = __instance.journalPage_TurnLeft;
			Material leftPage = __instance.leftPage;
			Material rightPage = __instance.rightPage;
			Material frontPage = __instance.frontPage;
			Material backPage = __instance.backPage;
			int currentPage = __instance.currentPage;
			Books b = Books.Fundamentals;
			if ((Object)(object)journalPageAnim.clip == (Object)(object)journalPage_TurnLeft)
			{
				backPage.color = Connection.Instance.slotData.GetJournalPageColor(currentPage, b);
				frontPage.color = Connection.Instance.slotData.GetJournalPageColor(currentPage - 1, b);
				rightPage.color = Connection.Instance.slotData.GetJournalPageColor(currentPage + 1, b);
				leftPage.color = Connection.Instance.slotData.GetJournalPageColor(currentPage - 2, b);
			}
			else
			{
				backPage.color = Connection.Instance.slotData.GetJournalPageColor(currentPage + 2, b);
				frontPage.color = Connection.Instance.slotData.GetJournalPageColor(currentPage + 1, b);
				rightPage.color = Connection.Instance.slotData.GetJournalPageColor(currentPage + 3, b);
				leftPage.color = Connection.Instance.slotData.GetJournalPageColor(currentPage, b);
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch("UpdatePage")]
		public static void PageOpeningColor(PeakJournal __instance)
		{
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			((object)__instance).GetType();
			Material leftPage = __instance.leftPage;
			Material rightPage = __instance.rightPage;
			Material frontPage = __instance.frontPage;
			Material backPage = __instance.backPage;
			int currentPage = __instance.currentPage;
			Books b = Books.Fundamentals;
			backPage.color = Connection.Instance.slotData.GetJournalPageColor(currentPage + 2, b);
			frontPage.color = Connection.Instance.slotData.GetJournalPageColor(currentPage + 1, b);
			rightPage.color = Connection.Instance.slotData.GetJournalPageColor(currentPage + 3, b);
			leftPage.color = Connection.Instance.slotData.GetJournalPageColor(currentPage, b);
		}
	}
	[HarmonyPatch(typeof(IntermediatePeakSelection))]
	internal class IntermediatePeakSelectionPatches
	{
		[HarmonyPrefix]
		[HarmonyPatch("OnMouseSpriteDown")]
		private static bool DisableClick(IntermediatePeakSelection __instance)
		{
			((object)__instance).GetType();
			IntermediateJournal peakJournal = __instance.peakJournal;
			Books b = Books.Intermediate;
			if ((__instance.leftPage && !Connection.Instance.slotData.IsJournalPageUnlocked(peakJournal.currentPage, b)) || (!__instance.leftPage && !Connection.Instance.slotData.IsJournalPageUnlocked(peakJournal.currentPage + 1, b)))
			{
				return false;
			}
			return true;
		}

		[HarmonyPrefix]
		[HarmonyPatch("OnMouseSpriteOver")]
		public static void ColorHighLight(IntermediatePeakSelection __instance)
		{
			//IL_0083: 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_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			((object)__instance).GetType();
			IntermediateJournal peakJournal = __instance.peakJournal;
			MeshRenderer component = peakJournal.leftSelectOutlineOBJ.GetComponent<MeshRenderer>();
			MeshRenderer component2 = peakJournal.rightSelectOutlineOBJ.GetComponent<MeshRenderer>();
			Books b = Books.Intermediate;
			if (__instance.leftPage && !Connection.Instance.slotData.IsJournalPageUnlocked(peakJournal.currentPage, b))
			{
				((Renderer)component).material.color = new Color(2f, 0f, 0f);
			}
			else
			{
				((Renderer)component).material.color = new Color(1f, 1f, 1f, 0.349f);
			}
			if (!__instance.leftPage && !Connection.Instance.slotData.IsJournalPageUnlocked(peakJournal.currentPage + 1, b))
			{
				((Renderer)component2).material.color = new Color(2f, 0f, 0f);
			}
			else
			{
				((Renderer)component2).material.color = new Color(1f, 1f, 1f, 0.349f);
			}
		}
	}
	[HarmonyPatch(typeof(IntermediateJournal))]
	internal class IntermediatePageColorationPatches
	{
		[HarmonyPostfix]
		[HarmonyPatch("PageTurnSound")]
		public static void PageTurnColoration(IntermediateJournal __instance)
		{
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_010f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: 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_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			Animation journalPageAnim = __instance.journalPageAnim;
			AnimationClip journalPage_TurnLeft = __instance.journalPage_TurnLeft;
			Material leftPage = __instance.leftPage;
			Material rightPage = __instance.rightPage;
			Material frontPage = __instance.frontPage;
			Material backPage = __instance.backPage;
			int currentPage = __instance.currentPage;
			Books b = Books.Intermediate;
			if ((Object)(object)journalPageAnim.clip == (Object)(object)journalPage_TurnLeft)
			{
				backPage.color = Connection.Instance.slotData.GetJournalPageColor(currentPage, b);
				frontPage.color = Connection.Instance.slotData.GetJournalPageColor(currentPage - 1, b);
				rightPage.color = Connection.Instance.slotData.GetJournalPageColor(currentPage + 1, b);
				leftPage.color = Connection.Instance.slotData.GetJournalPageColor(currentPage - 2, b);
			}
			else
			{
				backPage.color = Connection.Instance.slotData.GetJournalPageColor(currentPage + 2, b);
				frontPage.color = Connection.Instance.slotData.GetJournalPageColor(currentPage + 1, b);
				rightPage.color = Connection.Instance.slotData.GetJournalPageColor(currentPage + 3, b);
				leftPage.color = Connection.Instance.slotData.GetJournalPageColor(currentPage, b);
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch("UpdatePage")]
		public static void PageOpeningColor(IntermediateJournal __instance)
		{
			//IL_002f: 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_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			Material leftPage = __instance.leftPage;
			Material rightPage = __instance.rightPage;
			Material frontPage = __instance.frontPage;
			Material backPage = __instance.backPage;
			int currentPage = __instance.currentPage;
			Books b = Books.Intermediate;
			backPage.color = Connection.Instance.slotData.GetJournalPageColor(currentPage + 2, b);
			frontPage.color = Connection.Instance.slotData.GetJournalPageColor(currentPage + 1, b);
			rightPage.color = Connection.Instance.slotData.GetJournalPageColor(currentPage + 3, b);
			leftPage.color = Connection.Instance.slotData.GetJournalPageColor(currentPage, b);
		}
	}
	[HarmonyPatch(typeof(AdvancedPeakSelection))]
	internal class AdvancedPeakSelectionPatches
	{
		[HarmonyPrefix]
		[HarmonyPatch("OnMouseSpriteDown")]
		private static bool DisableClick(AdvancedPeakSelection __instance)
		{
			((object)__instance).GetType();
			AdvancedJournal peakJournal = __instance.peakJournal;
			Books b = Books.Advanced;
			if ((__instance.leftPage && !Connection.Instance.slotData.IsJournalPageUnlocked(peakJournal.currentPage, b)) || (!__instance.leftPage && !Connection.Instance.slotData.IsJournalPageUnlocked(peakJournal.currentPage + 1, b)))
			{
				return false;
			}
			return true;
		}

		[HarmonyPrefix]
		[HarmonyPatch("OnMouseSpriteOver")]
		public static void ColorHighLight(AdvancedPeakSelection __instance)
		{
			//IL_0083: 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_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			((object)__instance).GetType();
			AdvancedJournal peakJournal = __instance.peakJournal;
			MeshRenderer component = peakJournal.leftSelectOutlineOBJ.GetComponent<MeshRenderer>();
			MeshRenderer component2 = peakJournal.rightSelectOutlineOBJ.GetComponent<MeshRenderer>();
			Books b = Books.Advanced;
			if (__instance.leftPage && !Connection.Instance.slotData.IsJournalPageUnlocked(peakJournal.currentPage, b))
			{
				((Renderer)component).material.color = new Color(2f, 0f, 0f);
			}
			else
			{
				((Renderer)component).material.color = new Color(1f, 1f, 1f, 0.349f);
			}
			if (!__instance.leftPage && !Connection.Instance.slotData.IsJournalPageUnlocked(peakJournal.currentPage + 1, b))
			{
				((Renderer)component2).material.color = new Color(2f, 0f, 0f);
			}
			else
			{
				((Renderer)component2).material.color = new Color(1f, 1f, 1f, 0.349f);
			}
		}
	}
	[HarmonyPatch(typeof(AdvancedJournal))]
	internal class AdvancedPageColorationPatches
	{
		[HarmonyPostfix]
		[HarmonyPatch("PageTurnSound")]
		public static void PageTurnColoration(AdvancedJournal __instance)
		{
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_010f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: 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_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			Animation journalPageAnim = __instance.journalPageAnim;
			AnimationClip journalPage_TurnLeft = __instance.journalPage_TurnLeft;
			Material leftPage = __instance.leftPage;
			Material rightPage = __instance.rightPage;
			Material frontPage = __instance.frontPage;
			Material backPage = __instance.backPage;
			int currentPage = __instance.currentPage;
			Books b = Books.Advanced;
			if ((Object)(object)journalPageAnim.clip == (Object)(object)journalPage_TurnLeft)
			{
				backPage.color = Connection.Instance.slotData.GetJournalPageColor(currentPage, b);
				frontPage.color = Connection.Instance.slotData.GetJournalPageColor(currentPage - 1, b);
				rightPage.color = Connection.Instance.slotData.GetJournalPageColor(currentPage + 1, b);
				leftPage.color = Connection.Instance.slotData.GetJournalPageColor(currentPage - 2, b);
			}
			else
			{
				backPage.color = Connection.Instance.slotData.GetJournalPageColor(currentPage + 2, b);
				frontPage.color = Connection.Instance.slotData.GetJournalPageColor(currentPage + 1, b);
				rightPage.color = Connection.Instance.slotData.GetJournalPageColor(currentPage + 3, b);
				leftPage.color = Connection.Instance.slotData.GetJournalPageColor(currentPage, b);
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch("UpdatePage")]
		public static void PageOpeningColor(AdvancedJournal __instance)
		{
			//IL_002f: 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_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			Material leftPage = __instance.leftPage;
			Material rightPage = __instance.rightPage;
			Material frontPage = __instance.frontPage;
			Material backPage = __instance.backPage;
			int currentPage = __instance.currentPage;
			Books b = Books.Advanced;
			backPage.color = Connection.Instance.slotData.GetJournalPageColor(currentPage + 2, b);
			frontPage.color = Connection.Instance.slotData.GetJournalPageColor(currentPage + 1, b);
			rightPage.color = Connection.Instance.slotData.GetJournalPageColor(currentPage + 3, b);
			leftPage.color = Connection.Instance.slotData.GetJournalPageColor(currentPage, b);
		}
	}
	[HarmonyPatch(typeof(AlpsPeakSelection))]
	internal class AlpsPeakSelectionPatches
	{
		[HarmonyPrefix]
		[HarmonyPatch("OnMouseSpriteDown")]
		private static bool DisableClick(AlpsPeakSelection __instance)
		{
			((object)__instance).GetType();
			AlpsJournal peakJournal = __instance.peakJournal;
			Books b = peakJournal.currentJournal switch
			{
				0 => Books.Essentials, 
				1 => Books.AlpineGreats, 
				2 => Books.ArduousArctic, 
				_ => Books.Essentials, 
			};
			if ((__instance.leftPage && !Connection.Instance.slotData.IsJournalPageUnlocked(peakJournal.currentPage, b)) || (!__instance.leftPage && !Connection.Instance.slotData.IsJournalPageUnlocked(peakJournal.currentPage + 1, b)))
			{
				return false;
			}
			return true;
		}

		[HarmonyPrefix]
		[HarmonyPatch("OnMouseSpriteOver")]
		public static void ColorHighLight(AlpsPeakSelection __instance)
		{
			//IL_00b3: 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_0119: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			((object)__instance).GetType();
			AlpsJournal peakJournal = __instance.peakJournal;
			MeshRenderer component = peakJournal.leftSelectOutlineOBJ.GetComponent<MeshRenderer>();
			MeshRenderer component2 = peakJournal.rightSelectOutlineOBJ.GetComponent<MeshRenderer>();
			Books b = peakJournal.currentJournal switch
			{
				0 => Books.Essentials, 
				1 => Books.AlpineGreats, 
				2 => Books.ArduousArctic, 
				_ => Books.Essentials, 
			};
			if (__instance.leftPage && !Connection.Instance.slotData.IsJournalPageUnlocked(peakJournal.currentPage, b))
			{
				((Renderer)component).material.color = new Color(2f, 0f, 0f);
			}
			else
			{
				((Renderer)component).material.color = new Color(1f, 1f, 1f, 0.349f);
			}
			if (!__instance.leftPage && !Connection.Instance.slotData.IsJournalPageUnlocked(peakJournal.currentPage + 1, b))
			{
				((Renderer)component2).material.color = new Color(2f, 0f, 0f);
			}
			else
			{
				((Renderer)component2).material.color = new Color(1f, 1f, 1f, 0.349f);
			}
		}
	}
	[HarmonyPatch(typeof(AlpsJournal))]
	internal class AlpsPageColorationPatches
	{
		[HarmonyPostfix]
		[HarmonyPatch("PageTurnSound")]
		public static void PageTurnColoration(AlpsJournal __instance)
		{
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0110: Unknown result type (might be due to invalid IL or missing references)
			//IL_012b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0144: 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_00a1: 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_00d7: Unknown result type (might be due to invalid IL or missing references)
			Animation journalPageAnim = __instance.journalPageAnim;
			AnimationClip journalPage_TurnLeft = __instance.journalPage_TurnLeft;
			Material leftPage = __instance.leftPage;
			Material rightPage = __instance.rightPage;
			Material frontPage = __instance.frontPage;
			Material backPage = __instance.backPage;
			int currentPage = __instance.currentPage;
			Books b = __instance.currentJournal switch
			{
				0 => Books.Essentials, 
				1 => Books.AlpineGreats, 
				2 => Books.ArduousArctic, 
				_ => Books.Essentials, 
			};
			if ((Object)(object)journalPageAnim.clip == (Object)(object)journalPage_TurnLeft)
			{
				backPage.color = Connection.Instance.slotData.GetJournalPageColor(currentPage, b);
				frontPage.color = Connection.Instance.slotData.GetJournalPageColor(currentPage - 1, b);
				rightPage.color = Connection.Instance.slotData.GetJournalPageColor(currentPage + 1, b);
				leftPage.color = Connection.Instance.slotData.GetJournalPageColor(currentPage - 2, b);
			}
			else
			{
				backPage.color = Connection.Instance.slotData.GetJournalPageColor(currentPage + 2, b);
				frontPage.color = Connection.Instance.slotData.GetJournalPageColor(currentPage + 1, b);
				rightPage.color = Connection.Instance.slotData.GetJournalPageColor(currentPage + 3, b);
				leftPage.color = Connection.Instance.slotData.GetJournalPageColor(currentPage, b);
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch("UpdatePage")]
		public static void PageOpeningColor(AlpsJournal __instance)
		{
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: 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_00b7: Unknown result type (might be due to invalid IL or missing references)
			Material leftPage = __instance.leftPage;
			Material rightPage = __instance.rightPage;
			Material frontPage = __instance.frontPage;
			Material backPage = __instance.backPage;
			int currentPage = __instance.currentPage;
			Books b = __instance.currentJournal switch
			{
				0 => Books.Essentials, 
				1 => Books.AlpineGreats, 
				2 => Books.ArduousArctic, 
				_ => Books.Essentials, 
			};
			backPage.color = Connection.Instance.slotData.GetJournalPageColor(currentPage + 2, b);
			frontPage.color = Connection.Instance.slotData.GetJournalPageColor(currentPage + 1, b);
			rightPage.color = Connection.Instance.slotData.GetJournalPageColor(currentPage + 3, b);
			leftPage.color = Connection.Instance.slotData.GetJournalPageColor(currentPage, b);
		}
	}
	[HarmonyPatch(typeof(StamperPeakSummit))]
	internal class StamperPatches
	{
		public struct State
		{
			public bool crampons;

			public bool cramponUpgrade;

			public bool rope;

			public int ropesCollected;

			public bool ropeUpgrade;

			public bool pipe;

			public bool chalkbag;

			public bool coffee;

			public bool instantiated;
		}

		[HarmonyPrefix]
		[HarmonyPatch("StampJournal")]
		public static void PeakLocationComplete(StamperPeakSummit __instance)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			if (!__instance.isCustomLevel)
			{
				Peaks peaks = ItemTypes.PeakfromStamper(__instance.peakNames);
				PeaksOfArchipelago.Logger.LogInfo((object)$"Stamping journal for peak {peaks} (derived from {__instance.peakNames})");
				Connection.Instance.CompletePeakLocation(peaks);
				if (Mappings.HasFreeSolo(peaks) && GameObject.FindGameObjectWithTag("Player").GetComponent<RopeAnchor>().ropesPlacedDuringMap == 0)
				{
					Connection.Instance.CompleteFSPeakLocation(peaks);
				}
				bool flag = Connection.Instance.settings.gameMode == SessionSettings.GameMode.BOOK_UNLOCK;
				Peaks peak = peaks + 1;
				bool flag2 = Mappings.GetPeakBook(peaks) != Mappings.GetPeakBook(peak);
				bool flag3 = Connection.Instance.HasLocation(LocationIDs.GetPeakLocationID(peak));
				((Component)__instance.gotonextpeak_ui).gameObject.SetActive(!flag2 && (flag || flag3));
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch("SavePeakProgress")]
		public static void PrePeakProgressSave(out State __state)
		{
			__state = new State
			{
				crampons = GameManager.control.crampons,
				cramponUpgrade = GameManager.control.cramponsUpgrade,
				rope = GameManager.control.rope,
				ropesCollected = GameManager.control.ropesCollected,
				ropeUpgrade = GameManager.control.ropesUpgrade,
				pipe = GameManager.control.smokingpipe,
				chalkbag = GameManager.control.chalkBag,
				coffee = GameManager.control.coffee,
				instantiated = true
			};
		}

		[HarmonyPostfix]
		[HarmonyPatch("SavePeakProgress")]
		public static void PostPeakProgessSave(State __state)
		{
			if (!__state.instantiated)
			{
				PeaksOfArchipelago.Logger.LogWarning((object)"state not instantiated somehow");
				return;
			}
			GameManager.control.crampons = __state.crampons;
			GameManager.control.cramponsUpgrade = __state.cramponUpgrade;
			GameManager.control.rope = __state.rope;
			GameManager.control.ropesCollected = __state.ropesCollected;
			GameManager.control.ropesUpgrade = __state.ropeUpgrade;
			GameManager.control.smokingpipe = __state.pipe;
			GameManager.control.chalkBag = __state.chalkbag;
			GameManager.control.coffee = __state.coffee;
		}
	}
	[HarmonyPatch(typeof(ArtefactOnPeak))]
	internal class ArtefactOnPeakPatches
	{
		[HarmonyPrefix]
		[HarmonyPatch("PickUpItem")]
		public static void ArtefactLocationComplete(ArtefactOnPeak __instance)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Expected I4, but got Unknown
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Invalid comparison between Unknown and I4
			int num = __instance.peakArtefact - 1;
			if ((int)__instance.peakArtefact >= 20)
			{
				num -= 3;
			}
			Artefacts artefact = (Artefacts)num;
			Connection.Instance.CompleteArtefactLocation(artefact);
		}
	}
	[HarmonyPatch(typeof(RopeCollectable))]
	internal class RopeCollectablePatches
	{
		[HarmonyPrefix]
		[HarmonyPatch("PickUpRope")]
		public static void RopeLocationComplete(RopeCollectable __instance)
		{
			//IL_0009: 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_0011: Expected I4, but got Unknown
			Ropes rope;
			if (!__instance.isSingleRope)
			{
				rope = (Ropes)(__instance.extraRopeNumber + 4);
			}
			else if (__instance.isWaltersCrag)
			{
				rope = Ropes.WaltersCrag;
			}
			else if (__instance.isWalkersPillar)
			{
				rope = Ropes.WalkersPillar;
			}
			else if (__instance.isGreatGaol)
			{
				rope = Ropes.GreatGaol;
			}
			else
			{
				if (!__instance.isStHaelga)
				{
					throw new Exception("Rope brok lol");
				}
				rope = Ropes.StHaelga;
			}
			Connection.Instance.CompleteRopeLocation(rope);
			RopeAnchor component = GameObject.FindGameObjectWithTag("Player").GetComponent<RopeAnchor>();
			if (__instance.isSingleRope)
			{
				component.anchorsInBackpack--;
				GameManager control = GameManager.control;
				control.ropesCollected--;
			}
			else
			{
				component.anchorsInBackpack -= 2;
				GameManager control2 = GameManager.control;
				control2.ropesCollected -= 2;
			}
			component.UpdateRopesCollected();
		}

		[HarmonyPrefix]
		[HarmonyPatch("CheckRope")]
		public static void StartPrefix(out int __state)
		{
			__state = GameManager.control.ropesCollected;
		}

		[HarmonyPostfix]
		[HarmonyPatch("CheckRope")]
		public static void StartPostfix(int __state)
		{
			GameManager.control.ropesCollected = __state;
		}
	}
	[HarmonyPatch(typeof(Mermaid))]
	internal class MermaidPatches
	{
		[HarmonyPrefix]
		[HarmonyPatch("LoadMermaidStuff")]
		public static bool LoadPublicStuffPrefix(Mermaid __instance)
		{
			int num = int.Parse(((Object)((Component)__instance).gameObject).name.Split(new char[1] { '_' })[1]);
			if (num <= 0)
			{
				throw new Exception("Error: incorrectly determined index of mermaid " + ((Object)((Component)__instance).gameObject).name);
			}
			if (__instance.isEagle)
			{
				Mermaids mermaid = (Mermaids)(num + 11);
				((Component)__instance).gameObject.SetActive(!Connection.Instance.HasLocation(LocationIDs.GetMermaidLocationID(mermaid)) && !GameManager.control.alps_statue_sundown_InUse);
			}
			else if (__instance.isGoat)
			{
				Mermaids mermaid2 = (Mermaids)(num + 6);
				__instance.eagleParentObj.SetActive(!Connection.Instance.HasLocation(LocationIDs.GetMermaidLocationID(mermaid2)) && GameManager.control.alps_statue_sundown_InUse);
			}
			else
			{
				Mermaids mermaid3 = (Mermaids)num;
				((Component)__instance).gameObject.SetActive(!Connection.Instance.HasLocation(LocationIDs.GetMermaidLocationID(mermaid3)));
			}
			return false;
		}
	}
	[HarmonyPatch(typeof(MonocularSightDetection))]
	internal class MonocularSightDetectionPatches
	{
		[HarmonyPrefix]
		[HarmonyPatch("FadeOutMermaid")]
		public static void UnlockMermaid(int mermaidID)
		{
			Mermaids mermaids = (Mermaids)(-1);
			mermaids = (Mermaids)((mermaidID <= 7) ? (mermaidID - 1) : ((mermaidID > 12) ? (mermaidID - 6) : (mermaidID + 4)));
			Connection.Instance.CompleteMermaidLocation(mermaids);
		}
	}
	[HarmonyPatch(typeof(BirdSeedCollectable))]
	internal class BirdSeedCollectablePatches
	{
		[HarmonyPrefix]
		[HarmonyPatch("PickUpBirdSeed")]
		public static void BirdSeedLocationComplete(BirdSeedCollectable __instance)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected I4, but got Unknown
			BirdSeeds seed = (BirdSeeds)__instance.extraBirdSeedNumber;
			Connection.Instance.CompleteBirdSeedLocation(seed);
			GameManager control = GameManager.control;
			control.extraBirdSeedUses--;
		}

		[HarmonyPrefix]
		[HarmonyPatch("CheckBirdSeed")]
		public static void StartPrefix()
		{
			GameManager.control.extraBirdSeedUses = 0;
		}

		[HarmonyPostfix]
		[HarmonyPatch("CheckBirdSeed")]
		public static void StartPostfix()
		{
			GameManager.control.extraBirdSeedUses = Connection.Instance.slotData.GetTotalExtraBirdSeedCount();
		}
	}
	[HarmonyPatch(typeof(TimeAttack))]
	internal class TimeAttackCompletePatch
	{
		public struct TimeAttackDefaultData
		{
			public float[] times;

			public int[] ropes;

			public int[] holds;
		}

		public static TimeAttackDefaultData timeAttackDefaultData;

		[HarmonyPrefix]
		[HarmonyPatch("SetBestTime")]
		public static void BestTimeSet(TimeAttack __instance)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			if (timeAttackDefaultData.ropes != null)
			{
				Peaks peaks = ItemTypes.PeakfromStamper(__instance.summitStamper.peakNames);
				if (__instance.timer < timeAttackDefaultData.times[(int)peaks])
				{
					Connection.Instance.CompleteTimePBLocation(peaks);
				}
				if (__instance.ropesUsed <= timeAttackDefaultData.ropes[(int)peaks])
				{
					Connection.Instance.CompleteRopePBLocation(peaks);
				}
				if (__instance.holdsMade < timeAttackDefaultData.holds[(int)peaks])
				{
					Connection.Instance.CompleteHoldPBLocation(peaks);
				}
			}
		}
	}
	[HarmonyPatch(typeof(TimeAttackSetter))]
	internal class SetDefaultTimes
	{
		[HarmonyPostfix]
		[HarmonyPatch("SetDefaults")]
		public static void LoadTimeAttack(TimeAttackSetter __instance)
		{
			if (TimeAttackCompletePatch.timeAttackDefaultData.times == null)
			{
				List<float> list = new List<float>();
				list.AddRange(__instance.category1_defaultTimes);
				list.AddRange(__instance.category2_defaultTimes);
				list.AddRange(__instance.category3_defaultTimes);
				list.AddRange(__instance.alps_category1_defaultTimes);
				list.AddRange(__instance.alps_category2_defaultTimes);
				list.AddRange(__instance.alps_category3_defaultTimes);
				TimeAttackCompletePatch.timeAttackDefaultData.times = list.ToArray();
				List<int> list2 = new List<int>();
				list2.AddRange(__instance.category1_defaultRopes);
				list2.AddRange(__instance.category2_defaultRopes);
				list2.AddRange(__instance.category3_defaultRopes);
				list2.AddRange(__instance.alps_category1_defaultRopes);
				list2.AddRange(__instance.alps_category2_defaultRopes);
				list2.AddRange(__instance.alps_category3_defaultRopes);
				TimeAttackCompletePatch.timeAttackDefaultData.ropes = list2.ToArray();
				List<int> list3 = new List<int>();
				list3.AddRange(__instance.category1_defaultHolds);
				list3.AddRange(__instance.category2_defaultHolds);
				list3.AddRange(__instance.category3_defaultHolds);
				list3.AddRange(__instance.alps_category1_defaultHolds);
				list3.AddRange(__instance.alps_category2_defaultHolds);
				list3.AddRange(__instance.alps_category3_defaultHolds);
				TimeAttackCompletePatch.timeAttackDefaultData.holds = list3.ToArray();
			}
		}
	}
	[HarmonyPatch(typeof(MenuSaveManager))]
	internal class MenuSaveManagerPatches
	{
		[HarmonyPostfix]
		[HarmonyPatch("CheckModesUnlocked")]
		public static void GoToModesPostfix(MenuSaveManager __instance)
		{
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Expected O, but got Unknown
			Transform val = __instance.modeSelectMenu.transform.Find("ButtonLayout");
			Transform val2 = val.Find("NormalPlaythrough") ?? val.GetChild(0);
			Transform transform = __instance.yfydButton.transform;
			foreach (Transform item in val)
			{
				Transform val3 = item;
				if (((Object)val3).name != ((Object)val2).name && ((Object)val3).name != ((Object)transform).name)
				{
					((Component)val3).gameObject.SetActive(false);
				}
			}
			((Component)val2).GetComponentInChildren<Text>().text = "Archipelago";
			SlotType slotType = ((Connection.Instance != null) ? Connection.Instance.GetSlotType() : SlotType.None);
			((Selectable)((Component)val2).GetComponent<Button>()).interactable = slotType == SlotType.None || slotType == SlotType.Normal;
			((Selectable)((Component)transform).GetComponent<Button>()).interactable = slotType == SlotType.None || slotType == SlotType.YFYD;
		}

		[HarmonyPostfix]
		[HarmonyPatch("GoToSlots")]
		public static void GoToSlotsPostfix(MenuSaveManager __instance)
		{
			if (Connection.Instance == null)
			{
				PeaksOfArchipelago.Logger.LogFatal((object)"Connection should not be null :(");
				return;
			}
			int saveSlot = Connection.Instance.GetSaveSlot();
			SlotType slotType = Connection.Instance.GetSlotType();
			Button[] slotButtons = __instance.slotButtons;
			bool flag = (MenuSaveManager.modeSelect == 0 && slotType == SlotType.Normal) || (MenuSaveManager.modeSelect == 1 && slotType == SlotType.YFYD) || slotType == SlotType.None;
			for (int i = 0; i < 3; i++)
			{
				bool flag2 = ((Component)slotButtons[i]).GetComponentInChildren<Text>().text.ToUpper().Equals("EMPTY");
				if (flag2)
				{
					PeaksOfArchipelago.Logger.LogInfo((object)$"Slot {i} is empty");
				}
				if (saveSlot == -1)
				{
					((Selectable)slotButtons[i]).interactable = flag2 && flag;
				}
				else
				{
					((Selectable)slotButtons[i]).interactable = i == saveSlot && flag;
				}
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch("PlaySlot")]
		public static void PlaySlotPostfix(MenuSaveManager __instance, int slotToUse)
		{
			Connection.Instance.SetSaveSlot(slotToUse);
			switch (MenuSaveManager.modeSelect)
			{
			case 0:
				Connection.Instance.SetSlotType(SlotType.Normal);
				break;
			case 1:
				Connection.Instance.SetSlotType(SlotType.YFYD);
				break;
			default:
				Connection.Instance.SetSlotType(SlotType.None);
				break;
			}
		}
	}
	[HarmonyPatch(typeof(Player))]
	internal class HandBlockingPatch
	{
		[HarmonyPrefix]
		[HarmonyPatch("GetButton", new Type[] { typeof(string) })]
		public static bool HandDisabler(ref bool __result, string actionName)
		{
			if (actionName == "Arm Right" && !Connection.Instance.slotData.HasTool(Tools.RightHand))
			{
				return false;
			}
			if (actionName == "Arm Left" && !Connection.Instance.slotData.HasTool(Tools.leftHand))
			{
				return false;
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(OilLamp))]
	internal class OilLampPatch
	{
		[HarmonyPostfix]
		[HarmonyPatch("OilLampLightUp")]
		public static void Postfix(OilLamp __instance, ref IEnumerator __result)
		{
			if (!Connection.Instance.slotData.HasTool(Tools.Lamp))
			{
				__instance.oilLampLight.intensity = 0f;
				__result = null;
			}
		}
	}
	[HarmonyPatch(typeof(NPCSystem))]
	internal class NPCGivenItemsPatch
	{
		[HarmonyPatch("GivePlayerMonocular")]
		[HarmonyPostfix]
		public static void TakeAwayMonocular()
		{
			GameManager.control.monocular = Connection.Instance.slotData.HasTool(Tools.Monocular);
		}

		[HarmonyPatch("GivePlayerCoffee")]
		[HarmonyPostfix]
		public static void TakeAwayCoffee()
		{
			GameManager.control.coffee = Connection.Instance.slotData.HasTool(Tools.Coffee);
		}

		[HarmonyPatch("GivePlayerRope")]
		[HarmonyPostfix]
		public static void TakeAwayRope(NPCSystem __instance)
		{
			Ropes ropes = (Ropes)(-1);
			if (__instance.isStHaelga)
			{
				ropes = Ropes.StHaelga;
			}
			else
			{
				if (!__instance.isGreatGaol)
				{
					throw new Exception("Unknown rope NPC");
				}
				ropes = Ropes.GreatGaol;
			}
			GameManager control = GameManager.control;
			control.ropesCollected--;
			RopeAnchor component = GameObject.FindGameObjectWithTag("Player").GetComponent<RopeAnchor>();
			component.anchorsInBackpack--;
			Connection.Instance.CompleteRopeLocation(ropes);
		}
	}
	[HarmonyPatch(typeof(NPC_Climber))]
	internal class ClimberGivenItemsPatch
	{
		[HarmonyPatch("GivePlayerRope")]
		[HarmonyPostfix]
		public static void CollectRope(NPC_Climber __instance)
		{
			Ropes ropes = (Ropes)(-1);
			if (__instance.isWaltersCrag)
			{
				ropes = Ropes.WaltersCrag;
			}
			else
			{
				if (!__instance.isWalkersPillar)
				{
					throw new Exception("Unknown rope NPC");
				}
				ropes = Ropes.WalkersPillar;
			}
			GameManager control = GameManager.control;
			control.ropesCollected--;
			RopeAnchor component = GameObject.FindGameObjectWithTag("Player").GetComponent<RopeAnchor>();
			component.anchorsInBackpack--;
			Connection.Instance.CompleteRopeLocation(ropes);
		}
	}
	[HarmonyPatch(typeof(TimeAttack))]
	internal class TimeAttackNullReferenceExceptionPatch
	{
		[HarmonyPatch("Update")]
		[HarmonyPrefix]
		public static bool UpdatePatch()
		{
			//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)).buildIndex == 37)
			{
				return false;
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(Text))]
	internal class TextPatch
	{
		[HarmonyPrefix]
		[HarmonyPatch(/*Could not decode attribute arguments.*/)]
		public static bool TextPrefix(ref string value)
		{
			if (value == "- Essentials Completion Medal -" || value == "Awarded by the Alpine Climbing Association for summiting every peak in the \"Essentials\" category.")
			{
				return false;
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(PlayerPrefs))]
	internal class PlayerPrefsPatch
	{
		[HarmonyPrefix]
		[HarmonyPatch("HasKey")]
		public static bool HasKeyPrefix(string key, ref bool __result)
		{
			if (key.Equals("Pin_AA_4") || key.Equals("Pin_AA_5"))
			{
				__result = false;
				return false;
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(RopeAnchor))]
	internal class RopeAnchorPatch
	{
		[HarmonyPrefix]
		[HarmonyPatch("Start")]
		public static void Prefix(RopeAnchor __instance, out int __state)
		{
			__state = GameManager.control.ropesCollected;
		}

		[HarmonyPostfix]
		[HarmonyPatch("Start")]
		public static void Postfix(RopeAnchor __instance, int __state)
		{
			__instance.anchorsInBackpack = __state;
			GameManager.control.ropesCollected = __state;
			__instance.UpdateRopesCollected();
		}
	}
	[HarmonyPatch(typeof(FallingEvent))]
	internal class DeathFallPatch
	{
		[HarmonyPostfix]
		[HarmonyPatch("FellToDeath")]
		public static void Kill()
		{
			Connection.Instance?.HandleDeath();
		}
	}
}
namespace PeaksOfArchipelago.MonoBehaviours
{
	public class BookLayoutGroup : GridLayoutGroup
	{
		public override void SetLayoutHorizontal()
		{
			SetCellsAlongAxis(0);
		}

		public override void SetLayoutVertical()
		{
			SetCellsAlongAxis(1);
		}

		private void SetCellsAlongAxis(int axis)
		{
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: 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_008e: 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_00a4: Invalid comparison between Unknown and I4
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Invalid comparison between Unknown and I4
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0200: Expected I4, but got Unknown
			//IL_0201: Unknown result type (might be due to invalid IL or missing references)
			//IL_0207: Unknown result type (might be due to invalid IL or missing references)
			//IL_020a: Expected I4, but got Unknown
			//IL_020b: 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_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: 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_0135: Unknown result type (might be due to invalid IL or missing references)
			//IL_0140: 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_0163: Unknown result type (might be due to invalid IL or missing references)
			//IL_0284: Unknown result type (might be due to invalid IL or missing references)
			//IL_0295: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_018c: 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_01a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0303: Unknown result type (might be due to invalid IL or missing references)
			//IL_0347: Unknown result type (might be due to invalid IL or missing references)
			//IL_0352: Unknown result type (might be due to invalid IL or missing references)
			//IL_0362: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0411: Unknown result type (might be due to invalid IL or missing references)
			//IL_0421: Unknown result type (might be due to invalid IL or missing references)
			//IL_0426: Unknown result type (might be due to invalid IL or missing references)
			if (axis == 0)
			{
				for (int i = 0; i < ((LayoutGroup)this).rectChildren.Count; i++)
				{
					RectTransform val = ((LayoutGroup)this).rectChildren[i];
					((DrivenRectTransformTracker)(ref ((LayoutGroup)this).m_Tracker)).Add((Object)(object)this, val, (DrivenTransformProperties)16134);
					val.anchorMin = Vector2.up;
					val.anchorMax = Vector2.up;
					val.sizeDelta = ((GridLayoutGroup)this).cellSize;
				}
				return;
			}
			Rect rect = ((LayoutGroup)this).rectTransform.rect;
			float x = ((Rect)(ref rect)).size.x;
			rect = ((LayoutGroup)this).rectTransform.rect;
			float y = ((Rect)(ref rect)).size.y;
			int num = 1;
			int num2 = 1;
			if ((int)base.m_Constraint == 1)
			{
				num = base.m_ConstraintCount;
				if (((LayoutGroup)this).rectChildren.Count > num)
				{
					num2 = ((LayoutGroup)this).rectChildren.Count / num + ((((LayoutGroup)this).rectChildren.Count % num > 0) ? 1 : 0);
				}
			}
			else if ((int)base.m_Constraint != 2)
			{
				num = ((!(((GridLayoutGroup)this).cellSize.x + ((GridLayoutGroup)this).spacing.x <= 0f)) ? Mathf.Max(1, Mathf.FloorToInt((x - (float)((LayoutGroup)this).padding.horizontal + ((GridLayoutGroup)this).spacing.x + 0.001f) / (((GridLayoutGroup)this).cellSize.x + ((GridLayoutGroup)this).spacing.x))) : int.MaxValue);
				num2 = ((!(((GridLayoutGroup)this).cellSize.y + ((GridLayoutGroup)this).spacing.y <= 0f)) ? Mathf.Max(1, Mathf.FloorToInt((y - (float)((LayoutGroup)this).padding.vertical + ((GridLayoutGroup)this).spacing.y + 0.001f) / (((GridLayoutGroup)this).cellSize.y + ((GridLayoutGroup)this).spacing.y))) : int.MaxValue);
			}
			else
			{
				num2 = base.m_ConstraintCount;
				if (((LayoutGroup)this).rectChildren.Count > num2)
				{
					num = ((LayoutGroup)this).rectChildren.Count / num2 + ((((LayoutGroup)this).rectChildren.Count % num2 > 0) ? 1 : 0);
				}
			}
			int num3 = ((GridLayoutGroup)this).startCorner % 2;
			int num4 = ((GridLayoutGroup)this).startCorner / 2;
			int num5;
			int num6;
			int num7;
			if ((int)((GridLayoutGroup)this).startAxis == 0)
			{
				num5 = num;
				num6 = Mathf.Clamp(num, 1, ((LayoutGroup)this).rectChildren.Count);
				num7 = Mathf.Clamp(num2, 1, Mathf.CeilToInt((float)((LayoutGroup)this).rectChildren.Count / (float)num5));
			}
			else
			{
				num5 = num2;
				num7 = Mathf.Clamp(num2, 1, ((LayoutGroup)this).rectChildren.Count);
				num6 = Mathf.Clamp(num, 1, Mathf.CeilToInt((float)((LayoutGroup)this).rectChildren.Count / (float)num5));
			}
			Vector2 val2 = default(Vector2);
			((Vector2)(ref val2))..ctor((float)num6 * ((GridLayoutGroup)this).cellSize.x + (float)(num6 - 1) * ((GridLayoutGroup)this).spacing.x, (float)num7 * ((GridLayoutGroup)this).cellSize.y + (float)(num7 - 1) * ((GridLayoutGroup)this).spacing.y);
			Vector2 val3 = default(Vector2);
			((Vector2)(ref val3))..ctor(((LayoutGroup)this).GetStartOffset(0, val2.x), ((LayoutGroup)this).GetStartOffset(1, val2.y));
			int num8 = ((LayoutGroup)this).rectChildren.Count % num5;
			Vector2 val4 = default(Vector2);
			for (int j = 0; j < ((LayoutGroup)this).rectChildren.Count; j++)
			{
				int num9;
				int num10;
				if ((int)((GridLayoutGroup)this).startAxis == 0)
				{
					num9 = j % num5;
					num10 = j / num5;
				}
				else
				{
					num9 = j / num5;
					num10 = j % num5;
				}
				if (num3 == 1)
				{
					num9 = num6 - 1 - num9;
				}
				if (num4 == 1)
				{
					num10 = num7 - 1 - num10;
				}
				((Vector2)(ref val4))..ctor(((GridLayoutGroup)this).cellSize.x, ((GridLayoutGroup)this).cellSize.y);
				if ((int)((GridLayoutGroup)this).startAxis == 0)
				{
					int num11 = ((num9 < num8) ? num7 : (num7 - 1));
					val4.y /= ((num8 == 0) ? (num11 + 1) : num11);
				}
				else
				{
					int num12 = Mathf.Max((num10 < num8) ? num6 : (num6 - 1), 1);
					val4.x /= ((num12 == 0) ? (num12 + 1) : num12);
				}
				RectTransform obj = ((LayoutGroup)this).rectChildren[j];
				float x2 = val3.x;
				float num13 = ((Vector2)(ref val4))[0];
				Vector2 spacing = ((GridLayoutGroup)this).spacing;
				((LayoutGroup)this).SetChildAlongAxis(obj, 0, x2 + (num13 + ((Vector2)(ref spacing))[0]) * (float)num9, ((Vector2)(ref val4))[0]);
				RectTransform obj2 = ((LayoutGroup)this).rectChildren[j];
				float y2 = val3.y;
				float num14 = ((Vector2)(ref val4))[1];
				spacing = ((GridLayoutGroup)this).spacing;
				((LayoutGroup)this).SetChildAlongAxis(obj2, 1, y2 + (num14 + ((Vector2)(ref spacing))[1]) * (float)num10, ((Vector2)(ref val4))[1]);
			}
		}
	}
	public class Notification : MonoBehaviour
	{
		[CompilerGenerated]
		private sealed class <FadeTimer>d__5 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public Notification <>4__this;

			public float fadeDuration;

			public float duration;

			private float <elapsed>5__2;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <FadeTimer>d__5(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0057: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d3: Expected O, but got Unknown
				int num = <>1__state;
				Notification notification = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = null;
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					((Component)notification).transform.position = notification.startPosition;
					<elapsed>5__2 = 0f;
					goto IL_00b4;
				case 2:
					<>1__state = -1;
					goto IL_00b4;
				case 3:
					<>1__state = -1;
					<elapsed>5__2 = 0f;
					goto IL_013c;
				case 4:
					<>1__state = -1;
					goto IL_013c;
				case 5:
					<>1__state = -1;
					Object.Destroy((Object)(object)((Component)notification.targetTransform).gameObject);
					<>2__current = null;
					<>1__state = 6;
					return true;
				case 6:
					{
						<>1__state = -1;
						Object.Destroy((Object)(object)((Component)notification).gameObject);
						return false;
					}
					IL_013c:
					if (<elapsed>5__2 < fadeDuration)
					{
						<elapsed>5__2 += Time.deltaTime;
						notification.canvasGroup.alpha = 1f - Mathf.Clamp01(<elapsed>5__2 / fadeDuration);
						<>2__current = null;
						<>1__state = 4;
						return true;
					}
					<>2__current = null;
					<>1__state = 5;
					return true;
					IL_00b4:
					if (<elapsed>5__2 < duration)
					{
						<elapsed>5__2 += Time.deltaTime;
						notification.canvasGroup.alpha = Mathf.Clamp01(<elapsed>5__2 / fadeDuration);
						<>2__current = null;
						<>1__state = 2;
						return true;
					}
					<>2__current = (object)new WaitForSeconds(duration);
					<>1__state = 3;
					return true;
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		private Transform targetTransform;

		private Vector3 velocity = Vector3.zero;

		private Vector3 startPosition;

		private CanvasGroup canvasGroup;

		public void Init(string message, Transform target, Vector3 startPos, float duration = 2f)
		{
			//IL_002b: 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)
			canvasGroup = ((Component)this).GetComponent<CanvasGroup>();
			Text componentInChildren = ((Component)this).GetComponentInChildren<Text>();
			if ((Object)(object)componentInChildren != (Object)null)
			{
				componentInChildren.text = message;
			}
			targetTransform = target;
			startPosition = startPos;
			((MonoBehaviour)this).StartCoroutine(FadeTimer(duration, 0.5f));
		}

		[IteratorStateMachine(typeof(<FadeTimer>d__5))]
		private IEnumerator FadeTimer(float duration, float fadeDuration)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <FadeTimer>d__5(0)
			{
				<>4__this = this,
				duration = duration,
				fadeDuration = fadeDuration
			};
		}

		private void Update()
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: 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)
			if ((Object)(object)targetTransform != (Object)null)
			{
				((Component)this).transform.position = Vector3.SmoothDamp(((Component)this).transform.position, targetTransform.position, ref velocity, 0.5f);
			}
		}
	}
	public class Notificator : MonoBehaviour
	{
		public GameObject notificationPrefab;

		private Transform notificationParent;

		private void Awake()
		{
			notificationParent = ((Component)this).transform.GetChild(0);
		}

		public void CreateNotification(string message, float duration = 2f)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Expected O, but got Unknown
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("NotifLoc", new Type[1] { typeof(RectTransform) });
			val.transform.SetParent(notificationParent);
			val.transform.SetAsFirstSibling();
			GameObject val2 = Object.Instantiate<GameObject>(notificationPrefab, ((Component)this).transform);
			Notification notification = val2.AddComponent<Notification>();
			if (Object.op_Implicit((Object)(object)notification))
			{
				val2.SetActive(true);
				notification.Init(message, val.transform, ((Component)this).transform.position + Vector3.up * 500f, duration);
			}
		}
	}
	internal class ProgressDisplay : MonoBehaviour
	{
		[CompilerGenerated]
		private sealed class <ShowTutorial>d__19 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public ProgressDisplay <>4__this;

			private GameObject <tutorialObject>5__2;

			private CanvasGroup <cg>5__3;

			private float <t>5__4;

			private float <d>5__5;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <ShowTutorial>d__19(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<tutorialObject>5__2 = null;
				<cg>5__3 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				int num = <>1__state;
				ProgressDisplay progressDisplay = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<tutorialObject>5__2 = Object.Instantiate<GameObject>(PeaksOfAssets.ProgressScreenTutorial, ((Component)progressDisplay.canvas).transform);
					<cg>5__3 = <tutorialObject>5__2.GetComponent<CanvasGroup>();
					<cg>5__3.alpha = 0f;
					<t>5__4 = 0f;
					<d>5__5 = 2f;
					goto IL_00c6;
				case 1:
					<>1__state = -1;
					goto IL_00c6;
				case 2:
					<>1__state = -1;
					goto IL_00f4;
				case 3:
					<>1__state = -1;
					goto IL_015e;
				case 4:
					{
						<>1__state = -1;
						return false;
					}
					IL_00c6:
					if (<t>5__4 < <d>5__5)
					{
						<t>5__4 += Time.deltaTime;
						<cg>5__3.alpha = <t>5__4 / <d>5__5;
						<>2__current = null;
						<>1__state = 1;
						return true;
					}
					progressDisplay.showingTutorial = true;
					goto IL_00f4;
					IL_015e:
					if (<t>5__4 > 0f)
					{
						<t>5__4 -= Time.deltaTime;
						<cg>5__3.alpha = <t>5__4 / <d>5__5;
						<>2__current = null;
						<>1__state = 3;
						return true;
					}
					Object.Destroy((Object)(object)<tutorialObject>5__2);
					<>2__current = null;
					<>1__state = 4;
					return true;
					IL_00f4:
					if (progressDisplay.showingTutorial)
					{
						<>2__current = null;
						<>1__state = 2;
						return true;
					}
					PeaksOfArchipelago.Instance.hasSeenProgressScreenTutorial.Value = true;
					((BaseUnityPlugin)PeaksOfArchipelago.Instance).Config.Save();
					goto IL_015e;
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		private Connection connection;

		private Canvas canvas;

		private Transform progressDisplayRoot;

		private Dictionary<Books, Transform> books = new Dictionary<Books, Transform>();

		private Dictionary<Peaks, Transform> peaks = new Dictionary<Peaks, Transform>();

		private ManualLogSource Logger;

		private SessionSettings settings;

		private bool showingTutorial;

		private bool visible;

		public void Update()
		{
			if (visible)
			{
				if (Input.GetKeyDown((KeyCode)112) || Input.GetKeyDown((KeyCode)27))
				{
					Disable();
				}
			}
			else if (Input.GetKeyDown((KeyCode)112))
			{
				showingTutorial = false;
				Enable();
			}
		}

		private void Enable()
		{
			visible = true;
			((Component)progressDisplayRoot).gameObject.SetActive(true);
			Cursor.lockState = (CursorLockMode)0;
			Cursor.visible = true;
			LoadValues(connection.slotData);
		}

		private void Disable()
		{
			visible = false;
			((Component)progressDisplayRoot).gameObject.SetActive(false);
			Cursor.lockState = (CursorLockMode)1;
			Cursor.visible = false;
		}

		internal void Initialize(Canvas canvas, Connection connection)
		{
			//IL_0056: 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_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: 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)
			this.canvas = canvas;
			this.connection = connection;
			Logger = PeaksOfArchipelago.Logger;
			progressDisplayRoot = Object.Instantiate<GameObject>(PeaksOfAssets.ProgressDisplay, ((Component)canvas).transform).transform;
			progressDisplayRoot.SetAsLastSibling();
			((Component)progressDisplayRoot).gameObject.SetActive(false);
			Vector2 sizeDelta = ((RectTransform)((Component)canvas).transform).sizeDelta;
			PeaksOfArchipelago.Logger.LogInfo((object)sizeDelta);
			BookLayoutGroup bookLayoutGroup = ((Component)progressDisplayRoot).gameObject.AddComponent<BookLayoutGroup>();
			((GridLayoutGroup)bookLayoutGroup).constraint = (Constraint)1;
			((GridLayoutGroup)bookLayoutGroup).constraintCount = 4;
			((GridLayoutGroup)bookLayoutGroup).cellSize = new Vector2(sizeDelta.x / 4f, sizeDelta.y);
			if (!PeaksOfArchipelago.Instance.hasSeenProgressScreenTutorial.Value)
			{
				((MonoBehaviour)this).StartCoroutine("ShowTutorial");
			}
			settings = connection.settings;
			InitObjects();
		}

		private void LoadValues(ISlotData data)
		{
			foreach (Books value in Enum.GetValues(typeof(Books)))
			{
				LoadBookData(value, data);
			}
		}

		private void LoadBookData(Books book, ISlotData data)
		{
			bool flag = data.ShowBook(book);
			((Component)books[book]).gameObject.SetActive(flag);
			if (!flag)
			{
				return;
			}
			Transform val = books[book].FindDeep("BOOKNAME");
			if ((Object)(object)val == (Object)null)
			{
				Logger.LogError((object)"Couldn't find book name text field");
				return;
			}
			((Component)val).GetComponent<Text>().text = Mappings.GetBookName(book);
			Peaks[] array = Mappings.GetBookPeaks(book).ToArray();
			foreach (Peaks peak in array)
			{
				LoadPeakData(peak, data);
			}
		}

		private void LoadPeakData(Peaks peak, ISlotData data)
		{
			//IL_025a: Unknown result type (might be due to invalid IL or missing references)
			bool flag = data.HasPeak(peak);
			((Component)peaks[peak]).gameObject.SetActive(flag);
			if (!flag)
			{
				return;
			}
			Text component = ((Component)peaks[peak].FindDeep("PEAKNAME")).GetComponent<Text>();
			component.text = Mappings.GetPeakName(peak);
			bool flag2 = connection.HasLocation(LocationIDs.GetPeakLocationID(peak));
			bool flag3 = connection.HasLocation(LocationIDs.GetFSPeakLocationID(peak));
			bool flag4 = connection.HasLocation(LocationIDs.GetTATimePBLocationID(peak));
			bool flag5 = connection.HasLocation(LocationIDs.GetTAHoldsLocationID(peak));
			bool flag6 = connection.HasLocation(LocationIDs.GetTARopeLocationID(peak));
			Transform obj = peaks[peak].FindDeep("COMPLETIONCHECK");
			if (obj != null)
			{
				((Component)obj).gameObject.SetActive(flag2);
			}
			Transform obj2 = peaks[peak].FindDeep("FREESOLOCHECK");
			if (obj2 != null)
			{
				((Component)obj2).gameObject.SetActive(flag3);
			}
			CanvasGroup component2 = ((Component)peaks[peak].FindDeep("TIMECHECK")).gameObject.GetComponent<CanvasGroup>();
			CanvasGroup component3 = ((Component)peaks[peak].FindDeep("HOLDSCHECK")).gameObject.GetComponent<CanvasGroup>();
			CanvasGroup component4 = ((Component)peaks[peak].FindDeep("ROPESCHECK")).gameObject.GetComponent<CanvasGroup>();
			component2.alpha = (flag4 ? 1f : 0f);
			component3.alpha = (flag5 ? 1f : 0f);
			component4.alpha = (flag6 ? 1f : 0f);
			long[] array = Mappings.GetPeakLocations(peak).ToArray();
			int num = 0;
			long[] array2 = array;
			foreach (long v in array2)
			{
				if (!connection.HasLocation(v))
				{
					num++;
				}
			}
			((Component)peaks[peak].FindDeep("ARTEFACTCOUNT")).gameObject.GetComponent<Text>().text = num + "\n";
			if (flag2 && num == 0 && (flag3 || !Mappings.HasFreeSolo(peak) || !settings.includeFreeSolo) && ((flag4 && flag5 && flag6) || !Mappings.HasTimeAttack(peak) || !settings.includeTimeAttack))
			{
				((Graphic)component).color = Color.green;
			}
		}

		private void InitObjects()
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			books = new Dictionary<Books, Transform>();
			peaks = new Dictionary<Peaks, Transform>();
			foreach (Transform item in progressDisplayRoot)
			{
				Object.Destroy((Object)(object)((Component)item).gameObject);
			}
			foreach (Books value in Enum.GetValues(typeof(Books)))
			{
				CreateBookEntry(value);
			}
		}

		private void CreateBookEntry(Books book)
		{
			Transform transform = Object.Instantiate<GameObject>(PeaksOfAssets.BookEntryPrefab, progressDisplayRoot).transform;
			books.Add(book, transform);
			Transform val = transform.FindDeep("FREESOLO");
			if (Object.op_Implicit((Object)(object)val))
			{
				((Component)val).gameObject.SetActive(settings.includeFreeSolo);
			}
			else
			{
				Logger.LogWarning((object)"Couldn't find Free Solo column in book entry prefab");
			}
			Transform val2 = transform.FindDeep("TIMEATTACK");
			if (Object.op_Implicit((Object)(object)val2))
			{
				((Component)val2).gameObject.SetActive(settings.includeTimeAttack);
			}
			else
			{
				Logger.LogWarning((object)"Couldn't find Time Attack column in book entry prefab");
			}
			Transform parent = transform.FindDeep("ENTRYHOLDER");
			Peaks[] array = Mappings.GetBookPeaks(book).ToArray();
			foreach (Peaks peak in array)
			{
				CreatePeakEntry(peak, parent);
			}
		}

		private void CreatePeakEntry(Peaks peak, Transform parent)
		{
			Transform transform = Object.Instantiate<GameObject>(PeaksOfAssets.PeakEntryPrefab, parent).transform;
			peaks.Add(peak, transform);
			Transform val = transform.FindDeep("FREESOLO");
			if (Object.op_Implicit((Object)(object)val))
			{
				((Component)val).gameObject.SetActive(settings.includeFreeSolo);
				if (settings.includeFreeSolo)
				{
					(((Component)val).gameObject.GetComponent<CanvasGroup>() ?? ((Component)val).gameObject.AddComponent<CanvasGroup>()).alpha = (Mappings.HasFreeSolo(peak) ? 1f : 0f);
				}
			}
			else
			{
				Logger.LogWarning((object)"Couldn't find Free Solo column in book entry prefab");
			}
			Transform val2 = transform.FindDeep("TIMEATTACK");
			if (Object.op_Implicit((Object)(object)val2))
			{
				((Component)val2).gameObject.SetActive(settings.includeTimeAttack);
				if (settings.includeTimeAttack)
				{
					(((Component)val2).gameObject.GetComponent<CanvasGroup>() ?? ((Component)val2).gameObject.AddComponent<CanvasGroup>()).alpha = (Mappings.HasTimeAttack(peak) ? 1f : 0f);
				}
			}
			else
			{
				Logger.LogWarning((object)"Couldn't find Time Attack column in book entry prefab");
			}
		}

		[IteratorStateMachine(typeof(<ShowTutorial>d__19))]
		private IEnumerator ShowTutorial()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <ShowTutorial>d__19(0)
			{
				<>4__this = this
			};
		}
	}
	internal class TrapHandler : MonoBehaviour
	{
		[CompilerGenerated]
		private sealed class <TestTrap>d__14 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <TestTrap>d__14(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = null;
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					return false;
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		[CompilerGenerated]
		private sealed class <Timer>d__19 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public TrapHandler <>4__this;

			public string name;

			public float duration;

			public Action onEnd;

			private Transform <timer>5__2;

			private Slider <slider>5__3;

			private float <t>5__4;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <Timer>d__19(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<timer>5__2 = null;
				<slider>5__3 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_002a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0034: Expected O, but got Unknown
				int num = <>1__state;
				TrapHandler trapHandler = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (object)new WaitForEndOfFrame();
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<timer>5__2 = Object.Instantiate<GameObject>(PeaksOfAssets.TrapTimer, trapHandler.trapDisplay).transform;
					((Component)<timer>5__2.FindDeep("TRAPNAME")).GetComponent<Text>().text = name;
					<slider>5__3 = ((Component)<timer>5__2.FindDeep("SLIDER")).GetComponent<Slider>();
					<slider>5__3.normalizedValue = 1f;
					<t>5__4 = 0f;
					break;
				case 2:
					<>1__state = -1;
					break;
				}
				if (<t>5__4 <= 1f)
				{
					<t>5__4 += Time.deltaTime / duration;
					<slider>5__3.normalizedValue = 1f - <t>5__4;
					<>2__current = null;
					<>1__state = 2;
					return true;
				}
				Object.Destroy((Object)(object)((Component)<timer>5__2).gameObject);
				onEnd?.Invoke();
				return false;
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		public static TrapHandler Instance;

		private ManualLogSource logger;

		private Transform trapDisplay;

		private List<Trap> traps;

		private Bird hunter;

		private Bird crow;

		private OilLamp oilLamp;

		private EnterPeakScene peakEntry;

		private GameObject[] holds;

		private string[] holdNames;

		private RopeAnchor ropeAnchor;

		private CoffeeDrink coffeeDrink;

		private ChalkBag chalkBag;

		private bool holdsTrapRunning;

		[IteratorStateMachine(typeof(<TestTrap>d__14))]
		private IEnumerator TestTrap()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <TestTrap>d__14(0);
		}

		public void Awake()
		{
			if ((Object)(object)Instance != (Object)null)
			{
				Object.Destroy((Object)(object)this);
				return;
			}
			Instance = this;
			logger = PeaksOfArchipelago.Logger;
			logger.LogInfo((object)"Trap handler initialising");
			oilLamp = Object.FindObjectOfType<OilLamp>();
			GameObject obj = GameObject.Find("Seabird_Hunter");
			hunter = ((obj != null) ? obj.GetComponent<Bird>() : null);
			GameObject obj2 = GameObject.Find("CrowBird_Hunter");
			crow = ((obj2 != null) ? obj2.GetComponent<Bird>() : null);
			peakEntry = Object.FindObjectOfType<EnterPeakScene>();
			holds = GameObject.FindGameObjectsWithTag("Climbable");
			holdNames = new string[holds.Length];
			ropeAnchor = Object.FindObjectOfType<RopeAnchor>();
			coffeeDrink = Object.FindObjectOfType<CoffeeDrink>();
			chalkBag = Object.FindObjectOfType<ChalkBag>();
			for (int i = 0; i < holds.Length; i++)
			{
				holdNames[i] = ((Object)holds[i]).name;
			}
			Trap item = new TimedTrap("Eclipse", "The moon briefly obscures the sun.", delegate
			{
				GameManager.control.alps_statue_sundown_InUse = !GameManager.control.alps_statue_sundown_InUse;
				peakEntry.PublicSetSundown();
				GameManager.control.alps_statue_sundown_InUse = !GameManager.control.alps_statue_sundown_InUse;
				if (Connection.Instance.slotData.HasTool(Tools.Lamp))
				{
					oilLamp.lampObj.SetActive(true);
					((MonoBehaviour)oilLamp).StartCoroutine("StartOilLamp", (object)false);
				}
			}, delegate
			{
				peakEntry.PublicSetSundown();
			}, 60f, () => (Object)(object)oilLamp != (Object)null && (Object)(object)peakEntry != (Object)null);
			Trap item2 = new TimedTrap("Bird Attack!", "You've stirred the nest.", delegate
			{
				((Component)hunter).gameObject.SetActive(true);
				((Component)crow).gameObject.SetActive(true);
				hunter.InitiateBird();
				crow.InitiateBird();
			}, delegate
			{
				((Component)hunter).gameObject.SetActive(false);
				((Component)crow).gameObject.SetActive(false);
			}, 30f);
			Trap item3 = new TimedTrap("Feeling heavy", "How much porridge did ye have for breakfast", delegate
			{
				//IL_000f: Unknown result type (might be due to invalid IL or missing references)
				Physics.gravity = new Vector3(0f, -10.692901f, 0f);
			}, delegate
			{
				//IL_000f: Unknown result type (might be due to invalid IL or missing references)
				Physics.gravity = new Vector3(0f, -9.81f, 0f);
			}, 30f);
			Trap item4 = new TimedTrap("Oops, all crimps!", "The holds feel small today", delegate
			{
				holdsTrapRunning = true;
				for (int num = 0; num < holds.Length; num++)
				{
					if (!((Object)holds[num]).name.StartsWith("ClimbableSloper_"))
					{
						holds[num].tag = "ClimbableMicroHold";
					}
				}
			}, delegate
			{
				for (int n = 0; n < holds.Length; n++)
				{
					if (((Object)holds[n]).name.StartsWith("ClimbableSloper_"))
					{
						holds[n].tag = "Climbable";
					}
				}
				holdsTrapRunning = false;
			}, 15f, () => !holdsTrapRunning);
			Trap item5 = new TimedTrap("Oops, all slopers!", "You feel your hands sweating profusely", delegate
			{
				holdsTrapRunning = true;
				for (int m = 0; m < holds.Length; m++)
				{
					if (!((Object)holds[m]).name.StartsWith("ClimbableSloper_"))
					{
						((Object)holds[m]).name = "ClimbableSloper_Easy";
					}
				}
			}, delegate
			{
				for (int l = 0; l < holds.Length; l++)
				{
					((Object)holds[l]).name = holdNames[l];
				}
				holdsTrapRunning = false;
			}, 15f, () => !holdsTrapRunning);
			Trap item6 = new TimedTrap("Oops, all pitches!", "Your fingers are tiring", delegate
			{
				holdsTrapRunning = true;
				for (int k = 0; k < holds.Length; k++)
				{
					holds[k].tag = "ClimbablePitch";
				}
			}, delegate
			{
				for (int j = 0; j < holds.Length; j++)
				{
					holds[j].tag = "Climbable";
				}
				holdsTrapRunning = false;
			}, 15f, () => !holdsTrapRunning);
			Trap item7 = new InstantTrap("A rope slipped off of your body, -1 rope", delegate
			{
				RopeAnchor obj6 = ropeAnchor;
				obj6.anchorsInBackpack--;
			}, () => ropeAnchor.anchorsInBackpack > 0);
			Trap item8 = new InstantTrap("You found a leak in your coffee bottle, -1 coffee", delegate
			{
				CoffeeDrink obj5 = coffeeDrink;
				obj5.coffeeSipsLeft--;
			}, () => coffeeDrink.coffeeSipsLeft > 0);
			Trap item9 = new InstantTrap("There was a hole in your chalk bag, -1 chalk", delegate
			{
				ChalkBag obj4 = chalkBag;
				obj4.chalkBagUsesLeft--;
			}, () => chalkBag.chalkBagUsesLeft > 0);
			Trap item10 = new InstantTrap("There was a hole in your seeds bag, -1 seed use", delegate
			{
				ChalkBag obj3 = chalkBag;
				obj3.birdseedsUsesLeft--;
			}, () => chalkBag.birdseedsUsesLeft > 0);
			traps = new List<Trap>(10) { item, item2, item3, item4, item5, item6, item7, item8, item9, item10 };
		}

		public void OnDestroy()
		{
			if ((Object)(object)Instance == (Object)(object)this)
			{
				Instance = null;
			}
		}

		public void StartRandomTrap()
		{
			List<Trap> list = traps.Where((Trap t) => t.IsAvailable()).ToList();
			if (list.Count == 0)
			{
				logger.LogInfo((object)"No traps available");
				return;
			}
			Trap trap = list[Random.Range(0, list.Count)];
			PeaksOfArchipelago.ui.SendNotification(trap.Message);
			trap.Execute(this);
		}

		internal void StartTimer(string name, float duration, Action onEnd)
		{
			trapDisplay = PeaksOfArchipelago.ui.trapDisplay.transform;
			((MonoBehaviour)this).StartCoroutine(Timer(name, duration, onEnd));
		}

		[IteratorStateMachine(typeof(<Timer>d__19))]
		private IEnumerator Timer(string name, float duration, Action onEnd)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <Timer>d__19(0)
			{
				<>4__this = this,
				name = name,
				duration = duration,
				onEnd = onEnd
			};
		}
	}
	internal class ChatBox : MonoBehaviour
	{
		private ManualLogSource logger;

		private Canvas canvas;

		private GameObject chatBoxRoot;

		private Transform messageHolder;

		private Queue<string> messageQueue = new Queue<string>();

		public void Awake()
		{
			logger = PeaksOfArchipelago.Logger;
		}

		public void Update()
		{
			while (messageQueue.Count > 0)
			{
				Create(messageQueue.Dequeue());
			}
		}

		public void Initialize(Canvas c)
		{
			canvas = c;
			CreateChatBox();
		}

		private void CreateChatBox()
		{
			if ((Object)(object)canvas == (Object)null)
			{
				logger.LogError((object)"Canvas not found!");
				return;
			}
			chatBoxRoot = Object.Instantiate<GameObject>(PeaksOfAssets.ChatBoxPrefab, ((Component)canvas).transform, false);
			messageHolder = chatBoxRoot.transform.GetChild(0);
		}

		public void Create(string message)
		{
			if (!((Object)(object)messageHolder == (Object)null))
			{
				logger.LogInfo((object)("AddChatMessage: " + message));
				Object.Instantiate<GameObject>(PeaksOfAssets.ChatMessagePrefab, messageHolder).GetComponentInChildren<Text>().text = message;
			}
		}

		public void AddChatMessage(string message)
		{
			messageQueue.Enqueue(message);
		}
	}
}
namespace PeaksOfArchipelago.GameData
{
	internal abstract class ArchipelagoItem
	{
		public readonly string name;

		public ArchipelagoItem(ItemInfo info)
		{
			name = info.ItemName;
		}

		public static ArchipelagoItem Create(ItemInfo item)
		{
			ItemTypes.Types itemType = ItemTypes.GetItemType(item.ItemId);
			return itemType switch
			{
				ItemTypes.Types.Peak => new PeakItem(item), 
				ItemTypes.Types.Rope => new RopeItem(item), 
				ItemTypes.Types.Artefact => new ArtefactItem(item), 
				ItemTypes.Types.Book => new BookItem(item), 
				ItemTypes.Types.BirdSeed => new BirdSeedItem(item), 
				ItemTypes.Types.Tool => new ToolItem(item), 
				ItemTypes.Types.ExtraItem => new ExtraItem(item), 
				ItemTypes.Types.AlpIdol => new IdolItem(item), 
				_ => throw new NotImplementedException($"Item type {itemType} Should not exist"), 
			};
		}

		public abstract void Unlock(ISlotData slotData);
	}
	internal class IdolItem : ArchipelagoItem
	{
		public Idols idol;

		public IdolItem(ItemInfo info)
			: base(info)
		{
			idol = ItemIDs.GetIdolFromId(info.ItemId);
		}

		public override void Unlock(ISlotData slotData)
		{
			slotData.receiveIdol(idol);
		}
	}
	internal class ExtraItem : ArchipelagoItem
	{
		public ExtraItems item;

		public ExtraItem(ItemInfo info)
			: base(info)
		{
			item = ItemIDs.GetExtraItemFromId(info.ItemId);
		}

		public override void Unlock(ISlotData slotData)
		{
			slotData.ExtraItemReceived(item);
			switch (item)
			{
			case ExtraItems.ExtraRope:
			{
				GameManager control4 = GameManager.control;
				control4.ropesCollected++;
				GameManager control5 = GameManager.control;
				control5.ropesCollected++;
				break;
			}
			case ExtraItems.ExtraChalk:
			{
				GameManager control3 = GameManager.control;
				control3.extraChalkUses++;
				break;
			}
			case ExtraItems.ExtraCoffee:
			{
				GameManager control2 = GameManager.control;
				control2.extraCoffeeUses++;
				break;
			}
			case ExtraItems.ExtraSeed:
			{
				GameManager control = GameManager.control;
				control.extraBirdSeedUses++;
				break;
			}
			}
			GameManager.control.Save();
		}
	}
	internal class BirdSeedItem : ArchipelagoItem
	{
		private BirdSeeds birdSeed;

		public BirdSeedItem(ItemInfo info)
			: base(info)
		{
			birdSeed = ItemIDs.GetBirdSeedFromId(info.ItemId);
		}

		public override void Unlock(ISlotData slotData)
		{
			slotData.RecieveBirdSeed(birdSeed);
			GameManager control = GameManager.control;
			control.extraBirdSeedUses++;
			GameManager.control.Save();
		}
	}
	internal class BookItem : ArchipelagoItem
	{
		private Books book;

		public BookItem(ItemInfo info)
			: base(info)
		{
			book = ItemIDs.GetBookFromId(info.ItemId);
		}

		public override void Unlock(ISlotData slotData)
		{
			slotData.RecieveBook(book);
		}
	}
	internal class ArtefactItem : ArchipelagoItem
	{
		private Artefacts artefact;

		public ArtefactItem(ItemInfo info)
			: base(info)
		{
			artefact = ItemIDs.GetArtefactFromID(info.ItemId);
		}

		public override void Unlock(ISlotData slotData)
		{
			slotData.RecieveArtefact(artefact);
			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;
			}
			}
			GameManager.control.Save();
		}
	}
	internal class ToolItem : ArchipelagoItem
	{
		private Tools tool;

		public ToolItem(ItemInfo info)
			: base(info)
		{
			tool = ItemIDs.GetToolFromID(info.ItemId);
		}

		public override void Unlock(ISlotData slotData)
		{
			slotData.ReceiveTool(tool);
			switch (tool)
			{
			case Tools.Pipe:
				GameManager.control.smokingpipe = true;
				break;
			case Tools.RopeLengthUpgrade:
				GameManager.control.ropesUpgrade = true;
				break;
			case Tools.Barometer:
				GameManager.control.barometer = true;
				GameManager.control.artefactMap = true;
				break;
			case Tools.ProgressiveCrampons:
				GameManager.control.crampons = true;
				if (slotData.cramponLevel == 0)
				{
					GameManager.control.crampons = true;
					slotData.cramponLevel = 1;
					PeaksOfArchipelago.Logger.LogInfo((object)"Crampons level set to 1");
				}
				else if (slotData.cramponLevel == 1)
				{
					PeaksOfArchipelago.Logger.LogInfo((object)"Crampons level set to 2");
					PlayerPrefs.SetInt("UseBasicCrampons", 0);
					GameManager.control.cramponsUpgrade = true;
					slotData.cramponLevel = 2;
				}
				break;
			case Tools.Monocular:
				GameManager.control.monocular = true;
				break;
			case Tools.Phonograph:
				GameManager.control.phonograph = true;
				break;
			case Tools.Pocketwatch:
				GameManager.control.pocketwatch = true;
				break;
			case Tools.Chalkbag:
				GameManager.control.chalkBag = true;
				break;
			case Tools.Rope:
				GameManager.control.rope = true;
				break;
			case Tools.Coffee:
				GameManager.control.coffee = true;
				break;
			case Tools.IceAxes:
				GameManager.control.iceAxes = true;
				break;
			}
			GameManager.control.Save();
		}
	}
	internal class RopeItem : ArchipelagoItem
	{
		public Ropes Rope { get; private set; }

		public RopeItem(ItemInfo info)
			: base(info)
		{
			Rope = ItemIDs.GetRopeFromID(info.ItemId);
		}

		public override void Unlock(ISlotData slotData)
		{
			if (slotData.ropeUnlockMode == SessionSettings.RopeUnlockMode.INSTANT)
			{
				slotData.ReceiveTool(Tools.Rope);
				GameManager.control.rope = true;
			}
			slotData.RecieveRope(Rope);
			if (Rope < Ropes.ExtraFirst)
			{
				GameManager control = GameManager.control;
				control.ropesCollected++;
			}
			else
			{
				GameManager control2 = GameManager.control;
				control2.ropesCollected += 2;
			}
			GameManager.control.Save();
		}
	}
	internal class PeakItem : ArchipelagoItem
	{
		public Peaks Peak { get; private set; }

		public PeakItem(ItemInfo info)
			: base(info)
		{
			Peak = ItemIDs.GetPeakFromID(info.ItemId);
		}

		public override void Unlock(ISlotData slotData)
		{
			slotData.RecievePeak(Peak);
		}
	}
	internal class Offsets
	{
		public const int PeakIDOffset = 1;

		public const int RopeIDOffset = 1000;

		public const int ArtefactIDOffset = 2000;

		public const int BookIDOffset = 3000;

		public const int BirdSeedIDOffset = 4000;

		public const int ToolIDOffset = 5000;

		public const int ExtraItemIDOffset = 6000;

		public const int FreeSoloPeakIDOffset = 7000;

		public const int TATimeIDOffset = 8000;

		public const int TARopeIDOffset = 9000;

		public const int TAHoldsIDOffset = 10000;

		public const int AlpIdolIDOffset = 11000;

		public const int MermaidIDOffset = 12000;
	}
	internal class ItemTypes
	{
		public enum Types
		{
			Peak = 1,
			Rope,
			Artefact,
			Book,
			BirdSeed,
			Tool,
			ExtraItem,
			FreeSoloPeak,
			TATime,
			TARope,
			TAHolds,
			AlpIdol,
			Mermaid
		}

		public static Types GetItemType(long itemID)
		{
			if (itemID >= 12000)
			{
				return Types.Mermaid;
			}
			if (itemID >= 11000)
			{
				return Types.AlpIdol;
			}
			if (itemID >= 10000)
			{
				return Types.TAHolds;
			}
			if (itemID >= 9000)
			{
				return Types.TARope;
			}
			if (itemID >= 8000)
			{
				return Types.TATime;
			}
			if (itemID >= 7000)
			{
				return Types.FreeSoloPeak;
			}
			if (itemID >= 6000)
			{
				return Types.ExtraItem;
			}
			if (itemID >= 5000)
			{
				return Types.Tool;
			}
			if (itemID >= 4000)
			{
				return Types.BirdSeed;
			}
			if (itemID >= 3000)
			{
				return Types.Book;
			}
			if (itemID >= 2000)
			{
				return Types.Artefact;
			}
			if (itemID >= 1000)
			{
				return Types.Rope;
			}
			return Types.Peak;
		}

		public static Peaks PeakfromStamper(PeakNames peakName)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0004: Expected I4, but got Unknown
			int num = peakName - 1;
			if (num >= 36)
			{
				num--;
			}
			return (Peaks)num;
		}
	}
	internal class ItemIDs
	{
		public static Peaks GetPeakFromID(long itemID)
		{
			return (Peaks)(itemID - 1);
		}

		public static Ropes GetRopeFromID(long itemID)
		{
			return (Ropes)(itemID - 1000);
		}

		internal static Tools GetToolFromID(long itemId)
		{
			return (Tools)(itemId - 5000);
		}

		internal static Artefacts GetArtefactFromID(long itemId)
		{
			return (Artefacts)(itemId - 2000);
		}

		internal static Books GetBookFromId(long itemId)
		{
			return (Books)(itemId - 3000);
		}

		internal static BirdSeeds GetBirdSeedFromId(long itemId)
		{
			return (BirdSeeds)(itemId - 4000);
		}

		internal static ExtraItems GetExtraItemFromId(long itemId)
		{
			return (ExtraItems)(itemId - 6000);
		}

		internal static Idols GetIdolFromId(long itemId)
		{
			return (Idols)(itemId - 11000);
		}
	}
	internal class LocationIDs
	{
		internal static long GetPeakLocationID(Peaks peak)
		{
			return (long)peak + 1L;
		}

		internal static long GetFSPeakLocationID(Peaks peak)
		{
			return (long)peak + 7000L;
		}

		internal static long GetRopeLocationID(Ropes rope)
		{
			return (long)rope + 1000L;
		}

		internal static long GetToolLocationID(Tools tool)
		{
			return (long)tool + 5000L;
		}

		internal static long GetArtefactLocationID(Artefacts artefact)
		{
			return (long)artefact + 2000L;
		}

		internal static long GetBirdSeedLocationID(BirdSeeds seed)
		{
			return (long)seed + 4000L;
		}

		internal static long GetTATimePBLocationID(Peaks peak)
		{
			return (long)peak + 8000L;
		}

		internal static long GetTARopeLocationID(Peaks peak)
		{
			return (long)peak + 9000L;
		}

		internal static long GetTAHoldsLocationID(Peaks peak)
		{
			return (long)peak + 10000L;
		}

		internal static long GetMermaidLocationID(Mermaids mermaid)
		{
			return (long)mermaid + 12000L;
		}
	}
	internal static class Mappings
	{
		private static readonly Dictionary<Books, string> bookNames = new Dictionary<Books, string>
		{
			{
				Books.Fundamentals,
				"Fundamentals"
			},
			{
				Books.Intermediate,
				"Intermediate"
			},
			{
				Books.Advanced,
				"Advanced"
			},
			{
				Books.Expert,
				"Expert"
			},
			{
				Books.Essentials,
				"Essentials"
			},
			{
				Books.AlpineGreats,
				"Alpine Greats"
			},
			{
				Books.ArduousArctic,
				"Arduous & Arctic"
			}
		};

		private static readonly Dictionary<Books, List<Peaks>> BookPeakMappings = new Dictionary<Books, List<Peaks>>
		{
			{
				Books.Fundamentals,
				new List<Peaks>
				{
					Peaks.GreenhornsTop,
					Peaks.PaltryPeak,
					Peaks.OldMill,
					Peaks.GrayGully,
					Peaks.Lighthouse,
					Peaks.OldManOfSjor,
					Peaks.GiantsShelf,
					Peaks.EvergreensEnd,
					Peaks.TheTwins,
					Peaks.OldGrovesSkelf,
					Peaks.HangmansLeap,
					Peaks.LandsEnd,
					Peaks.OldLangr,
					Peaks.AldrGrotto,
					Peaks.ThreeBrothers,
					Peaks.WaltersCrag,
					Peaks.GreatCrevice,
					Peaks.OldHagger,
					Peaks.UgsomeStorr,
					Peaks.WutheringCrest
				}
			},
			{
				Books.Intermediate,
				new List<Peaks>
				{
					Peaks.PortersBoulders,
					Peaks.JotunnsThumb,
					Peaks.OldSkerry,
					Peaks.HamarrStone,
					Peaks.GiantsNose,
					Peaks.WaltersBoulder,
					Peaks.SunderedSons,
					Peaks.OldWealdsBoulder,
					Peaks.LeaningSpire,
					Peaks.Cromlech
				}
			},
			{
				Books.Advanced,
				new List<Peaks>
				{
					Peaks.WalkersPillar,
					Peaks.GreatGaol,
					Peaks.Eldenhorn,
					Peaks.StHaelga,
					Peaks.YmirsShadow
				}
			},
			{
				Books.Expert,
				new List<Peaks>
				{
					Peaks.GreatBulwark,
					Peaks.SolemnTempest
				}
			},
			{
				Books.Essentials,
				new List<Peaks>
				{
					Peaks.TutorTower,
					Peaks.StougrBoulder,
					Peaks.MarasArch,
					Peaks.GrainneSpire,
					Peaks.GreatBokTree,
					Peaks.Treppenwald,
					Peaks.CastleoftheSwanKing,
					Peaks.SeasideTribune,
					Peaks.IvoryGranites,
					Peaks.OldRekkja,
					Peaks.Quietude,
					Peaks.EljunsFolly
				}
			},
			{
				Books.AlpineGreats,
				new List<Peaks>
				{
					Peaks.EinvaldFalls,
					Peaks.AlmattrDam,
					Peaks.Dunderhorn,
					Peaks.MhorDruim,
					Peaks.WelkinPass
				}
			},
			{
				Books.ArduousArctic,
				new List<Peaks>
				{
					Peaks.SeigrCraeg,
					Peaks.UllrsChasm,
					Peaks.GreatSilf,
					Peaks.ToweringVisir,
					Peaks.EldrisWall,
					Peaks.MountMhorgorm
				}
			}
		};

		private static readonly Dictionary<Peaks, List<long>> PeakIdMappings = new Dictionary<Peaks, List<long>>
		{
			{
				Peaks.OldMill,
				new List<long> { LocationIDs.GetArtefactLocationID(Artefacts.Hat1) }
			},
			{
				Peaks.GrayGully,
				new List<long> { LocationIDs.GetArtefactLocationID(Artefacts.Photograph_1) }
			},
			{
				Peaks.OldManOfSjor,
				new List<long>
				{
					LocationIDs.GetArtefactLocationID(Artefacts.Shoe),
					LocationIDs.GetRopeLocationID(Ropes.ExtraFirst)
				}
			},
			{
				Peaks.GiantsShelf,
				new List<long> { LocationIDs.GetArtefactLocationID(Artefacts.Sleepingbag) }
			},
			{
				Peaks.EvergreensEnd,
				new List<long>
				{
					LocationIDs.GetArtefactLocationID(Artefacts.Hat2),
					LocationIDs.GetRopeLocationID(Ropes.Extra10)
				}
			},
			{
				Peaks.OldGrovesSkelf,
				new List<long> { LocationIDs.GetArtefactLocationID(Artefacts.Helmet) }
			},
			{
				Peaks.LandsEnd,
				new List<long>
				{
					LocationIDs.GetArtefactLocationID(Artefacts.Photograph_2),
					LocationIDs.GetRopeLocationID(Ropes.Extra9)
				}
			},
			{
				Peaks.HangmansLeap,
				new List<long> { LocationIDs.GetRopeLocationID(Ropes.ExtraSecond) }
			},
			{
				Peaks.OldLangr,
				new List<long> { LocationIDs.GetArtefactLocationID(Artefacts.Coffebox_1) }
			},
			{
				Peaks.AldrGrotto,
				new List<long> { LocationIDs.GetArtefactLocationID(Artefacts.Backpack) }
			},
			{
				Peaks.ThreeBrothers,
				new List<long>
				{
					LocationIDs.GetArtefactLocationID(Artefacts.Shovel),
					LocationIDs.GetBirdSeedLocationID(BirdSeeds.ExtraSeed1)
				}
			},
			{
				Peaks.WaltersCrag,
				new List<long>
				{
					LocationIDs.GetArtefactLocationID(Artefacts.ClimberStatue0),
					LocationIDs.GetRopeLocationID(Ropes.WaltersCrag),
					LocationIDs.GetRopeLocationID(Ropes.Extra8)
				}
			},
			{
				Peaks.GreatCrevice,
				new List<long>
				{
					LocationIDs.GetArtefactLocationID(Artefacts.Photograph_3),
					LocationIDs.GetRopeLocationID(Ropes.Extra11)
				}
			},
			{
				Peaks.OldHagger,
				new List<long> { LocationIDs.GetRopeLocationID(Ropes.Extra12) }
			},
			{
				Peaks.UgsomeStorr,
				new List<long> { LocationIDs.GetRopeLocationID(Ropes.ExtraThird) }
			},
			{
				Peaks.WutheringCrest,
				new List<long>
				{
					LocationIDs.GetArtefactLocationID(Artefacts.Coffebox_2),
					LocationIDs.GetRopeLocationID(Ropes.Extra6)
				}
			},
			{
				Peaks.OldSkerry,
				new List<long> { LocationIDs.GetBirdSeedLocationID(BirdSeeds.ExtraSeed2) }
			},
			{
				Peaks.LeaningSpire,
				new List<long> { LocationIDs.GetArtefactLocationID(Artefacts.ClimberStatue1) }
			},
			{
				Peaks.WalkersPillar,
				new List<long>
				{
					LocationIDs.GetRopeLocationID(Ropes.WalkersPillar),
					LocationIDs.GetArtefactLocationID(Artefacts.Chalkbox_1)
				}
			},
			{
				Peaks.Eldenhorn,
				new List<long>
				{
					LocationIDs.GetArtefactLocationID(Artefacts.Chalkbox_2),
					LocationIDs.GetRopeLocationID(Ropes.ExtraFourth),
					LocationIDs.GetBirdSeedLocationID(BirdSeeds.ExtraSeed4)
				}
			},
			{
				Peaks.GreatGaol,
				new List<long>
				{
					LocationIDs.GetArtefactLocationID(Artefacts.PhotographFrame),
					LocationIDs.GetRopeLocationID(Ropes.GreatGaol),
					LocationIDs.GetRopeLocationID(Ropes.Extra7),
					LocationIDs.GetBirdSeedLocationID(BirdSeeds.ExtraSeed3)
				}
			},
			{
				Peaks.StHaelga,
				new List<long>
				{
					LocationIDs.GetRopeLocationID(Ropes.StHaelga),
					LocationIDs.GetArtefactLocationID(Artefacts.Photograph_4)
				}
			},
			{
				Peaks.YmirsShadow,
				new List<long>
				{
					LocationIDs.GetArtefactLocationID(Artefacts.ClimberStatue2),
					LocationIDs.GetRopeLocationID(Ropes.Extra5),
					LocationIDs.GetBirdSeedLocationID(BirdSeeds.ExtraSeed5)
				}
			},
			{
				Peaks.GreatBulwark,
				new List<long> { LocationIDs.GetArtefactLocationID(Artefacts.ClimberStatue3) }
			},
			{
				Peaks.MarasArch,
				new List<long> { LocationIDs.GetArtefactLocationID(Artefacts.Alps_Gentiana1) }
			},
			{
				Peaks.GrainneSpire,
				new List<long> { LocationIDs.GetArtefactLocationID(Artefacts.Alps_Idol_crimpsPt1) }
			},
			{
				Peaks.GreatBokTree,
				new List<long>
				{
					LocationIDs.GetArtefactLocationID(Artefacts.Alps_Idol_crimpsPt2),
					LocationIDs.GetArtefactLocationID(Artefacts.Alps_Edelweiss2)
				}
			},
			{
				Peaks.Treppenwald,
				new List<long>
				{
					LocationIDs.GetArtefactLocationID(Artefacts.Alps_Gentiana2),
					LocationIDs.GetArtefactLocationID(Artefacts.Alps_Idol_seedsPt1)
				}
			},
			{
				Peaks.CastleoftheSwanKing,
				new List<long>
				{
					LocationIDs.GetArtefactLocationID(Artefacts.Alps_Edelweiss3),
					LocationIDs.GetArtefactLocationID(Artefacts.Alps_Idol_slopersPt1),
					LocationIDs.GetArtefactLocationID(Artefacts.Alps_Idol_sundownPt1),
					LocationIDs.GetArtefactLocationID(Artefacts.Alps_Idol_pitchesPt1)
				}
			},
			{
				Peaks.SeasideTribune,
				new List<long> { LocationIDs.GetArtefactLocationID(Artefacts.Alps_Idol_pinchesPt2) }
			},
			{
				Peaks.IvoryGranites,
				new List<long>
				{
					LocationIDs.GetArtefactLocationID(Artefacts.Alps_Edelweiss4),
					LocationIDs.GetArtefactLocationID(Artefacts.Alps_Idol_gravityPt2)
				}
			},
			{
				Peaks.OldRekkja,
				new List<long> { LocationIDs.GetArtefactLocationID(Artefacts.Alps_Idol_slopersPt2) }
			},
			{
				Peaks.Quietude,
				new List<long> { LocationIDs.GetArtefactLocationID(Artefacts.Alps_Gentiana4) }
			},
			{
				Peaks.EljunsFolly,
				new List<long>
				{
					LocationIDs.GetArtefactLocationID(Artefacts.Alps_Gentiana3),
					LocationIDs.GetArtefactLocationID(Artefacts.Alps_Idol_pitchesPt2)
				}
			},
			{
				Peaks.EinvaldFalls,
				new List<long> { LocationIDs.GetArtefactLocationID(Artefacts.Alps_Gentiana5) }
			},
			{
				Peaks.AlmattrDam,
				new List<long>()
			},
			{
				Peaks.Dunderhorn,
				new List<long>
				{
					LocationIDs.GetArtefactLocationID(Artefacts.Alps_Edelweiss7),
					LocationIDs.GetArtefactLocationID(Artefacts.Alps_Idol_sundownPt2)
				}
			},
			{
				Peaks.MhorDruim,
				new List<long>
				{
					LocationIDs.GetArtefactLocationID(Artefacts.Alps_Gentiana6),
					LocationIDs.GetArtefactLocationID(Artefacts.Alps_Idol_feathersPt1),
					LocationIDs.GetArtefactLocationID(Artefacts.Alps_Idol_icePt1)
				}
			},
			{
				Peaks.WelkinPass,
				new List<long>
				{
					LocationIDs.GetArtefactLocationID(Artefacts.Alps_Edelweiss6),
					LocationIDs.GetArtefactLocationID(Artefacts.Alps_Idol_feathersPt2)
				}
			},
			{
				Peaks.SeigrCraeg,
				new List<long>()
			},
			{
				Peaks.UllrsChasm,
				new List<long> { LocationIDs.GetArtefactLocationID(Artefacts.Alps_Idol_greaterbalancePt2) }
			},
			{
				Peaks.GreatSilf,
				new List<long>()
			},
			{
				Peaks.ToweringVisir,
				new List<long>
				{
					LocationIDs.GetArtefactLocationID(Artefacts.Alps_Edelweiss1),
					LocationIDs.GetArtefactLocationID(Artefacts.Alps_Gentiana7),
					LocationIDs.GetArtefactLocationID(Artefacts.Alps_Idol_greaterbalancePt1),
					LocationIDs.GetArtefactLocationID(Artefacts.Alps_Idol_pinchesPt1)
				}
			},
			{
				Peaks.EldrisWall,
				new List<long>
				{
					LocationIDs.GetArtefactLocationID(Artefacts.Alps_Edelweiss5),
					LocationIDs.GetArtefactLocationID(Artefacts.Alps_Idol_icePt2),
					LocationIDs.GetArtefactLocationID(Artefacts.Alps_Idol_seedsPt2)
				}
			},
			{
				Peaks.MountMhorgorm,
				new List<long> { LocationIDs.GetArtefactLocationID(Artefacts.Alps_Idol_gravityPt1) }
			}
		};

		private static readonly HashSet<Peaks> FSPeaks = new HashSet<Peaks>
		{
			Peaks.WalkersPillar,
			Peaks.Eldenhorn,
			Peaks.GreatGaol,
			Peaks.StHaelga,
			Peaks.YmirsShadow,
			Peaks.GreatBulwark,
			Peaks.SolemnTempest,
			Peaks.EinvaldFalls,
			Peaks.AlmattrDam,
			Peaks.Dunderhorn,
			Peaks.MhorDruim,
			Peaks.WelkinPass,
			Peaks.SeigrCraeg,
			Peaks.UllrsChasm,
			Peaks.GreatSilf,
			Peaks.ToweringVisir,
			Peaks.EldrisWall,
			Peaks.MountMhorgorm
		};

		private static readonly HashSet<Peaks> NoTAPeaks = new HashSet<Peaks>
		{
			Peaks.GreatBulwark,
			Peaks.SolemnTempest
		};

		public static string GetBookName(Books book)
		{
			return bookNames[book];
		}

		public static string GetPeakName(Peaks peak)
		{
			return Regex.Replace(peak.ToString(), "(\\B[A-Z])", " $1");
		}

		public static List<Peaks> GetBookPeaks(Books book)
		{
			return BookPeakMappings[book];
		}

		public static List<long> GetPeakLocations(Peaks peak)
		{
			if (!PeakIdMappings.ContainsKey(peak))
			{
				return new List<long>();
			}
			return PeakIdMappings[peak];
		}

		public static bool HasFreeSolo(Peaks peak)
		{
			return FSPeaks.Contains(peak);
		}

		public static bool HasTimeAttack(Peaks peak)
		{
			return !NoTAPeaks.Contains(peak);
		}

		public static Books GetPeakBook(Peaks peak)
		{
			foreach (Books value in Enum.GetValues(typeof(Books)))
			{
				if (BookPeakMappings[value].Contains(peak))
				{
					return value;
				}
			}
			throw new Exception("Peak not found");
		}
	}
	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,
		TutorTower,
		StougrBoulder,
		MarasArch,
		GrainneSpire,
		GreatBokTree,
		Treppenwald,
		CastleoftheSwanKing,
		SeasideTribune,
		IvoryGranites,
		OldRekkja,
		Quietude,
		EljunsFolly,
		EinvaldFalls,
		AlmattrDam,
		Dunderhorn,
		MhorDruim,
		WelkinPass,
		SeigrCraeg,
		UllrsChasm,
		GreatSilf,
		ToweringVisir,
		EldrisWall,
		MountMhorgorm
	}
	public enum Ropes
	{
		WaltersCrag,
		WalkersPillar,
		GreatGaol,
		StHaelga,
		ExtraFirst,
		ExtraSecond,
		ExtraThird,
		ExtraFourth,
		Extra5,
		Extra6,
		Extra7,
		Extra8,
		Extra9,
		Extra10,
		Extra11,
		Extra12
	}
	public enum Tools
	{
		Pipe,
		RopeLengthUpgrade,
		Barometer,
		ProgressiveCrampons,
		Monocular,
		Phonograph,
		Pocketwatch,
		Chalkbag,
		Rope,
		Coffee,
		Lamp,
		leftHand,
		RightHand,
		IceAxes,
		AlpsTicket
	}
	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,
		Alps_Idol_crimpsPt1,
		Alps_Idol_crimpsPt2,
		Alps_Idol_slopersPt1,
		Alps_Idol_slopersPt2,
		Alps_Idol_feathersPt1,
		Alps_Idol_feathersPt2,
		Alps_Idol_pitchesPt1,
		Alps_Idol_pitchesPt2,
		Alps_Idol_icePt1,
		Alps_Idol_icePt2,
		Alps_Idol_pinchesPt1,
		Alps_Idol_pinchesPt2,
		Alps_Idol_greaterbalancePt1,
		Alps_Idol_greaterbalancePt2,
		Alps_Idol_sundownPt1,
		Alps_Idol_sundownPt2,
		Alps_Idol_seedsPt1,
		Alps_Idol_seedsPt2,
		Alps_Idol_gravityPt1,
		Alps_Idol_gravityPt2,
		Alps_Gentiana1,
		Alps_Gentiana2,
		Alps_Gentiana3,
		Alps_Gentiana4,
		Alps_Gentiana5,
		Alps_Gentiana6,
		Alps_Gentiana7,
		Alps_Edelweiss1,
		Alps_Edelweiss2,
		Alps_Edelweiss3,
		Alps_Edelweiss4,
		Alps_Edelweiss5,
		Alps_Edelweiss6,
		Alps_Edelweiss7
	}
	public enum Idols
	{
		Crimps,
		Slopers,
		Feathers,
		Pitches,
		Ice,
		Pinches,
		GreaterBalance,
		Sundown,
		Seeds,
		Gravity
	}
	public enum Mermaids
	{
		Mermaid1,
		Mermaid2,
		Mermaid3,
		Mermaid4,
		Mermaid5,
		Mermaid6,
		Mermaid7,
		Goat1,
		Goat2,
		Goat3,
		Goat4,
		Goat5,
		Eagle1,
		Eagle2,
		Eagle3,
		Eagle4,
		Eagle5
	}
	public enum Books
	{
		Fundamentals,
		Intermediate,
		Advanced,
		Expert,
		Essentials,
		AlpineGreats,
		ArduousArctic
	}
	public enum BirdSeeds
	{
		ExtraSeed1,
		ExtraSeed2,
		ExtraSeed3,
		ExtraSeed4,
		ExtraSeed5
	}
	public enum ExtraItems
	{
		ExtraRope,
		ExtraChalk,
		ExtraCoffee,
		ExtraSeed,
		Trap
	}
	public enum PeakStatus
	{
		Locked,
		Unlocked,
		Summited,
		Completed
	}
	public enum Cabins
	{
		Cabin,
		CabinExpert,
		CabinAlps
	}
	internal interface ISlotData
	{
		SessionSettings.RopeUnlockMode ropeUnlockMode { get; set; }

		SessionSettings.GameMode gameMode { get; set; }

		int cramponLevel { get; set; }

		bool HasBook(Books book);

		bool ShowBook(Books book);

		bool HasTool(Tools tool);

		bool HasPeak(Peaks peak);

		bool HasIdol(Idols idol);

		int GetTotalRopeCount();

		int GetTotalCoffeeCount();

		int GetExtraItemCount(ExtraItems item);

		void RecieveArtefact(Artefacts artefact);

		void RecieveBirdSeed(BirdSeeds birdSeed);

		void RecieveBook(Books book);

		void ExtraItemReceived(ExtraItems item);

		void RecievePeak(Peaks peak);

		void RecieveRope(Ropes rope);

		void ReceiveTool(Tools tool);

		bool IsJournalPageUnlocked(int v, Books b);

		Peaks BookPageToPeaks(int page, Books book);

		Color GetJournalPageColor(int v, Books b);

		int GetTotalExtraBirdSeedCount();

		void receiveIdol(Idols idol);
	}
	internal class SessionSettings
	{
		public enum RopeUnlockMode
		{
			INSTANT,
			EARLY,
			NORMAL
		}

		public enum Goal
		{
			ALL_PEAKS,
			ALL_ARTEFACTS,
			ALL_ARTEFACTS_AND_PEAKS,
			ALL_TIME_ATTACK,
			ALL,
			PEAK
		}

		public enum GameMode
		{
			BOOK_UNLOCK,
			PEAK_UNLOCK
		}

		public enum Book
		{
			FUNDAMENTALS = 1,
			INTERMEDIATE = 2,
			ADVANCED = 4,
			EXPERT = 8
		}

		public const int SETTINGSVER = 3;

		public bool deathLinkEnabled;

		public RopeUnlockMode ropeUnlockMode = RopeUnlockMode.NORMAL;

		public Goal goal;

		public GameMode gameMode;

		public int booksEnabled;

		public bool excludeST;

		public bool includeFreeSolo;

		public bool includeTimeAttack;

		public Peaks targetPeak;

		public bool enableDLC;

		public int version;

		public SessionSettings(bool deathLinkEnabled, RopeUnlockMode ropeUnlockMode, Goal goal, GameMode gameMode, int booksEnabled, bool excludeST)
		{
			this.deathLinkEnabled = deathLinkEnabled;
			this.ropeUnlockMode = ropeUnlockMode;
			this.goal = goal;
			this.gameMode = gameMode;
			this.booksEnabled = booksEnabled;
			this.excludeST = excludeST;
		}

		public SessionSettings(Dictionary<string, object> optionsDict)
		{
			PeaksOfArchipelago.Logger.LogInfo((object)"Loading session settings from options dict");
			foreach (string key in optionsDict.Keys)
			{
				PeaksOfArchipelago.Logger.LogInfo((object)("Option key: " + key + ", value: " + optionsDict[key].ToString()));
			}
			deathLinkEnabled = LoadIntFromDict(optionsDict, "deathLink", false) == 1;
			ropeUnlockMode = (RopeUnlockMode)LoadIntFromDict(optionsDict, "ropeUnlockMode", RopeUnlockMode.NORMAL);
			goal = (Goal)LoadIntFromDict(optionsDict, "goal", Goal.ALL_PEAKS);
			gameMode = (GameMode)LoadIntFromDict(optionsDict, "gameMode", GameMode.BOOK_UNLOCK);
			excludeST = LoadIntFromDict(optionsDict, "disableSolemnTempest", true) == 1;
			includeFreeSolo = LoadIntFromDict(optionsDict, "includeFreeSolo", false) == 1;
			includeTimeAttack = LoadIntFromDict(optionsDict, "includeTimeAttack", false) == 1;
			targetPeak = (Peaks)LoadIntFromDict(optionsDict, "peakGoal", 36);
			enableDLC = LoadIntFromDict(optionsDict, "enableDlc", false) == 1;
			version = LoadIntFromDict(optionsDict, "settingsVer", 0);
			if (version < 3)
			{
				PeaksOfArchipelago.Logger.LogWarning((object)"AP World out of date! Issues may happen.");
				PeaksOfArchipelago.Logger.LogWarning((object)$"Mod settings Version     : v{3}");
				PeaksOfArchipelago.Logger.LogWarning((object)$"AP World settings Version: v{version}");
				PeaksOfArchipelago.ui.SendNotification($"AP World out of date: Expected v{3}, got v{version}");
				PeaksOfArchipelago.ui.SendNotification("Expect the Unexpected");
			}
			if (version > 3)
			{
				PeaksOfArchipelago.Logger.LogWarning((object)$"Mod out of date! Issues may happen. Expected v{3}, got v{version}");
				PeaksOfArchipelago.ui.SendNotification($"Mod out of date: Expected v{3}, got v{version}");
				PeaksOfArchipelago.ui.SendNotification("Expect the Unexpected");
			}
		}

		private int LoadIntFromDict(Dictionary<string, object> dict, string v, object defaultValue)
		{
			if (dict.TryGetValue(v, out var value))
			{
				PeaksOfArchipelago.Logger.LogInfo((object)$"{v}: {value}");
				return Convert.ToInt32(value);
			}
			PeaksOfArchipelago.Logger.LogWarning((object)$"{v} not found, defaulting to {defaultValue}");
			return Convert.ToInt32(defaultValue);
		}
	}
	internal class SlotData : ISlotData
	{
		private readonly HashSet<Books> unlockedBooks = new HashSet<Books>();

		private readonly HashSet<Artefacts> unlockedArtefacts = new HashSet<Artefacts>();

		private readonly HashSet<BirdSeeds> unlockedBirdSeeds = new HashSet<BirdSeeds>();

		private readonly HashSet<Peaks> unlockedPeaks = new HashSet<Peaks>();

		private readonly HashSet<Ropes> unlockedRopes = new HashSet<Ropes>();

		private readonly HashSet<Tools> unlockedTools = new HashSet<Tools>();

		private readonly HashSet<Idols> unlockedIdols = new HashSet<Idols>();

		private readonly Dictionary<ExtraItems, int> extraItemCounts = new Dictionary<ExtraItems, int>();

		public SessionSettings.RopeUnlockMode ropeUnlockMode { get; set; }

		public SessionSettings.GameMode gameMode { get; set; }

		public int cramponLevel { get; set; }

		public SlotData(SessionSettings settings)
		{
			ropeUnlockMode = settings.ropeUnlockMode;
			gameMode = settings.gameMode;
			extraItemCounts = new Dictionary<ExtraItems, int>();
			for (int i = 0; i < Enum.GetValues(typeof(ExtraItems)).Length; i++)
			{
				extraItemCounts[(ExtraItems)i] = 0;
			}
		}

		public void RecieveArtefact(Artefacts artefact)
		{
			unlockedArtefacts.Add(artefact);
			PeaksOfArchipelago.Logger.LogWarning((object)"How did we get here again?");
		}

		public void RecieveBirdSeed(BirdSeeds birdSeed)
		{
			unlockedBirdSeeds.Add(birdSeed);
		}

		public void RecieveBook(Books book)
		{
			PeaksOfArchipelago.Logger.LogInfo((object)$"Unlocked book: {book}");
			unlockedBooks.Add(book);
		}

		public void RecievePeak(Peaks peak)
		{
			unlockedPeaks.Add(peak);
		}

		public void RecieveRope(Ropes rope)
		{
			unlockedRopes.Add(rope);
		}

		public void ReceiveTool(Tools tool)
		{
			unlockedTools.Add(tool);
		}

		public void ExtraItemReceived(ExtraItems item)
		{
			extraItemCounts[item]++;
		}

		public bool HasBook(Books book)
		{
			if (!unlockedBooks.Contains(book))
			{
				return gameMode == SessionSettings.GameMode.PEAK_UNLOCK;
			}
			return true;
		}

		public bool ShowBook(Books book)
		{
			if (gameMode == SessionSettings.GameMode.PEAK_UNLOCK)
			{
				foreach (Peaks bookPeak in Mappings.GetBookPeaks(book))
				{
					if (HasPeak(bookPeak))
					{
						return true;
					}
				}
				return false;
			}
			return HasBook(book);
		}

		public int GetTotalRopeCount()
		{
			return GetExtraItemCount(ExtraItems.ExtraRope) * 2;
		}

		public int GetTotalExtraBirdSeedCount()
		{
			int num = GetExtraItemCount(ExtraItems.ExtraSeed);
			for (int i = 0; i <= 4; i++)
			{
				if (unlockedBirdSeeds.Contains((BirdSeeds)i))
				{
					num++;
				}
			}
			return num;
		}

		public int GetTotalCoffeeCount()
		{
			throw new NotImplementedException();
		}

		public bool HasTool(Tools tool)
		{
			return unlockedTools.Contains(tool);
		}

		public bool HasPeak(Peaks peak)
		{
			if (!unlockedPeaks.Contains(peak))
			{
				return gameMode == SessionSettings.GameMode.BOOK_UNLOCK;
			}
			return true;
		}

		public bool HasIdol(Idols idol)
		{
			return unlockedIdols.Contains(idol);
		}

		public bool IsJournalPageUnlocked(int page, Books book)
		{
			return HasPeak(BookPageToPeaks(page, book));
		}

		public int GetExtraItemCount(ExtraItems item)
		{
			return extraItemCounts[item];
		}

		public Peaks BookPageToPeaks(int page, Books book)
		{
			page--;
			if (page < 0)
			{
				return (Peaks)(-1);
			}
			switch (book)
			{
			case Books.Fundamentals:
			{
				Peaks peaks = (Peaks)page;
				switch (peaks)
				{
				case Peaks.HangmansLeap:
					peaks = Peaks.LandsEnd;
					break;
				case Peaks.LandsEnd:
					peaks = Peaks.HangmansLeap;
					break;
				}
				return peaks;
			}
			case Books.Intermediate:
				return (Peaks)(page + 20);
			case Books.Advanced:
			{
				Peaks peaks = (Peaks)(page + 30);
				switch (peaks)
				{
				case Peaks.Eldenhorn:
					peaks = Peaks.GreatGaol;
					break;
				case Peaks.GreatGaol:
					peaks = Peaks.Eldenhorn;
					break;
				}
				return peaks;
			}
			case Books.Essentials:
				return (Peaks)(page + 37);
			case Books.AlpineGreats:
				return (Peaks)(page + 49);
			case Books.ArduousArctic:
				return (Peaks)(page + 54);
			default:
				return (Peaks)(-2);
			}
		}

		public Color GetJournalPageColor(int v, Books b)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			if (!IsJournalPageUnlocked(v, b))
			{
				return Color.red;
			}
			return Color.white;
		}

		public void receiveIdol(Idols idol)
		{
			unlockedIdols.Add(idol);
		}
	}
}
namespace PeaksOfArchipelago.Extensions
{
	internal static class DeepFind
	{
		public static Transform FindDeep(this Transform aParent, string name)
		{
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Expected O, but got Unknown
			Queue<Transform> queue = new Queue<Transform>();
			queue.Enqueue(aParent);
			while (queue.Count > 0)
			{
				Transform val = queue.Dequeue();
				if (((Object)val).name == name)
				{
					return val;
				}
				foreach (Transform item2 in val)
				{
					Transform item = item2;
					queue.Enqueue(item);
				}
			}
			return null;
		}
	}
}
namespace PeaksOfArchipelago.CabinHandlers
{
	internal class AlpsCabinHandler : CabinHandler
	{
		private struct IdolInfo
		{
			public Idols idol;

			public GameObject fullObject;

			public ArtefactInfo p1;

			public ArtefactInfo p2;

			public IdolInfo(Idols idol, GameObject fullObject, ArtefactInfo p1, ArtefactInfo p2)
			{
				this.idol = idol;
				this.fullObject = fullObject;
				this.p1 = p1;
				this.p2 = p2;
			}
		}

		private bool hasSpawnedInAPLogo;

		public AlpsCabinHandler(ISlotData slotData)
			: base(slotData)
		{
		}

		public override bool CollectItems(List<ItemInfo> itemInfos)
		{
			//IL_0125: Unknown result type (might be due to invalid IL or missing references)
			//IL_0144: Unknown result type (might be due to invalid IL or missing references)
			//IL_0163: Unknown result type (might be due to invalid IL or missing references)
			itemInfos = itemInfos.Where((ItemInfo i) => i.ItemName != "Trap").ToList();
			if (itemInfos.Count == 0)
			{
				return true;
			}
			AlpsEvents val = Object.FindObjectOfType<AlpsEvents>();
			val.currentEventName = "Alps_Medal1";
			val.itemDisplay_MedalTitle.text = "- Archipelago Item Delivery -";
			val.itemDisplay_MedalDescription.text = "You have received:\n " + itemInfos[0].ItemName;
			for (int j = 1; j < itemInfos.Count; j++)
			{
				Text itemDisplay_MedalDescription = val.itemDisplay_MedalDescription;
				itemDisplay_MedalDescription.text = itemDisplay_MedalDescription.text + ", " + itemInfos[j].ItemName;
			}
			if (!hasSpawnedInAPLogo)
			{
				GameObject val2 = Object.Instantiate<GameObject>(PeaksOfAssets.APLogo);
				val2.layer = val.alps_itemDisplay_Medal1.layer;
				((Component)val2.transform.GetChild(0)).gameObject.layer = val.alps_itemDisplay_Medal1.layer;
				val2.transform.SetParent(val.alps_itemDisplay_Medal1.transform.parent, false);
				val2.transform.localPosition = val.alps_itemDisplay_Medal1.transform.localPosition;
				val2.transform.localScale = new Vector3(0.025f, 0.025f, 0.025f);
				val2.transform.localRotation = Quaternion.Euler(270f, 270f, 0f);
				val.alps_itemDisplay_Medal1 = val2;
				val.alps_itemDisplay_Medal1.SetActive(false);
				hasSpawnedInAPLogo = true;
			}
			((MonoBehaviour)val).StartCoroutine("UnpackParcel");
			return true;
		}

		public override bool HandleCompletion()
		{
			return false;
		}

		public override void LoadProgress()
		{
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			AlpsJournal val = Object.FindObjectOfType<AlpsJournal>();
			if (!Object.op_Implicit((Object)(object)val))
			{
				logger.LogError((object)"Could not find Alps Journal, progress will not be loaded");
				return;
			}
			if (!slotData.HasBook(Books.Essentials))
			{
				foreach (Transform item in ((Component)val).transform)
				{
					((Component)item).gameObject.SetActive(false);
				}
				((Collider)((Component)((Component)val).transform.parent).GetComponent<BoxCollider>()).enabled = false;
				((Component)((Component)val).transform.parent.parent.parent.GetChild(1)).gameObject.SetActive(false);
			}
			val.AlpsJournal2.SetActive(slotData.HasBook(Books.AlpineGreats));
			val.AlpsJournal3.SetActive(slotData.HasBook(Books.ArduousArctic));
			AlpsEvents obj = Object.FindObjectOfType<AlpsEvents>();
			obj.alps_freesolo_medal.SetActive(false);
			obj.alps_timeattack_medal1.SetActive(false);
			obj.alps_timeattack_medal2.SetActive(false);
			obj.alps_timeattack_medal3.SetActive(false);
			obj.alps_medal1.SetActive(false);
			obj.alps_medal2.SetActive(false);
			obj.alps_medal3.SetActive(false);
			ArtefactLoaderCabin val2 = Object.FindObjectOfType<ArtefactLoaderCabin>();
			AudioSource phonographMusic = obj.phonographMusic;
			if (phonographMusic != null)
			{
				((Component)((Component)phonographMusic).transform.parent).gameObject.SetActive(slotData.HasTool(Tools.Phonograph));
			}
			val2.alpcabin_ropes.SetActive(slotData.HasTool(Tools.Rope));
			val2.alpcabin_ropesUpgraded.SetActive(slotData.HasTool(Tools.RopeLengthUpgrade));
			val2.alpcabin_crampons.SetActive(slotData.cramponLevel > 0);
			val2.alpcabin_iceaxes.SetActive(slotData.HasTool(Tools.IceAxes));
			val2.alpcabin_barometer.SetActive(slotData.HasTool(Tools.Barometer));
			val2.alpcabin_chalkbag.SetActive(slotData.HasTool(Tools.Chalkbag));
			val2.alpcabin_coffee.SetActive(slotData.HasTool(Tools.Coffee));
			val2.alpcabin_seeds.SetActive(GameManager.control.extraBirdSeedUses > 0);
			((Component)val2.alpcabin_barometer.transform.parent).gameObject.SetActive(true);
			if (!slotData.HasTool(Tools.Pipe))
			{
				GameManager.control.isUsingPipe = false;
			}
		}

		internal override void LoadArtefacts()
		{
			ArtefactLoaderCabin val = Object.FindObjectOfType<ArtefactLoaderCabin>();
			foreach (IdolInfo item in new List<IdolInfo>
			{
				new IdolInfo(Idols.Crimps, val.alps_clean_statue_crimps_complete, new ArtefactInfo(Artefacts.Alps_Idol_crimpsPt1, val.alps_clean_statue_crimps_pt1, val.alps_dirty_statue_crimps_pt1, GameManager.control.alps_statue_crimps_IsDirty_pt1, GameManager.control.alps_hasStatue_crimps_pt1), new ArtefactInfo(Artefacts.Alps_Idol_crimpsPt2, val.alps_clean_statue_crimps_pt2, val.alps_dirty_statue_crimps_pt2, GameManager.control.alps_statue_crimps_IsDirty_pt2, GameManager.control.alps_hasStatue_crimps_pt2)),
				new IdolInfo(Idols.Slopers, val.alps_clean_statue_slopers_complete, new ArtefactInfo(Artefacts.Alps_Idol_slopersPt1, val.alps_clean_statue_slopers_pt1, val.alps_dirty_statue_slopers_pt1, GameManager.control.alps_statue_slopers_IsDirty_pt1, GameManager.control.alps_hasStatue_slopers_pt1), new ArtefactInfo(Artefacts.Alps_Idol_slopersPt2, val.alps_clean_statue_slopers_pt2, val.alps_dirty_statue_slopers_pt2, GameManager.control.alps_statue_slopers_IsDirty_pt2, GameManager.control.alps_hasStatue_slopers_pt2)),
				new IdolInfo(Idols.Feathers, val.alps_clean_statue_feathers_complete, new ArtefactInfo(Artefacts.Alps_Idol_feathersPt1, val.alps_clean_statue_feathers_pt1, val.alps_dirty_statue_feathers_pt1, GameManager.control.alps_statue_feathers_IsDirty_pt1, GameManager.control.alps_hasStatue_feathers_pt1), new ArtefactInfo(Artefacts.Alps_Idol_feathersPt2, val.alps_clean_statue_feathers_pt2, val.alps_dirty_statue_feathers_pt2, GameManager.control.alps_statue_feathers_IsDirty_pt2, GameManager.control.alps_hasStatue_feathers_pt2)),
				new IdolInfo(Idols.Pitches, val.alps_clean_statue_pitches_complete, new ArtefactInfo(Artefacts.Alps_Idol_pitchesPt1, val.alps_clean_statue_pitches_pt1, val.alps_dirty_statue_pitches_pt1, GameManager.control.alps_statue_pitches_IsDirty_pt1, GameManager.control.alps_hasStatue_pitches_pt1), new ArtefactInfo(Artefacts.Alps_Idol_pitchesPt2, val.alps_clean_statue_pitches_pt2, val.alps_dirty_statue_pitches_pt2, GameManager.control.alps_statue_pitches_IsDirty_pt2, GameManager.control.alps_hasStatue_pitches_pt2)),
				new IdolInfo(Idols.Ice, val.alps_clean_statue_ice_complete, new ArtefactInfo(Artefacts.Alps_Idol_icePt1, val.alps_clean_statue_ice_pt1, val.alps_dirty_statue_ice_pt1, GameManager.control.alps_statue_ice_IsDirty_pt1, GameManager.control.alps_hasStatue_ice_pt1), new ArtefactInfo(Artefacts.Alps_Idol_icePt2, val.alps_clean_statue_ice_pt2, val.alps_dirty_statue_ice_pt2, GameManager.control.alps_statue_ice_IsDirty_pt2, GameManager.control.alps_hasStatue_ice_pt2)),
				new IdolInfo(Idols.Pinches, val.alps_clean_statue_pinches_complete, new ArtefactInfo(Artefacts.Alps_Idol_pinchesPt1, val.alps_clean_statue_pinches_pt1, val.alps_dirty_statue_pinches_pt1, GameManager.control.alps_statue_pinches_IsDirty_pt1, GameManager.control.alps_hasStatue_pinches_pt1), new ArtefactInfo(Artefacts.Alps_Idol_pinchesPt2, val.alps_clean_statue_pinches_pt2, val.alps_dirty_statue_pinches_pt2, GameManager.control.alps_statue_pinches_IsDirty_pt2, GameManager.control.alps_hasStatue_pinches_pt2)),
				new IdolInfo(Idols.GreaterBalance, val.alps_clean_statue_greaterbalance_complete, new ArtefactInfo(Artefacts.Alps_Idol_greaterbalancePt1, val.alps_clean_statue_greaterbalance_pt1, val.alps_dirty_statue_greaterbalance_pt1, GameManager.control.alps_statue_greaterbalance_IsDirty_pt1, GameManager.control.alps_hasStatue_greaterbalance_pt1), new ArtefactInfo(Artefacts.Alps_Idol_greaterbalancePt2, val.alps_clean_statue_greaterbalance_pt2, val.alps_dirty_statue_greaterbalance_pt2, GameManager.control.alps_statue_greaterbalance_IsDirty_pt2, GameManager.control.alps_hasStatue_greaterbalance_pt2)),
				new IdolInfo(Idols.Sundown, val.alps_clean_statue_sundown_complete, new ArtefactInfo(Artefacts.Alps_Idol_sundownPt1, val.alps_clean_statue_sundown_pt1, val.alps_dirty_statue_sundown_pt1, GameManager.control.alps_statue_sundown_IsDirty_pt1, GameManager.control.alps_hasStatue_sundown_pt1), new ArtefactInfo(Artefacts.Alps_Idol_sundownPt2, val.alps_clean_statue_sundown_pt2, val.alps_dirty_statue_sundown_pt2, GameManager.control.alps_statue_sundown_IsDirty_pt2, GameManager.control.alps_hasStatue_sundown_pt2)),
				new IdolInfo(Idols.Seeds, val.alps_clean_statue_seeds_complete, new ArtefactInfo(Artefacts.Alps_Idol_seedsPt1, val.alps_clean_statue_seeds_pt1, val.alps_dirty_statue_seeds_pt1, GameManager.control.alps_statue_seeds_IsDirty_pt1, GameManager.control.alps_hasStatue_seeds_pt1), new ArtefactInfo(Artefacts.Alps_Idol_seedsPt2, val.alps_clean_statue_seeds_pt2, val.alps_dirty_statue_seeds_pt2, GameManager.control.alps_statue_seeds_IsDirty_pt2, GameManager.control.alps_hasStatue_seeds_pt2)),
				new IdolInfo(Idols.Gravity, val.alps_clean_statue_gravity_complete, new ArtefactInfo(Artefacts.Alps_Idol_gravityPt1, val.alps_clean_statue_gravity_pt1, val.alps_dirty_statue_gravity_pt1, GameManager.control.alps_statue_gravity_IsDirty_pt1, GameManager.control.alps_hasStatue_gravity_pt1), new ArtefactInfo(Artefacts.Alps_Idol_gravityPt2, val.alps_clean_statue_gravity_pt2, val.alps_dirty_statue_gravity_pt2, GameManager.control.alps_statue_gravity_IsDirty_pt2, GameManager.control.alps_hasStatue_gravity_pt2))
			})
			{
				item.fullObject.SetActive(false);
				item.p1.cleanObject.SetActive(false);
				item.p1.dirtyObject.SetActive(false);
				item.p2.cleanObject.SetActive(false);
				item.p2.dirtyObject.SetActive(false);
				if (item.p1.hasArtefact)
				{
					item.p1.dirtyObject.SetActive(item.p1.isDirty);
					item.p1.cleanObject.SetActive(!item.p1.isDirty);
				}
				if (item.p2.hasArtefact)
				{
					item.p2.dirtyObject.SetActive(item.p2.isDirty);
					item.p2.cleanObject.SetActive(!item.p2.isDirty);
				}
				if (slotData.HasIdol(item.idol))
				{
					item.fullObject.SetActive(true);
					item.p1.cleanObject.SetActive(false);
					item.p2.cleanObject.SetActive(false);
				}
			}
			Dictionary<Artefacts, bool> dictionary = new Dictionary<Artefacts, bool>
			{
				{
					Artefacts.Alps_Gentiana1,
					GameManager.control.alps_gentiana1
				},
				{
					Artefacts.Alps_Gentiana2,
					GameManager.control.alps_gentiana2
				},
				{
					Artefacts.Alps_Gentiana3,
					GameManager.control.alps_gentiana3
				},
				{
					Artefacts.Alps_Gentiana4,
					GameManager.control.alps_gentiana4
				},
				{
					Artefacts.Alps_Gentiana5,
					GameManager.control.alps_gentiana5
				},
				{
					Artefacts.Alps_Gentiana6,
					GameManager.control.alps_gentiana6
				},
				{
					Artefacts.Alps_Gentiana7,
					GameManager.control.alps_gentiana7
				}
			};
			for (int i = 0; i < dictionary.Count; i++)
			{
				bool flag = dictionary[(Artefacts)(i + 40)];
				if (flag)
				{
					val.alpsflowerpot_gentiana.SetActive(true);
				}
				val.alpsflower_gentiana[i].SetActive(flag);
			}
			Dictionary<Artefacts, bool> dictionary2 = new Dictionary<Artefacts, bool>
			{
				{
					Artefacts.Alps_Edelweiss1,
					GameManager.control.alps_edelweiss1
				},
				{
					Artefacts.Alps_Edelweiss2,
					GameManager.control.alps_edelweiss2
				},
				{
					Artefacts.Alps_Edelweiss3,
					GameManager.control.alps_edelweiss3
				},
				{
					Artefacts.Alps_Edelweiss4,
					GameManager.control.alps_edelweiss4
				},
				{
					Artefacts.Alps_Edelweiss5,
					GameManager.control.alps_edelweiss5
				},
				{
					Artefacts.Alps_Edelweiss6,
					GameManager.control.alps_edelweiss6
				},
				{
					Artefacts.Alps_Edelweiss7,
					GameManager.control.alps_edelweiss7
				}
			};
			for (int j = 0; j < dictionary2.Count; j++)
			{
				bool flag2 = dictionary2[(Artefacts)(j + 47)];
				if (flag2)
				{
					val.alpsflowerpot_edelweiss.SetActive(true);
				}
				val.alpsflower_edelweiss[j].SetActive(flag2);
			}
		}
	}
	internal class BaseCabinHandler : CabinHandler
	{
		private bool hasSpawnedInAPLogo;

		private GameObject book1;

		public BaseCabinHandler(ISlotData slotData)
			: base(slotData)
		{
		}

		public override bool CollectItems(List<ItemInfo> itemInfos)
		{
			//IL_0117: Unknown result type (might be due to invalid IL or missing references)
			//IL_0136: Unknown result type (might be due to invalid IL or missing references)
			//IL_0151: Unknown result type (might be due to invalid IL or missing references)
			itemInfos = itemInfos.Where((ItemInfo i) => i.ItemName != "Trap").ToList();
			if (itemInfos.Count == 0)
			{
				return true;
			}
			NPCEvents val = Object.FindObjectOfType<NPCEvents>();
			val.eventName = "AllArtefacts";
			Text componentInChildren = val.allArtefactsInfo.GetComponentInChildren<Text>();
			componentInChildren.text = "You have received:\n " + itemInfos[0].ItemName;
			for (int j = 1; j < itemInfos.Count; j++)
			{
				componentInChildren.text = componentInChildren.text + ", " + itemInfos[j].ItemName;
			}
			if (!hasSpawnedInAPLogo)
			{
				GameObject val2 = Object.Instantiate<GameObject>(PeaksOfAssets.APLogo);
				val2.layer = val.packageContentAllArtefacts.layer;
				((Component)val2.transform.GetChild(0)).gameObject.layer = val.packageContentAllArtefacts.layer;
				val2.transform.SetParent(val.packageContentAllArtefacts.transform.parent, false);
				val2.transform.localPosition = val.packageContentAllArtefacts.transform.localPosition;
				val2.transform.localScale = new Vector3(0.15f, 0.15f, 0.15f);
				val2.transform.rotation = val.packageContentAllArtefacts.transform.rotation;
				val.packageContentAllArtefacts = val2;
				val.packageContentAllArtefacts.SetActive(false);
				hasSpawnedInAPLogo = true;
			}
			val.runningEvent = true;
			((MonoBehaviour)val.npcParcelDeliverySystem).StartCoroutine("FadeScreenAndStartUnpackEvent");
			return true;
		}

		public override bool HandleCompletion()
		{
			NPCEvents val = Object.FindObjectOfType<NPCEvents>();
			if ((Object)(object)val == (Object)null)
			{
				logger.LogError((object)"Couldn't find NPCEvents to start win check");
				return false;
			}
			((MonoBehaviour)val).StartCoroutine("GameEndingBase");
			return true;
		}

		public override void LoadProgress()
		{
			logger.LogInfo((object)"Loading Base Cabin Progress...");
			Object.FindObjectOfType<ArtefactLoaderCabin>();
			if (!slotData.HasTool(Tools.AlpsTicket))
			{
				logger.LogInfo((object)"Alps disabled, disabling ticket (if existing)");
				GameObject obj = GameObject.Find("bed_original");
				if (obj != null)
				{
					obj.SetActive(true);
				}
				GameObject val = GameObject.Find("AlpsGateway");
				if ((Object)(object)val != (Object)null)
				{
					val.SetActive(false);
				}
				else
				{
					logger.LogWarning((object)"Alps Gateway not found!");
				}
			}
			if ((Object)(object)book1 == (Object)null)
			{
				book1 = GameObject.Find("MAPJOURNAL");
				if ((Object)(object)book1 == (Object)null)
				{
					logger.LogWarning((object)"Warning: Could Not Find Fundamentals book");
				}
			}
			NPCEvents val2 = Object.FindObjectOfType<NPCEvents>();
			if ((Object)(object)val2 == (Object)null)
			{
				logger.LogWarning((object)"npc events is null, aborting");
				return;
			}
			Transform val3 = val2.cabinIceaxes.transform.Find("Category4_Ticket_Cabin");
			Transform val4 = val2.cabinIceaxes.transform.Find("iceaxes_hanging");
			val2.iceaxesInfo.SetActive(false);
			book1.SetActive(slotData.ShowBook(Books.Fundamentals));
			val2.cabin_Category2.SetActive(slotData.ShowBook(Books.Intermediate));
			bool flag = slotData.ShowBook(Books.Advanced);
			val2.cabin_Category3.SetActive(flag);
			val2.teaclothteacupObj.SetActive(!flag);
			((Component)val3).gameObject.SetActive(slotData.ShowBook(Books.Expert));
			val2.cabinMedal_1.SetActive(false);
			val2.cabinMedal_2.SetActive(false);
			val2.cabinMedal_3.SetActive(false);
			val2.cabinallArtefacts.SetActive(false);
			if (Object.op_Implicit((Object)(object)val2.cabinRope))
			{
				val2.cabinRope.SetActive(slotData.HasTool(Tools.Rope));
			}
			if (Object.op_Implicit((Object)(object)val2.cabinPhonograph))
			{
				val2.cabinPhonograph.SetActive(slotData.HasTool(Tools.Phonograph));
			}
			((Component)val4).gameObject.SetActive(slotData.HasTool(Tools.IceAxes));
			val2.iceaxesInfo.SetActive(false);
			if (Object.op_Implicit((Object)(object)val2.cabinRopesUpgraded))
			{
				val2.cabinRopesUpgraded.SetActive(slotData.HasTool(Tools.RopeLengthUpgrade));
			}
			if (Object.op_Implicit((Object)(object)val2.cabinPocketwatch))
			{
				val2.cabinPocketwatch.SetActive(slotData.HasTool(Tools.Pocketwatch));
				val2.cabinScoreboard.SetActive(slotData.HasTool(Tools.Pocketwatch));
			}
			if (slotData.cramponLevel > 0)
			{
				val2.cabinCramponsCollider.SetActive(true);
				logger.LogInfo((object)$"crampon level: {slotData.cramponLevel}");
				if (slotData.cramponLevel <= 2)
				{
					if (PlayerPrefs.GetInt("UseBasicCrampons") == 1)
					{
						val2.cramponsEditionTxt.text = "10-";
						val2.cabinCrampons_10Point.SetActive(true);
						val2.cabinCrampons_6Point.SetActive(false);
					}
					else
					{
						val2.cramponsEditionTxt.text = "6-";
						val2.cabinCrampons_6Point.SetActive(true);
						val2.cabinCrampons_10Point.SetActive(false);
					}
				}
				else
				{
					PlayerPrefs.SetInt("UseBasicCrampons", 1);
					val2.cramponsEditionTxt.text = "6-";
					val2.cabinCrampons_6Point.SetActive(true);
					val2.cabinCrampons_10Point.SetActive(false);
				}
			}
			else
			{
				logger.LogInfo((object)"Showing no crampons");
				val2.cabinCramponsCollider.SetActive(false);
				val2.cabinCrampons_6Point.SetActive(false);
				val2.cabinCrampons_10Point.SetActive(false);
			}
			if (Object.op_Implicit((Object)(object)val2.cabinChalkbag))
			{
				val2.cabinChalkbag.SetActive(slotData.HasTool(Tools.Chalkbag));
			}
			if (Object.op_Implicit((Object)(object)val2.cabinPipe))
			{
				val2.cabinPipe.SetActive(slotData.HasTool(Tools.Pipe));
			}
			if (!slotData.HasTool(Tools.Pipe))
			{
				GameManager.control.isUsingPipe = false;
			}
			if (Object.op_Implicit((Object)(object)val2.cabinBarometer))
			{
				val2.cabinBarometer.SetActive(slotData.HasTool(Tools.Barometer));
			}
		}

		internal override void LoadArtefacts()
		{
			ArtefactLoaderCabin val = Object.FindObjectOfType<ArtefactLoaderCabin>();
			foreach (ArtefactInfo item in new List<ArtefactInfo>
			{
				new ArtefactInfo(Artefacts.Hat1, val.clean_hat1, val.dirty_hat1, GameManager.control.artefact_Hat1_IsDirty, GameManager.control.hasArtefact_Hat1),
				new ArtefactInfo(Artefacts.Hat2, val.clean_hat2, val.dirty_hat2, GameManager.control.artefact_Hat2_IsDirty, GameManager.control.hasArtefact_Hat2),
				new ArtefactInfo(Artefacts.Helmet, val.clean_helmet, val.dirty_helmet, GameManager.control.artefact_Helmet_IsDirty, GameManager.control.hasArtefact_Helmet),
				new ArtefactInfo(Artefacts.Shoe, val.clean_shoe, val.dirty_shoe, GameManager.control.artefact_Shoe_IsDirty, GameManager.control.hasArtefact_Shoe),
				new ArtefactInfo(Artefacts.Shovel, val.clean_shovel, val.dirty_shovel, GameManager.control.artefact_Shovel_IsDirty, GameManager.control.hasArtefact_Shovel),
				new ArtefactInfo(Artefacts.Sleepingbag, val.clean_sleepingbag, val.dirty_sleepingbag, GameManager.control.artefact_Sleepingbag_IsDirty, GameManager.control.hasArtefact_Sleepingbag),
				new ArtefactInfo(Artefacts.Backpack, val.clean_backpack, val.dirty_backpack, GameManager.control.artefact_Backpack_IsDirty, GameManager.control.hasArtefact_Backpack),
				new ArtefactInfo(Artefacts.Coffebox_1, val.clean_coffeebox1, val.dirty_coffeebox1, GameManager.control.artefact_Coffeebox1_IsDirty, GameManager.control.hasArtefact_Coffeebox1),
				new ArtefactInfo(Artefacts.Coffebox_2, val.clean_coffeebox2, val.dirty_coffeebox2, GameManager.control.artefact_Coffeebox2_IsDirty, GameManager.control.hasArtefact_Coffeebox2),
				new ArtefactInfo(Artefacts.Chalkbox_1, val.clean_chalkbox1, val.dirty_chalkbox1, GameManager.control.artefact_Chalkbox1_IsDirty, GameManager.control.hasArtefact_Chalkbox1),
				new ArtefactInfo(Artefacts.Chalkbox_2, val.clean_chalkbox2, val.dirty_chalkbox2, GameManager.control.artefact_Chalkbox2_IsDirty, GameManager.control.hasArtefact_Chalkbox2),
				new ArtefactInfo(Artefacts.ClimberStatue1, val.clean_statue1, val.dirty_statue1, GameManager.control.artefact_Statue1_IsDirty, GameManager.control.hasArtefact_Statue1),
				new ArtefactInfo(Artefacts.ClimberStatue2, val.clean_statue2, val.dirty_statue2, GameManager.control.artefact_Statue2_IsDirty, GameManager.control.hasArtefact_Statue2),
				new ArtefactInfo(Artefacts.ClimberStatue3, val.clean_statue3, val.dirty_statue3, GameManager.control.artefact_Statue3_IsDirty, GameManager.control.hasArtefact_Statue3),
				new ArtefactInfo(Artefacts.Photograph_1, val.clean_photograph1, val.dirty_photograph1, GameManager.control.artefact_Photograph1_IsDirty, GameManager.control.hasArtefact_Photograph1),
				new ArtefactInfo(Artefacts.Photograph_2, val.clean_photograph2, val.dirty_photograph2, GameManager.control.artefact_Photograph2_IsDirty, GameManager.control.hasArtefact_Photograph2),
				new ArtefactInfo(Artefacts.Photograph_3, val.clean_photograph3, val.dirty_photograph3, GameManager.control.artefact_Photograph3_IsDirty, GameManager.control.hasArtefact_Photograph3),
				new ArtefactInfo(Artefacts.Photograph_4, val.clean_photograph4, val.dirty_photograph4, GameManager.control.artefact_Photograph4_IsDirty, GameManager.control.hasArtefact_Photograph4),
				new ArtefactInfo(Artefacts.PhotographFrame, val.clean_photographframe, val.dirty_photographframe, GameManager.control.artefact_PhotographFrame_IsDirty, GameManager.control.hasArtefact_PhotographFrame),
				new ArtefactInfo(Artefacts.ClimberStatue0, val.clean_statue0, val.dirty_statue0, GameManager.control.artefact_Statue0_IsDirty, GameManager.control.hasArtefact_Statue0)
			})
			{
				if (item.hasArtefact)
				{
					if (item.isDirty)
					{
						item.cleanObject.SetActive(false);
						item.dirtyObject.SetActive(true);
					}
					else
					{
						item.cleanObject.SetActive(true);
						item.dirtyObject.SetActive(false);
					}
				}
				else
				{
					item.cleanObject.SetActive(false);
					item.dirtyObject.SetActive(false);
				}
			}
			Dictionary<Idols, GameObject> dictionary = new Dictionary<Idols, GameObject>
			{
				{
					Idols.Crimps,
					val.alps_clean_statue_crimps_complete
				},
				{
					Idols.Slopers,
					val.alps_clean_statue_slopers_complete
				},
				{
					Idols.Feathers,
					val.alps_clean_statue_feathers_complete
				},
				{
					Idols.Pitches,
					val.alps_clean_statue_pitches_complete
				},
				{
					Idols.Ice,
					val.alps_clean_statue_ice_complete
				},
				{
					Idols.Pinches,
					val.alps_clean_statue_pinches_complete
				},
				{
					Idols.GreaterBalance,
					val.alps_clean_statue_greaterbalance_complete
				},
				{
					Idols.Sundown,
					val.alps_clean_statue_sundown_complete
				},
				{
					Idols.Seeds,
					val.alps_clean_statue_seeds_complete
				},
				{
					Idols.Gravity,
					val.alps_clean_statue_gravity_complete
				}
			};
			foreach (Idols key in dictionary.Keys)
			{
				dictionary[key].SetActive(slotData.HasIdol(key));
			}
		}
	}
	internal abstract class CabinHandler
	{
		protected struct ArtefactInfo
		{
			public Artefacts artefact;

			public GameObject cleanObject;

			public GameObject dirtyObject;

			public bool isDirty;

			public bool hasArtefact;

			public ArtefactInfo(Artefacts artefact, GameObject cleanObject, GameObject dirtyObject, bool isDirty, bool hasArtefact)
			{
				this.artefact = artefact;
				this.cleanObject = cleanObject;
				this.dirtyObject = dirtyObject;
				this.isDirty = isDirty;
				this.hasArtefact = hasArtefact;
			}
		}

		protected ManualLogSource logger;

		protected ISlotData slotData;

		public abstract void LoadProgress();

		public abstract bool CollectItems(List<ItemInfo> itemInfos);

		public abstract bool HandleCompletion();

		public CabinHandler(ISlotData slotData)
		{
			this.slotData = slotData;
			logger = PeaksOfArchipelago.Logger;
		}

		public static CabinHandler New(Cabins cabin, ISlotData slotData)
		{
			return cabin switch
			{
				Cabins.Cabin => new BaseCabinHandler(slotData), 
				Cabins.CabinExpert => new ExpertCabinHandler(slotData), 
				Cabins.CabinAlps => new AlpsCabinHandler(slotData), 
				_ => throw new NotImplementedException(), 
			};
		}

		internal abstract void LoadArtefacts();
	}
	internal class ExpertCabinHandler : CabinHandler
	{
		public ExpertCabinHandler(ISlotData slotData)
			: base(slotData)
		{
		}

		public override bool CollectItems(List<ItemInfo> itemInfos)
		{
			PeaksOfArchipelago.ui.SendNotification($"You have {itemInfos.Count} items awaiting you in your cabin, return there to collect them");
			return false;
		}

		public override bool HandleCompletion()
		{
			PeaksOfArchipelago.ui.SendNotification("You have completed your goal, return to your cabin to free your items.");
			return false;
		}

		public override void LoadProgress()
		{
			if (!slotData.HasTool(Tools.AlpsTicket))
			{
				logger.LogInfo((object)"Alps disabled, disabling ticket (if existing)");
				GameObject obj = GameObject.Find("bed_original");
				if (obj != null)
				{
					obj.SetActive(true);
				}
				GameObject val = GameObject.Find("AlpsGateway");
				if ((Object)(object)val != (Object)null)
				{
					val.SetActive(false);
				}
				else
				{
					logger.LogWarning((object)"Alps Gateway not found!");
				}
			}
			logger.LogInfo((object)"Loading progress for Expert Cabin");
			if (!slotData.HasTool(Tools.IceAxes))
			{
				PeaksOfArchipelago.ui.SendNotification("You have not unlocked the Ice Axes, you will not be able to progress here");
			}
			Category4CabinLeave val2 = Object.FindObjectOfType<Category4CabinLeave>();
			if ((Object)(object)val2 == (Object)null)
			{
				logger.LogError((object)"Could not find Category4CabinLeave in Alps Cabin :\\");
			}
			else
			{
				((Behaviour)val2).enabled = slotData.HasPeak(Peaks.GreatBulwark);
			}
		}

		internal override void LoadArtefacts()
		{
			ArtefactLoaderCabin val = Object.FindObjectOfType<ArtefactLoaderCabin>();
			Dictionary<Idols, GameObject> dictionary = new Dictionary<Idols, GameObject>
			{
				{
					Idols.Crimps,
					val.alps_clean_statue_crimps_complete
				},
				{
					Idols.Slopers,
					val.alps_clean_statue_slopers_complete
				},
				{
					Idols.Feathers,
					val.alps_clean_statue_feathers_complete
				},
				{
					Idols.Pitches,
					val.alps_clean_statue_pitches_complete
				},
				{
					Idols.Ice,
					val.alps_clean_statue_ice_complete
				},
				{
					Idols.Pinches,
					val.alps_clean_statue_pinches_complete
				},
				{
					Idols.GreaterBalance,
					val.alps_clean_statue_greaterbalance_complete
				},
				{
					Idols.Sundown,
					val.alps_clean_statue_sundown_complete
				},
				{
					Idols.Seeds,
					val.alps_clean_statue_seeds_complete
				},
				{
					Idols.Gravity,
					val.alps_clean_statue_gravity_complete
				}
			};
			foreach (Idols key in dictionary.Keys)
			{
				dictionary[key].SetActive(slotData.HasIdol(key));
			}
		}
	}
}
namespace PeaksOfArchipelago.Assets
{
	internal class PeaksOfAssets
	{
		private static bool loaded;

		private static AssetBundle assetBundle;

		public static GameObject ChatBoxPrefab { get; private set; }

		public static GameObject ChatMessagePrefab { get; private set; }

		public static GameObject LoginScreen { get; private set; }

		public static GameObject APLogo { get; private set; }

		public static GameObject Notificator { get; private set; }

		public static GameObject Notification { get; private set; }

		public static GameObject ProgressDisplay { get; private set; }

		public static GameObject BookEntryPrefab { get; private set; }

		public static GameObject PeakEntryPrefab { get; private set; }

		public static GameObject ProgressScreenTutorial { get; private set; }

		public static GameObject TrapDisplay { get; private set; }

		public static GameObject TrapTimer { get; private set; }

		public static GameObject DLCWarning { get; private set; }

		public static void LoadAssets()
		{
			if (!loaded)
			{
				PeaksOfArchipelago.Logger.LogInfo((object)"Loading Assets...");
				assetBundle = AssetBundle.LoadFromFile(Path.Combine(Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), "Assets"), "peaksofbundle"));
				ChatBoxPrefab = assetBundle.LoadAsset<GameObject>("ChatBox");
				ChatMessagePrefab = assetBundle.LoadAsset<GameObject>("ChatMessage");
				LoginScreen = assetBundle.LoadAsset<GameObject>("LogInPrefab");
				APLogo = assetBundle.LoadAsset<GameObject>("APLogo");
				Notificator = assetBundle.LoadAsset<GameObject>("NotificationMaker");
				Notification = assetBundle.LoadAsset<GameObject>("Notification");
				ProgressDisplay = assetBundle.LoadAsset<GameObject>("ProgressDisplay");
				BookEntryPrefab = assetBundle.LoadAsset<GameObject>("BookPanel");
				PeakEntryPrefab = assetBundle.LoadAsset<GameObject>("PeakEntry");
				ProgressScreenTutorial = assetBundle.LoadAsset<GameObject>("ProgressScreenTutorial");
				TrapDisplay = assetBundle.LoadAsset<GameObject>("TrapDisplay");
				TrapTimer = assetBundle.LoadAsset<GameObject>("TrapTimer");
				DLCWarning = assetBundle.LoadAsset<GameObject>("NoDLCAlert");
				PeaksOfArchipelago.Logger.LogInfo((object)"Assets Loaded");
				loaded = true;
			}
		}
	}
}