using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text.Json;
using AskaShared.Game;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Core.Logging.Interpolation;
using BepInEx.Logging;
using BepInEx.Unity.IL2CPP;
using Cinemachine;
using Fusion;
using HarmonyLib;
using Il2CppInterop.Runtime;
using Il2CppInterop.Runtime.Injection;
using Il2CppInterop.Runtime.InteropTypes;
using Il2CppInterop.Runtime.InteropTypes.Arrays;
using Il2CppSystem;
using Il2CppSystem.Collections.Generic;
using Microsoft.CodeAnalysis;
using SSSGame;
using SSSGame.Controllers;
using SSSGame.Network;
using SSSGame.Render;
using SSSGame.UI;
using SandSailorStudio.Inventory;
using SandSailorStudio.Localization;
using SandSailorStudio.Storage;
using SandSailorStudio.UI;
using TMPro;
using UnityEngine;
using UnityEngine.Events;
using UnityEngine.SceneManagement;
using UnityEngine.UI;
using UnityEngine.VFX;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName = ".NET 6.0")]
[assembly: AssemblyCompany("Bifrost")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("0.2.0")]
[assembly: AssemblyInformationalVersion("0.2.0+d91bb6825f5a0f8e79d1c5fedeec0b352ae58d6b")]
[assembly: AssemblyProduct("Bifrost")]
[assembly: AssemblyTitle("Bifrost")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.2.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace AskaTeleportation
{
	internal static class ArchConfirmDialog
	{
		private const string Title = "Open Portal";

		private const string ConfirmCaptionKey = "common.confirm";

		private const string CancelCaptionKey = "common.cancel";

		private const string Prefix = "[Portals][attune]";

		private const float VanishGraceSeconds = 5f;

		private static Action<ConfirmActionMenu> _confirmHandler;

		private static Action<ConfirmActionMenu> _cancelHandler;

		private static Structure _arch;

		private static Menu _menu;

		private static bool _tracking;

		private static float _lastAliveAt;

		internal static bool IsOpen
		{
			get
			{
				//IL_0028: Unknown result type (might be due to invalid IL or missing references)
				//IL_002e: Expected O, but got Unknown
				try
				{
					return (Object)(object)_menu != (Object)null && _menu.IsActive;
				}
				catch (Exception ex)
				{
					ManualLogSource log = Plugin.Log;
					bool flag = default(bool);
					BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(35, 2, ref flag);
					if (flag)
					{
						((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>("[Portals][attune]");
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" reading the dialog's state threw: ");
						((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(ex.Message);
					}
					log.LogWarning(val);
					return false;
				}
			}
		}

		internal static bool TryOpen(Structure arch)
		{
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fe: Expected O, but got Unknown
			//IL_0220: Unknown result type (might be due to invalid IL or missing references)
			//IL_0227: Expected O, but got Unknown
			//IL_02d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d8: Expected O, but got Unknown
			//IL_032b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0332: Expected O, but got Unknown
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Expected O, but got Unknown
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Expected O, but got Unknown
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Expected O, but got Unknown
			//IL_0145: Unknown result type (might be due to invalid IL or missing references)
			//IL_014c: Expected O, but got Unknown
			//IL_018c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0193: Expected O, but got Unknown
			//IL_01ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01de: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0202: Unknown result type (might be due to invalid IL or missing references)
			//IL_0209: Unknown result type (might be due to invalid IL or missing references)
			//IL_0212: Expected O, but got Unknown
			//IL_03d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d8: Expected O, but got Unknown
			//IL_037f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0386: Expected O, but got Unknown
			//IL_0441: Unknown result type (might be due to invalid IL or missing references)
			//IL_0448: Expected O, but got Unknown
			if ((Object)(object)arch == (Object)null)
			{
				return false;
			}
			bool flag = default(bool);
			BepInExInfoLogInterpolatedStringHandler val;
			if (_tracking)
			{
				if (!HasVanished())
				{
					ManualLogSource log = Plugin.Log;
					val = new BepInExInfoLogInterpolatedStringHandler(44, 1, ref flag);
					if (flag)
					{
						((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>("[Portals][attune]");
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" a confirm dialog is already open - ignoring");
					}
					log.LogInfo(val);
					return false;
				}
				ManualLogSource log2 = Plugin.Log;
				val = new BepInExInfoLogInterpolatedStringHandler(68, 1, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>("[Portals][attune]");
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" the previous confirm dialog vanished without a callback - reopening");
				}
				log2.LogInfo(val);
				Forget();
			}
			ItemCost portalCost = Plugin.PortalCost;
			if (portalCost == null || (!portalCost.IsFree && !portalCost.IsResolved))
			{
				Toast("The portal cost is not configured.", (NotificationType)1);
				ManualLogSource log3 = Plugin.Log;
				BepInExWarningLogInterpolatedStringHandler val2 = new BepInExWarningLogInterpolatedStringHandler(25, 1, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<string>("[Portals][attune]");
					((BepInExLogInterpolatedStringHandler)val2).AppendLiteral(" refused: cost unresolved");
				}
				log3.LogWarning(val2);
				return false;
			}
			MenuManager instance;
			try
			{
				instance = MenuManager.Instance;
			}
			catch (Exception ex)
			{
				ManualLogSource log4 = Plugin.Log;
				BepInExErrorLogInterpolatedStringHandler val3 = new BepInExErrorLogInterpolatedStringHandler(37, 2, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val3).AppendFormatted<string>("[Portals][attune]");
					((BepInExLogInterpolatedStringHandler)val3).AppendLiteral(" reading MenuManager.Instance threw: ");
					((BepInExLogInterpolatedStringHandler)val3).AppendFormatted<Exception>(ex);
				}
				log4.LogError(val3);
				return false;
			}
			bool flag2 = default(bool);
			if ((Object)(object)instance == (Object)null)
			{
				ManualLogSource log5 = Plugin.Log;
				BepInExWarningLogInterpolatedStringHandler val2 = new BepInExWarningLogInterpolatedStringHandler(63, 1, ref flag2);
				if (flag2)
				{
					((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<string>("[Portals][attune]");
					((BepInExLogInterpolatedStringHandler)val2).AppendLiteral(" there is no MenuManager - the confirm dialog cannot be opened.");
				}
				log5.LogWarning(val2);
				return false;
			}
			ConfirmActionMenu val4 = ResolvePrefab(instance, arch);
			if ((Object)(object)val4 == (Object)null)
			{
				ManualLogSource log6 = Plugin.Log;
				BepInExWarningLogInterpolatedStringHandler val2 = new BepInExWarningLogInterpolatedStringHandler(85, 1, ref flag2);
				if (flag2)
				{
					((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<string>("[Portals][attune]");
					((BepInExLogInterpolatedStringHandler)val2).AppendLiteral(" no ConfirmActionMenu prefab could be resolved - the confirm dialog cannot be opened.");
				}
				log6.LogWarning(val2);
				return false;
			}
			string text = "Open this portal for " + portalCost.Describe() + "?";
			ConfirmActionMenuParameters val5;
			try
			{
				val5 = new ConfirmActionMenuParameters
				{
					Title = "Open Portal",
					Message = text,
					ConfirmMessage = "common.confirm",
					CancelMessage = "common.cancel",
					CloseOnConfirm = true,
					HideCancelButton = false,
					DontCloseOnEscape = false
				};
			}
			catch (Exception ex2)
			{
				ManualLogSource log7 = Plugin.Log;
				BepInExErrorLogInterpolatedStringHandler val3 = new BepInExErrorLogInterpolatedStringHandler(40, 2, ref flag2);
				if (flag2)
				{
					((BepInExLogInterpolatedStringHandler)val3).AppendFormatted<string>("[Portals][attune]");
					((BepInExLogInterpolatedStringHandler)val3).AppendLiteral(" building the confirm parameters threw: ");
					((BepInExLogInterpolatedStringHandler)val3).AppendFormatted<Exception>(ex2);
				}
				log7.LogError(val3);
				return false;
			}
			_arch = arch;
			_confirmHandler = HandleConfirm;
			_cancelHandler = HandleCancel;
			try
			{
				val5.OnConfirm = DelegateSupport.ConvertDelegate<Action<ConfirmActionMenu>>((Delegate)_confirmHandler);
				val5.OnCancel = DelegateSupport.ConvertDelegate<Action<ConfirmActionMenu>>((Delegate)_cancelHandler);
			}
			catch (Exception ex3)
			{
				ManualLogSource log8 = Plugin.Log;
				BepInExErrorLogInterpolatedStringHandler val3 = new BepInExErrorLogInterpolatedStringHandler(48, 2, ref flag2);
				if (flag2)
				{
					((BepInExLogInterpolatedStringHandler)val3).AppendFormatted<string>("[Portals][attune]");
					((BepInExLogInterpolatedStringHandler)val3).AppendLiteral(" converting the confirm/cancel callbacks threw: ");
					((BepInExLogInterpolatedStringHandler)val3).AppendFormatted<Exception>(ex3);
				}
				log8.LogError(val3);
				Forget();
				return false;
			}
			Menu val6;
			try
			{
				val6 = instance.OpenMenuPrefab((Menu)(object)val4, (MenuParameters)(object)val5);
			}
			catch (Exception ex4)
			{
				ManualLogSource log9 = Plugin.Log;
				BepInExErrorLogInterpolatedStringHandler val3 = new BepInExErrorLogInterpolatedStringHandler(35, 2, ref flag2);
				if (flag2)
				{
					((BepInExLogInterpolatedStringHandler)val3).AppendFormatted<string>("[Portals][attune]");
					((BepInExLogInterpolatedStringHandler)val3).AppendLiteral(" opening the confirm dialog threw: ");
					((BepInExLogInterpolatedStringHandler)val3).AppendFormatted<Exception>(ex4);
				}
				log9.LogError(val3);
				Forget();
				return false;
			}
			if ((Object)(object)val6 == (Object)null)
			{
				ManualLogSource log10 = Plugin.Log;
				BepInExWarningLogInterpolatedStringHandler val2 = new BepInExWarningLogInterpolatedStringHandler(67, 1, ref flag2);
				if (flag2)
				{
					((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<string>("[Portals][attune]");
					((BepInExLogInterpolatedStringHandler)val2).AppendLiteral(" OpenMenuPrefab returned nothing - the confirm dialog did not open.");
				}
				log10.LogWarning(val2);
				Forget();
				return false;
			}
			_menu = val6;
			_tracking = true;
			_lastAliveAt = SafeNow();
			ManualLogSource log11 = Plugin.Log;
			val = new BepInExInfoLogInterpolatedStringHandler(35, 3, ref flag2);
			if (flag2)
			{
				((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>("[Portals][attune]");
				((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" dialog opened for the arch at ");
				((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(ArchInteraction.PositionText(arch));
				((BepInExLogInterpolatedStringHandler)val).AppendLiteral(": '");
				((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(text);
				((BepInExLogInterpolatedStringHandler)val).AppendLiteral("'");
			}
			log11.LogInfo(val);
			if (!RawTextRenders("Open Portal"))
			{
				ManualLogSource log12 = Plugin.Log;
				BepInExWarningLogInterpolatedStringHandler val2 = new BepInExWarningLogInterpolatedStringHandler(152, 1, ref flag2);
				if (flag2)
				{
					((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<string>("[Portals][attune]");
					((BepInExLogInterpolatedStringHandler)val2).AppendLiteral(" the localizer does not pass unknown keys through, so the dialog's title and message may not read as written - repeating the question as a notification.");
				}
				log12.LogWarning(val2);
				Toast(text);
			}
			return true;
		}

		private static void HandleConfirm(ConfirmActionMenu menu)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Expected O, but got Unknown
			Structure arch = _arch;
			Forget();
			try
			{
				Attune(arch);
			}
			catch (Exception ex)
			{
				ManualLogSource log = Plugin.Log;
				bool flag = default(bool);
				BepInExErrorLogInterpolatedStringHandler val = new BepInExErrorLogInterpolatedStringHandler(34, 2, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>("[Portals][attune]");
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" handling the confirmation threw: ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<Exception>(ex);
				}
				log.LogError(val);
			}
		}

		private static void HandleCancel(ConfirmActionMenu menu)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Expected O, but got Unknown
			Forget();
			ManualLogSource log = Plugin.Log;
			bool flag = default(bool);
			BepInExInfoLogInterpolatedStringHandler val = new BepInExInfoLogInterpolatedStringHandler(10, 1, ref flag);
			if (flag)
			{
				((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>("[Portals][attune]");
				((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" cancelled");
			}
			log.LogInfo(val);
		}

		private static void Attune(Structure arch)
		{
			//IL_0165: Unknown result type (might be due to invalid IL or missing references)
			//IL_016c: Expected O, but got Unknown
			//IL_025e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0265: Expected O, but got Unknown
			//IL_035c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0363: Expected O, but got Unknown
			//IL_03d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_03df: Expected O, but got Unknown
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Expected O, but got Unknown
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Expected O, but got Unknown
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_0118: Expected O, but got Unknown
			//IL_01d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01db: Expected O, but got Unknown
			//IL_02b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b9: Expected O, but got Unknown
			if ((Object)(object)arch == (Object)null)
			{
				return;
			}
			PortalRegistry current = PortalRegistry.Current;
			if (current == null)
			{
				Toast("Portals are not ready yet.", (NotificationType)1);
				return;
			}
			bool flag = default(bool);
			if (!ArchTargeting.TrySnapshot(arch, out var snapshot))
			{
				Toast("That portal cannot be opened any more.", (NotificationType)1);
				ManualLogSource log = Plugin.Log;
				BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(75, 1, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>("[Portals][attune]");
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" confirm refused: the arch is gone, dismantled or not built - nothing taken");
				}
				log.LogWarning(val);
				return;
			}
			if (current.TryFindByArch(arch, out var record))
			{
				Toast(record.Name + " is already open.");
				return;
			}
			ItemCost portalCost = Plugin.PortalCost;
			if (portalCost == null || (!portalCost.IsFree && !portalCost.IsResolved))
			{
				Toast("The portal cost is not configured.", (NotificationType)1);
				ManualLogSource log2 = Plugin.Log;
				BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(33, 1, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>("[Portals][attune]");
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" confirm refused: cost unresolved");
				}
				log2.LogWarning(val);
				return;
			}
			int num = 0;
			BepInExInfoLogInterpolatedStringHandler val3;
			if (!portalCost.IsFree)
			{
				ItemCollection val2 = PlayerInventory();
				if (val2 == null)
				{
					Toast("Portals are not ready yet.", (NotificationType)1);
					ManualLogSource log3 = Plugin.Log;
					BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(37, 1, ref flag);
					if (flag)
					{
						((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>("[Portals][attune]");
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" confirm refused: no player inventory");
					}
					log3.LogWarning(val);
					return;
				}
				int itemQuantity;
				try
				{
					itemQuantity = val2.GetItemQuantity(portalCost.Info);
				}
				catch (Exception ex)
				{
					Toast("Portals are not ready yet.", (NotificationType)1);
					ManualLogSource log4 = Plugin.Log;
					BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(41, 2, ref flag);
					if (flag)
					{
						((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>("[Portals][attune]");
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" confirm refused: inventory read failed: ");
						((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(ex.Message);
					}
					log4.LogWarning(val);
					return;
				}
				if (itemQuantity < portalCost.Count)
				{
					Toast("Opening needs " + portalCost.Describe() + ".", (NotificationType)1);
					ManualLogSource log5 = Plugin.Log;
					val3 = new BepInExInfoLogInterpolatedStringHandler(31, 4, ref flag);
					if (flag)
					{
						((BepInExLogInterpolatedStringHandler)val3).AppendFormatted<string>("[Portals][attune]");
						((BepInExLogInterpolatedStringHandler)val3).AppendLiteral(" confirm refused: have ");
						((BepInExLogInterpolatedStringHandler)val3).AppendFormatted<int>(itemQuantity);
						((BepInExLogInterpolatedStringHandler)val3).AppendLiteral(", need ");
						((BepInExLogInterpolatedStringHandler)val3).AppendFormatted<int>(portalCost.Count);
						((BepInExLogInterpolatedStringHandler)val3).AppendLiteral(" ");
						((BepInExLogInterpolatedStringHandler)val3).AppendFormatted<string>(portalCost.ItemName);
					}
					log5.LogInfo(val3);
					return;
				}
				try
				{
					num = val2.RemoveItems(portalCost.Info, portalCost.Count);
				}
				catch (Exception ex2)
				{
					ManualLogSource log6 = Plugin.Log;
					BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(39, 2, ref flag);
					if (flag)
					{
						((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>("[Portals][attune]");
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" confirm aborted: cost removal failed: ");
						((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(ex2.Message);
					}
					log6.LogWarning(val);
					return;
				}
				if (num < portalCost.Count)
				{
					ManualLogSource log7 = Plugin.Log;
					BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(31, 4, ref flag);
					if (flag)
					{
						((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>("[Portals][attune]");
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" confirm aborted: removed ");
						((BepInExLogInterpolatedStringHandler)val).AppendFormatted<int>(num);
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" of ");
						((BepInExLogInterpolatedStringHandler)val).AppendFormatted<int>(portalCost.Count);
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" ");
						((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(portalCost.ItemName);
					}
					log7.LogWarning(val);
					Refund(val2, portalCost, num);
					Toast("Opening needs " + portalCost.Describe() + ".", (NotificationType)1);
					return;
				}
			}
			PortalRecord portalRecord = current.Attune(snapshot);
			try
			{
				PortalVisuals.Apply(portalRecord, arch);
			}
			catch (Exception ex3)
			{
				ManualLogSource log8 = Plugin.Log;
				BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(36, 3, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>("[Portals][attune]");
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" the rune could not be applied to ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(portalRecord.Name);
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral(": ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(ex3.Message);
				}
				log8.LogWarning(val);
			}
			PortalNaming.ApplyPortalName(arch, portalRecord);
			Toast(portalRecord.Name + " opened.");
			ManualLogSource log9 = Plugin.Log;
			val3 = new BepInExInfoLogInterpolatedStringHandler(32, 4, ref flag);
			if (flag)
			{
				((BepInExLogInterpolatedStringHandler)val3).AppendFormatted<string>("[Portals][attune]");
				((BepInExLogInterpolatedStringHandler)val3).AppendLiteral(" confirmed: consumed ");
				((BepInExLogInterpolatedStringHandler)val3).AppendFormatted<int>(num);
				((BepInExLogInterpolatedStringHandler)val3).AppendLiteral(" ");
				((BepInExLogInterpolatedStringHandler)val3).AppendFormatted<string>(portalCost.IsFree ? "(free)" : portalCost.ItemName);
				((BepInExLogInterpolatedStringHandler)val3).AppendLiteral(", attuned ");
				((BepInExLogInterpolatedStringHandler)val3).AppendFormatted<string>(portalRecord.Name);
			}
			log9.LogInfo(val3);
			if (current.Portals.Count >= 2)
			{
				PortalTool.RequestDestinationDialog(portalRecord);
			}
		}

		private static void Refund(ItemCollection inventory, ItemCost cost, int consumed)
		{
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0105: Expected O, but got Unknown
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Expected O, but got Unknown
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Expected O, but got Unknown
			if (inventory == null || cost == null || consumed <= 0)
			{
				return;
			}
			bool flag = default(bool);
			try
			{
				int num = inventory.AddItems(cost.Info, consumed);
				if (num < consumed)
				{
					ManualLogSource log = Plugin.Log;
					BepInExErrorLogInterpolatedStringHandler val = new BepInExErrorLogInterpolatedStringHandler(42, 5, ref flag);
					if (flag)
					{
						((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>("[Portals][attune]");
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" refund incomplete: ");
						((BepInExLogInterpolatedStringHandler)val).AppendFormatted<int>(num);
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" of ");
						((BepInExLogInterpolatedStringHandler)val).AppendFormatted<int>(consumed);
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" ");
						((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(cost.ItemName);
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" returned - ");
						((BepInExLogInterpolatedStringHandler)val).AppendFormatted<int>(consumed - num);
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" lost");
					}
					log.LogError(val);
				}
				else
				{
					ManualLogSource log2 = Plugin.Log;
					BepInExInfoLogInterpolatedStringHandler val2 = new BepInExInfoLogInterpolatedStringHandler(11, 3, ref flag);
					if (flag)
					{
						((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<string>("[Portals][attune]");
						((BepInExLogInterpolatedStringHandler)val2).AppendLiteral(" refunded ");
						((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<int>(consumed);
						((BepInExLogInterpolatedStringHandler)val2).AppendLiteral(" ");
						((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<string>(cost.ItemName);
					}
					log2.LogInfo(val2);
				}
			}
			catch (Exception ex)
			{
				ManualLogSource log3 = Plugin.Log;
				BepInExErrorLogInterpolatedStringHandler val = new BepInExErrorLogInterpolatedStringHandler(24, 4, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>("[Portals][attune]");
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" refund failed: ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<int>(consumed);
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(cost.ItemName);
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" lost: ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<Exception>(ex);
				}
				log3.LogError(val);
			}
		}

		private static ItemCollection PlayerInventory()
		{
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Expected O, but got Unknown
			try
			{
				Character localCharacter = PortalTool.LocalCharacter;
				if ((Object)(object)localCharacter == (Object)null)
				{
					return null;
				}
				InventoryComponent inventory = localCharacter.Inventory;
				return ((Object)(object)inventory != (Object)null) ? inventory.GetItemCollection() : null;
			}
			catch (Exception ex)
			{
				ManualLogSource log = Plugin.Log;
				bool flag = default(bool);
				BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(33, 2, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>("[Portals][attune]");
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" player inventory lookup failed: ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(ex.Message);
				}
				log.LogWarning(val);
				return null;
			}
		}

		private static bool HasVanished()
		{
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Expected O, but got Unknown
			if (!_tracking)
			{
				return true;
			}
			float num = SafeNow();
			bool flag;
			try
			{
				flag = (Object)(object)_menu != (Object)null && _menu.IsActive;
			}
			catch (Exception ex)
			{
				ManualLogSource log = Plugin.Log;
				bool flag2 = default(bool);
				BepInExErrorLogInterpolatedStringHandler val = new BepInExErrorLogInterpolatedStringHandler(35, 2, ref flag2);
				if (flag2)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>("[Portals][attune]");
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" reading the dialog's state threw: ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<Exception>(ex);
				}
				log.LogError(val);
				flag = false;
			}
			if (flag)
			{
				_lastAliveAt = num;
				return false;
			}
			return num - _lastAliveAt > 5f;
		}

		private static void Forget()
		{
			_tracking = false;
			_menu = null;
			_arch = null;
		}

		internal static void Reset()
		{
			Forget();
			_lastAliveAt = 0f;
		}

		private static ConfirmActionMenu ResolvePrefab(MenuManager manager, Structure prefabSource)
		{
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Expected O, but got Unknown
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Expected O, but got Unknown
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Expected O, but got Unknown
			bool flag = default(bool);
			try
			{
				ConfirmActionMenu prefab = manager.GetPrefab<ConfirmActionMenu>();
				if ((Object)(object)prefab != (Object)null)
				{
					return prefab;
				}
				ManualLogSource log = Plugin.Log;
				BepInExInfoLogInterpolatedStringHandler val = new BepInExInfoLogInterpolatedStringHandler(106, 1, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>("[Portals][attune]");
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" MenuManager has no registered ConfirmActionMenu prefab - falling back to the arch's own dismantle dialog.");
				}
				log.LogInfo(val);
			}
			catch (Exception ex)
			{
				ManualLogSource log2 = Plugin.Log;
				BepInExWarningLogInterpolatedStringHandler val2 = new BepInExWarningLogInterpolatedStringHandler(104, 2, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<string>("[Portals][attune]");
					((BepInExLogInterpolatedStringHandler)val2).AppendLiteral(" MenuManager.GetPrefab<ConfirmActionMenu>() failed (");
					((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<string>(ex.Message);
					((BepInExLogInterpolatedStringHandler)val2).AppendLiteral(") - falling back to the arch's own dismantle dialog.");
				}
				log2.LogWarning(val2);
			}
			try
			{
				if ((Object)(object)prefabSource != (Object)null)
				{
					ConfirmActionMenu confirmDismantleMenu = prefabSource._confirmDismantleMenu;
					if ((Object)(object)confirmDismantleMenu != (Object)null)
					{
						return confirmDismantleMenu;
					}
				}
			}
			catch (Exception ex2)
			{
				ManualLogSource log3 = Plugin.Log;
				BepInExErrorLogInterpolatedStringHandler val3 = new BepInExErrorLogInterpolatedStringHandler(51, 2, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val3).AppendFormatted<string>("[Portals][attune]");
					((BepInExLogInterpolatedStringHandler)val3).AppendLiteral(" reading the arch's dismantle dialog prefab threw: ");
					((BepInExLogInterpolatedStringHandler)val3).AppendFormatted<Exception>(ex2);
				}
				log3.LogError(val3);
			}
			return null;
		}

		private static bool RawTextRenders(string sample)
		{
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Expected O, but got Unknown
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Expected O, but got Unknown
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Expected O, but got Unknown
			if (string.IsNullOrEmpty(sample))
			{
				return true;
			}
			bool flag3 = default(bool);
			try
			{
				LocalizationManager instance = LocalizationManager.Instance;
				BepInExInfoLogInterpolatedStringHandler val;
				if ((Object)(object)instance == (Object)null)
				{
					ManualLogSource log = Plugin.Log;
					bool flag = default(bool);
					val = new BepInExInfoLogInterpolatedStringHandler(108, 1, ref flag);
					if (flag)
					{
						((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>("[Portals][attune]");
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" there is no LocalizationManager to check raw-text rendering against - assuming the text renders as written.");
					}
					log.LogInfo(val);
					return true;
				}
				string text = instance.Loc(sample, false);
				bool flag2 = string.Equals(text, sample, StringComparison.Ordinal);
				ManualLogSource log2 = Plugin.Log;
				val = new BepInExInfoLogInterpolatedStringHandler(54, 4, ref flag3);
				if (flag3)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>("[Portals][attune]");
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" raw-text check: Loc(\"");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(sample);
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("\") -> \"");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(text);
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("\" (renders as written: ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(flag2 ? "yes" : "NO");
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral(").");
				}
				log2.LogInfo(val);
				return flag2;
			}
			catch (Exception ex)
			{
				ManualLogSource log3 = Plugin.Log;
				BepInExErrorLogInterpolatedStringHandler val2 = new BepInExErrorLogInterpolatedStringHandler(27, 2, ref flag3);
				if (flag3)
				{
					((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<string>("[Portals][attune]");
					((BepInExLogInterpolatedStringHandler)val2).AppendLiteral(" the raw-text check threw: ");
					((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<Exception>(ex);
				}
				log3.LogError(val2);
				return true;
			}
		}

		private static float SafeNow()
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Expected O, but got Unknown
			try
			{
				return Time.unscaledTime;
			}
			catch (Exception ex)
			{
				ManualLogSource log = Plugin.Log;
				bool flag = default(bool);
				BepInExErrorLogInterpolatedStringHandler val = new BepInExErrorLogInterpolatedStringHandler(26, 2, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>("[Portals][attune]");
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" reading the clock threw: ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<Exception>(ex);
				}
				log.LogError(val);
				return 0f;
			}
		}

		private static void Toast(string message)
		{
			Toast(message, (NotificationType)0);
		}

		private static void Toast(string message, NotificationType type)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Invalid comparison between Unknown and I4
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Expected O, but got Unknown
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Expected O, but got Unknown
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			bool flag = default(bool);
			if ((int)type == 1)
			{
				try
				{
					string text = message;
					int hashCode = message.GetHashCode();
					float num = 1f;
					Color val = default(Color);
					((Color)(ref val))..ctor(0.85f, 0.2f, 0.18f, 1f);
					NotificationMenu.DisplayStacking((NotificationType)1, (StackingType)0, ref text, ref hashCode, ref num, (Sprite)null, val, val);
					return;
				}
				catch (Exception ex)
				{
					ManualLogSource log = Plugin.Log;
					BepInExWarningLogInterpolatedStringHandler val2 = new BepInExWarningLogInterpolatedStringHandler(41, 2, ref flag);
					if (flag)
					{
						((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<string>("[Portals][attune]");
						((BepInExLogInterpolatedStringHandler)val2).AppendLiteral(" red notification failed, using default: ");
						((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<string>(ex.Message);
					}
					log.LogWarning(val2);
				}
			}
			try
			{
				string text2 = message;
				NotificationMenu.Display(type, ref text2, false);
			}
			catch (Exception ex2)
			{
				ManualLogSource log2 = Plugin.Log;
				BepInExWarningLogInterpolatedStringHandler val2 = new BepInExWarningLogInterpolatedStringHandler(22, 2, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<string>("[Portals][attune]");
					((BepInExLogInterpolatedStringHandler)val2).AppendLiteral(" notification failed: ");
					((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<string>(ex2.Message);
				}
				log2.LogWarning(val2);
			}
		}
	}
	internal static class ArchInteraction
	{
		internal const string HolderName = "PortalDeposit";

		private const string AreaChildName = "ActivityInteractionArea";

		private const string EyeOfOdinPathFragment = "InteractionAreaComplete/StorageInteraction";

		internal static readonly List<Structure> Pending = new List<Structure>();

		private static readonly HashSet<string> _loggedFailures = new HashSet<string>();

		private static readonly HashSet<int> _refileFailed = new HashSet<int>();

		private static readonly HashSet<IntPtr> _injected = new HashSet<IntPtr>();

		internal static bool WidgetRefreshUnsafe(Structure arch)
		{
			try
			{
				return (Object)(object)arch != (Object)null && _refileFailed.Contains(((Object)arch).GetInstanceID());
			}
			catch (Exception)
			{
				return true;
			}
		}

		private static void L(string message)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Expected O, but got Unknown
			ManualLogSource log = Plugin.Log;
			bool flag = default(bool);
			BepInExInfoLogInterpolatedStringHandler val = new BepInExInfoLogInterpolatedStringHandler(18, 1, ref flag);
			if (flag)
			{
				((BepInExLogInterpolatedStringHandler)val).AppendLiteral("[Portals][attune] ");
				((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(message);
			}
			log.LogInfo(val);
		}

		private static void LogOnce(string key, string message)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Expected O, but got Unknown
			if (_loggedFailures.Add(key))
			{
				ManualLogSource log = Plugin.Log;
				bool flag = default(bool);
				BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(18, 1, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("[Portals][attune] ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(message);
				}
				log.LogWarning(val);
			}
		}

		internal static bool IsInjected(Structure arch)
		{
			return (Object)(object)FindHolder(arch) != (Object)null;
		}

		internal static Interaction InjectedInteractionFor(Structure arch)
		{
			try
			{
				Transform val = FindHolder(arch);
				if ((Object)(object)val == (Object)null)
				{
					return null;
				}
				StorageInteraction val2 = FindStorage(val, (StorageInteractionType)4);
				return ((Object)(object)val2 != (Object)null) ? ((Il2CppObjectBase)val2).TryCast<Interaction>() : null;
			}
			catch (Exception ex)
			{
				LogOnce("injected-interaction-for", "InjectedInteractionFor failed: " + ex.Message);
				return null;
			}
		}

		internal static bool TryGetArch(InteractionSession session, out Structure arch)
		{
			arch = null;
			try
			{
				if (session == null)
				{
					return false;
				}
				return TryGetArch(session.Interaction, out arch);
			}
			catch (Exception ex)
			{
				LogOnce("try-get-arch", "TryGetArch failed: " + ex.Message);
				arch = null;
				return false;
			}
		}

		internal static bool TryGetArch(Interaction interaction, out Structure arch)
		{
			arch = null;
			try
			{
				if ((Object)(object)interaction == (Object)null)
				{
					return false;
				}
				if (!_injected.Contains(((Il2CppObjectBase)interaction).Pointer))
				{
					return false;
				}
				Transform val = ((Component)interaction).transform;
				while ((Object)(object)val != (Object)null && ((Object)val).name != "PortalDeposit")
				{
					val = val.parent;
				}
				if ((Object)(object)val == (Object)null)
				{
					return false;
				}
				Structure componentInParent = ((Component)val).GetComponentInParent<Structure>();
				if ((Object)(object)componentInParent == (Object)null || !ArchTargeting.IsArch(componentInParent))
				{
					return false;
				}
				arch = componentInParent;
				return true;
			}
			catch (Exception ex)
			{
				LogOnce("try-get-arch-interaction", "TryGetArch(Interaction) failed: " + ex.Message);
				arch = null;
				return false;
			}
		}

		internal static bool TryInject(Structure arch, out string reason)
		{
			//IL_0145: Unknown result type (might be due to invalid IL or missing references)
			//IL_014b: Expected O, but got Unknown
			GameObject val = null;
			try
			{
				if ((Object)(object)arch == (Object)null)
				{
					reason = "no-arch";
					return false;
				}
				if (!ArchTargeting.IsArch(arch))
				{
					reason = "not-an-arch";
					return false;
				}
				bool dismantled;
				bool isActive;
				try
				{
					dismantled = arch.Dismantled;
					isActive = arch.IsActive;
				}
				catch (Exception ex)
				{
					LogOnce("arch-state", "arch state unreadable: " + ex.Message);
					reason = "arch-state-unreadable";
					return false;
				}
				if (dismantled)
				{
					reason = "dismantled";
					return false;
				}
				if (!isActive)
				{
					reason = "not-built";
					return false;
				}
				if (ArchTargeting.IsUnderConstruction(arch))
				{
					reason = "not-built";
					return false;
				}
				StructureInteractionArea val2 = FindArea(arch);
				if ((Object)(object)val2 == (Object)null)
				{
					reason = "no-interaction-area";
					return false;
				}
				if ((Object)(object)((Component)val2).transform.Find("PortalDeposit") != (Object)null)
				{
					reason = "already-injected";
					return false;
				}
				INetworkInteractable val3 = ResolveArchNi(val2);
				if (val3 == null)
				{
					reason = "no-network-interactable";
					return false;
				}
				Pickable areaPickable = ResolveAreaPickable(val2);
				if (!FindEyeOfOdinSource(out var sourceActivation, out var sourceContainer) || (Object)(object)sourceActivation == (Object)null || (Object)(object)sourceContainer == (Object)null)
				{
					reason = "source-missing";
					return false;
				}
				val = new GameObject("PortalDeposit");
				val.SetActive(false);
				val.transform.SetParent(((Component)val2).transform, false);
				GameObject val4 = Object.Instantiate<GameObject>(sourceActivation, val.transform, false);
				((Object)val4).name = "ActivationInteraction";
				GameObject obj = Object.Instantiate<GameObject>(sourceContainer, val.transform, false);
				((Object)obj).name = "Container";
				ItemContainerComponent component = obj.GetComponent<ItemContainerComponent>();
				if ((Object)(object)component == (Object)null)
				{
					LogOnce("clone-container", "cloned Container has no ItemContainerComponent");
					Cleanup(val);
					reason = "container-missing";
					return false;
				}
				InitializeContainer(component);
				DestroyAll<NetworkActivationState>(val4);
				DestroyAll<AnimatorEventPlaySounds>(val4);
				DestroyAll<ActivationInteraction>(val4);
				StorageInteraction val5 = KeepMenuStorageOnly(val4);
				if ((Object)(object)val5 == (Object)null)
				{
					LogOnce("clone-incomplete", "clone yielded no InventoryMenu StorageInteraction");
					Cleanup(val);
					reason = "clone-incomplete";
					return false;
				}
				RePointStorage(val5, component, ((Component)arch).gameObject);
				List<Interaction> list = new List<Interaction> { (Interaction)(object)val5 };
				BindAreas(val2, list);
				val.SetActive(true);
				for (int i = 0; i < list.Count; i++)
				{
					try
					{
						list[i].InitializeInteractable();
					}
					catch (Exception ex2)
					{
						LogOnce("init-interactable", "InitializeInteractable failed: " + ex2.Message);
					}
				}
				for (int j = 0; j < list.Count; j++)
				{
					Interaction it = list[j];
					MoveToArchInteractable(val3, it);
					RegisterWithInteractable(val3, it);
					EnsurePickable(it, areaPickable);
				}
				val.SetActive(false);
				val.SetActive(true);
				RegisterWithArea(val2, list);
				ResyncContainer(val5, component);
				UnfileFromEyeCollection(component, val, arch);
				NoteInjected(list);
				L("injected arch at " + PositionText(arch));
				reason = null;
				return true;
			}
			catch (Exception ex3)
			{
				LogOnce("inject", "injection failed: " + ex3.Message);
				Cleanup(val);
				reason = "exception";
				return false;
			}
		}

		private static StorageInteraction KeepMenuStorageOnly(GameObject cloneActivation)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Invalid comparison between Unknown and I4
			StorageInteraction val = null;
			Il2CppArrayBase<StorageInteraction> components = cloneActivation.GetComponents<StorageInteraction>();
			int num = components?.Length ?? 0;
			for (int i = 0; i < num; i++)
			{
				StorageInteraction val2 = components[i];
				if ((Object)(object)val2 == (Object)null)
				{
					continue;
				}
				if ((int)ReadStorageType(val2) == 4 && (Object)(object)val == (Object)null)
				{
					val = val2;
					continue;
				}
				try
				{
					Object.DestroyImmediate((Object)(object)val2);
				}
				catch (Exception ex)
				{
					LogOnce("destroy-storage", "destroying a cloned StorageInteraction failed: " + ex.Message);
				}
			}
			return val;
		}

		private static void RePointStorage(StorageInteraction storage, ItemContainerComponent container, GameObject archRoot)
		{
			if ((Object)(object)storage == (Object)null)
			{
				return;
			}
			try
			{
				storage.storageContainer = container;
			}
			catch (Exception ex)
			{
				LogOnce("storage-container", "storageContainer failed: " + ex.Message);
			}
			try
			{
				storage.Container = container.container;
			}
			catch (Exception ex2)
			{
				LogOnce("container", "Container failed: " + ex2.Message);
			}
			try
			{
				((Interaction)storage).host = archRoot;
			}
			catch (Exception ex3)
			{
				LogOnce("host", "host failed: " + ex3.Message);
			}
			try
			{
				((Interaction)storage).order = (InteractionOrder)0;
			}
			catch (Exception ex4)
			{
				LogOnce("order", "order failed: " + ex4.Message);
			}
			try
			{
				storage.openStructureOrder = (InteractionOrder)8;
			}
			catch (Exception ex5)
			{
				LogOnce("open-structure-order", "openStructureOrder failed: " + ex5.Message);
			}
			try
			{
				storage.openMilitiaOrder = (InteractionOrder)8;
			}
			catch (Exception ex6)
			{
				LogOnce("open-militia-order", "openMilitiaOrder failed: " + ex6.Message);
			}
			try
			{
				storage.villagerOrder = (InteractionOrder)8;
			}
			catch (Exception ex7)
			{
				LogOnce("villager-order", "villagerOrder failed: " + ex7.Message);
			}
			try
			{
				storage.villagerAbortOrder = (InteractionOrder)8;
			}
			catch (Exception ex8)
			{
				LogOnce("villager-abort-order", "villagerAbortOrder failed: " + ex8.Message);
			}
		}

		private static void InitializeContainer(ItemContainerComponent component)
		{
			bool flag = false;
			try
			{
				flag = component._initialized;
			}
			catch (Exception ex)
			{
				LogOnce("initialized-read", "_initialized read failed: " + ex.Message);
			}
			if (!flag)
			{
				try
				{
					component.Initialize();
				}
				catch (Exception ex2)
				{
					LogOnce("container-init", "ItemContainerComponent.Initialize failed: " + ex2.Message);
				}
			}
		}

		private static void UnfileFromEyeCollection(ItemContainerComponent containerComponent, GameObject holder, Structure arch)
		{
			//IL_0124: Unknown result type (might be due to invalid IL or missing references)
			//IL_0129: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)containerComponent == (Object)null)
			{
				return;
			}
			ItemContainer val = null;
			try
			{
				val = containerComponent.container;
			}
			catch (Exception ex)
			{
				LogOnce("unfile-container-read", "container read failed: " + ex.Message);
			}
			InventoryComponent val2 = null;
			try
			{
				val2 = containerComponent.inventoryComponent;
			}
			catch (Exception ex2)
			{
				LogOnce("unfile-inventory-read", "inventoryComponent read failed: " + ex2.Message);
			}
			if (val == null || (Object)(object)val2 == (Object)null)
			{
				LogOnce("unfile-missing", "cannot unfile container: container or inventoryComponent is null");
				return;
			}
			string text = "?";
			try
			{
				text = PathOf(((Component)val2).transform);
			}
			catch (Exception ex3)
			{
				text = "EX: " + ex3.Message;
			}
			ItemCollection val3 = null;
			try
			{
				val3 = val2.GetItemCollection();
			}
			catch (Exception ex4)
			{
				LogOnce("unfile-collection-read", "GetItemCollection failed: " + ex4.Message);
			}
			if (val3 == null)
			{
				LogOnce("unfile-collection-null", "Eye of Odin inventory has no ItemCollection");
				return;
			}
			try
			{
				val3.RemoveContainer(val);
			}
			catch (Exception ex5)
			{
				LogOnce("unfile-remove", "RemoveContainer failed: " + ex5.Message);
				return;
			}
			bool flag = false;
			try
			{
				GameObject val4 = (((Object)(object)holder != (Object)null) ? holder : ((Component)arch).gameObject);
				ItemCollection val5 = new ItemCollection();
				val5.Setup(val4, "PortalDeposit");
				val5.AddContainer(val);
				flag = val.Inventory != null;
			}
			catch (Exception ex6)
			{
				LogOnce("refile", "re-filing the container into a private collection failed: " + ex6.Message);
			}
			if (!flag)
			{
				try
				{
					_refileFailed.Add(((Object)arch).GetInstanceID());
				}
				catch (Exception ex7)
				{
					LogOnce("refile-mark", "marking the arch failed: " + ex7.Message);
				}
				L("container unfiled from " + text + " collection but NOT re-filed - the widget refresh is skipped for this arch");
			}
			else
			{
				L("container unfiled from " + text + " collection and re-filed into a private one");
			}
		}

		private static void BindAreas(StructureInteractionArea area, List<Interaction> injected)
		{
			IInteractionArea val = null;
			try
			{
				val = ((Il2CppObjectBase)area).TryCast<IInteractionArea>();
			}
			catch (Exception ex)
			{
				LogOnce("area-cast", "area TryCast<IInteractionArea> failed: " + ex.Message);
			}
			if (val == null)
			{
				LogOnce("area-cast-null", "StructureInteractionArea does not cast to IInteractionArea");
				return;
			}
			for (int i = 0; i < injected.Count; i++)
			{
				Interaction val2 = injected[i];
				if ((Object)(object)val2 == (Object)null)
				{
					continue;
				}
				try
				{
					val2._interactionArea = val;
				}
				catch (Exception ex2)
				{
					LogOnce("bind-area", "binding Interaction._interactionArea failed: " + ex2.Message);
				}
				StorageInteraction val3 = null;
				try
				{
					val3 = ((Il2CppObjectBase)val2).TryCast<StorageInteraction>();
				}
				catch (Exception ex3)
				{
					LogOnce("bind-cast", "TryCast<StorageInteraction> failed: " + ex3.Message);
				}
				if (!((Object)(object)val3 == (Object)null))
				{
					try
					{
						val3._interactionArea = val;
					}
					catch (Exception ex4)
					{
						LogOnce("bind-shadow", "binding StorageInteraction._interactionArea failed: " + ex4.Message);
					}
				}
			}
		}

		private static void MoveToArchInteractable(INetworkInteractable archNi, Interaction it)
		{
			if ((Object)(object)it == (Object)null)
			{
				return;
			}
			INetworkInteractable val = null;
			try
			{
				val = it.interactable;
			}
			catch (Exception ex)
			{
				LogOnce("interactable-read", "interaction.interactable read failed: " + ex.Message);
			}
			if (val != null && SamePtr((Il2CppObjectBase)(object)val, (Il2CppObjectBase)(object)archNi))
			{
				return;
			}
			if (val != null)
			{
				try
				{
					val.UnregisterInteraction(it);
				}
				catch (Exception ex2)
				{
					LogOnce("old-unregister", "unregistering from the source interactable failed: " + ex2.Message);
				}
			}
			bool flag = false;
			try
			{
				archNi.MoveInteractionToThis(it);
				flag = true;
			}
			catch (Exception ex3)
			{
				LogOnce("move-interaction", "MoveInteractionToThis failed: " + ex3.Message);
			}
			if (flag)
			{
				return;
			}
			try
			{
				it.interactable = archNi;
			}
			catch (Exception ex4)
			{
				LogOnce("interactable-write", "interaction.interactable write failed: " + ex4.Message);
			}
		}

		private static void RegisterWithInteractable(INetworkInteractable archNi, Interaction it)
		{
			if ((Object)(object)it == (Object)null)
			{
				return;
			}
			bool flag = false;
			try
			{
				flag = archNi.TryRegisterInteraction(it);
			}
			catch (Exception ex)
			{
				LogOnce("register-interactable", "TryRegisterInteraction failed: " + ex.Message);
			}
			if (flag)
			{
				return;
			}
			try
			{
				archNi.MoveInteractionToThis(it);
			}
			catch (Exception ex2)
			{
				LogOnce("register-move", "MoveInteractionToThis retry failed: " + ex2.Message);
			}
			try
			{
				archNi.TryRegisterInteraction(it);
			}
			catch (Exception ex3)
			{
				LogOnce("register-retry", "TryRegisterInteraction retry failed: " + ex3.Message);
			}
		}

		private static void EnsurePickable(Interaction it, Pickable areaPickable)
		{
			if ((Object)(object)it == (Object)null || (Object)(object)areaPickable == (Object)null)
			{
				return;
			}
			Pickable val = null;
			try
			{
				val = it.GetPickable();
			}
			catch (Exception ex)
			{
				LogOnce("pickable-read", "GetPickable failed: " + ex.Message);
			}
			if ((Object)(object)val != (Object)null)
			{
				return;
			}
			try
			{
				it._cachedPickable = areaPickable;
			}
			catch (Exception ex2)
			{
				LogOnce("pickable-write", "_cachedPickable write failed: " + ex2.Message);
			}
		}

		private static void RegisterWithArea(StructureInteractionArea area, List<Interaction> injected)
		{
			List<Interaction> val = null;
			try
			{
				val = ((StandaloneInteractionArea)area).interactions;
			}
			catch (Exception ex)
			{
				LogOnce("area-list-read", "area.interactions read failed: " + ex.Message);
			}
			if (val == null)
			{
				try
				{
					val = (((StandaloneInteractionArea)area).interactions = new List<Interaction>());
				}
				catch (Exception ex2)
				{
					LogOnce("area-list-create", "area.interactions create failed: " + ex2.Message);
					return;
				}
			}
			for (int i = 0; i < injected.Count; i++)
			{
				Interaction val3 = injected[i];
				if (!((Object)(object)val3 == (Object)null))
				{
					try
					{
						val.Add(val3);
					}
					catch (Exception ex3)
					{
						LogOnce("area-list-add", "area.interactions add failed: " + ex3.Message);
					}
				}
			}
			try
			{
				((StandaloneInteractionArea)area).SetAreaDirty();
			}
			catch (Exception ex4)
			{
				LogOnce("set-area-dirty", "SetAreaDirty failed: " + ex4.Message);
			}
		}

		private static void ResyncContainer(StorageInteraction menuStorage, ItemContainerComponent component)
		{
			ItemContainer val = null;
			try
			{
				val = component.container;
			}
			catch (Exception ex)
			{
				LogOnce("resync-read", "container re-read failed: " + ex.Message);
			}
			if (val == null || (Object)(object)menuStorage == (Object)null)
			{
				return;
			}
			try
			{
				menuStorage.storageContainer = component;
			}
			catch (Exception ex2)
			{
				LogOnce("resync-component", "storageContainer resync failed: " + ex2.Message);
			}
			try
			{
				menuStorage.Container = val;
			}
			catch (Exception ex3)
			{
				LogOnce("resync-container", "Container resync failed: " + ex3.Message);
			}
		}

		private static bool FindEyeOfOdinSource(out GameObject sourceActivation, out GameObject sourceContainer)
		{
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Invalid comparison between Unknown and I4
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			sourceActivation = null;
			sourceContainer = null;
			try
			{
				Il2CppArrayBase<StorageInteraction> val = Resources.FindObjectsOfTypeAll<StorageInteraction>();
				int num = val?.Length ?? 0;
				for (int i = 0; i < num; i++)
				{
					StorageInteraction val2 = val[i];
					if ((Object)(object)val2 == (Object)null || (int)ReadStorageType(val2) != 1)
					{
						continue;
					}
					string text;
					try
					{
						text = PathOf(((Component)val2).transform);
					}
					catch
					{
						continue;
					}
					if (text.IndexOf("InteractionAreaComplete/StorageInteraction", StringComparison.Ordinal) < 0)
					{
						continue;
					}
					GameObject gameObject = ((Component)val2).gameObject;
					Transform parent = ((Component)val2).transform.parent;
					Transform val3 = (((Object)(object)parent != (Object)null) ? parent.Find("Container") : null);
					if (!((Object)(object)val3 == (Object)null))
					{
						bool flag;
						try
						{
							Scene scene = gameObject.scene;
							flag = ((Scene)(ref scene)).IsValid();
						}
						catch
						{
							flag = false;
						}
						if (flag || (Object)(object)sourceActivation == (Object)null)
						{
							sourceActivation = gameObject;
							sourceContainer = ((Component)val3).gameObject;
						}
						if (flag)
						{
							break;
						}
					}
				}
				return true;
			}
			catch (Exception ex)
			{
				LogOnce("source-search", "Eye of Odin source search failed: " + ex.Message);
				return false;
			}
		}

		private static StorageInteractionType ReadStorageType(StorageInteraction si)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				return si.storageType;
			}
			catch
			{
				return (StorageInteractionType)4;
			}
		}

		private static StructureInteractionArea FindArea(Structure arch)
		{
			try
			{
				Transform val = ((Component)arch).transform.Find("ActivityInteractionArea");
				if ((Object)(object)val != (Object)null)
				{
					StructureInteractionArea component = ((Component)val).GetComponent<StructureInteractionArea>();
					if ((Object)(object)component != (Object)null)
					{
						return component;
					}
				}
			}
			catch (Exception ex)
			{
				LogOnce("area-find", "interaction-area lookup failed: " + ex.Message);
			}
			try
			{
				return ((Component)arch).GetComponentInChildren<StructureInteractionArea>(true);
			}
			catch (Exception ex2)
			{
				LogOnce("area-search", "interaction-area search failed: " + ex2.Message);
				return null;
			}
		}

		private static Transform FindHolder(Structure arch)
		{
			try
			{
				if ((Object)(object)arch == (Object)null)
				{
					return null;
				}
				StructureInteractionArea val = FindArea(arch);
				return ((Object)(object)val != (Object)null) ? ((Component)val).transform.Find("PortalDeposit") : null;
			}
			catch (Exception ex)
			{
				LogOnce("holder-find", "holder lookup failed: " + ex.Message);
				return null;
			}
		}

		private static StorageInteraction FindStorage(Transform holder, StorageInteractionType want)
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			Il2CppArrayBase<StorageInteraction> componentsInChildren = ((Component)holder).GetComponentsInChildren<StorageInteraction>(true);
			int num = componentsInChildren?.Length ?? 0;
			for (int i = 0; i < num; i++)
			{
				StorageInteraction val = componentsInChildren[i];
				if ((Object)(object)val != (Object)null && ReadStorageType(val) == want)
				{
					return val;
				}
			}
			return null;
		}

		private static INetworkInteractable ResolveArchNi(StructureInteractionArea area)
		{
			NetworkObjectInteractable val = null;
			try
			{
				val = ((Component)area).gameObject.GetComponent<NetworkObjectInteractable>();
			}
			catch (Exception ex)
			{
				LogOnce("ni-get", "NetworkObjectInteractable lookup failed: " + ex.Message);
			}
			if ((Object)(object)val == (Object)null)
			{
				return null;
			}
			try
			{
				return ((Il2CppObjectBase)val).TryCast<INetworkInteractable>();
			}
			catch (Exception ex2)
			{
				LogOnce("ni-cast", "NetworkObjectInteractable cast failed: " + ex2.Message);
				return null;
			}
		}

		private static Pickable ResolveAreaPickable(StructureInteractionArea area)
		{
			try
			{
				return ((Component)area).gameObject.GetComponent<Pickable>();
			}
			catch (Exception ex)
			{
				LogOnce("pickable-get", "area Pickable lookup failed: " + ex.Message);
				return null;
			}
		}

		private static void DestroyAll<T>(GameObject go) where T : Component
		{
			try
			{
				Il2CppArrayBase<T> components = go.GetComponents<T>();
				int num = components?.Length ?? 0;
				for (int i = 0; i < num; i++)
				{
					T val = components[i];
					if (!((Object)(object)val == (Object)null))
					{
						try
						{
							Object.DestroyImmediate((Object)(object)val);
						}
						catch (Exception ex)
						{
							LogOnce("destroy-" + typeof(T).Name, "destroying " + typeof(T).Name + " failed: " + ex.Message);
						}
					}
				}
			}
			catch (Exception ex2)
			{
				LogOnce("destroy-all-" + typeof(T).Name, "sweeping " + typeof(T).Name + " failed: " + ex2.Message);
			}
		}

		private static void NoteInjected(List<Interaction> injected)
		{
			for (int i = 0; i < injected.Count; i++)
			{
				try
				{
					Interaction val = injected[i];
					if ((Object)(object)val != (Object)null)
					{
						_injected.Add(((Il2CppObjectBase)val).Pointer);
					}
				}
				catch (Exception ex)
				{
					LogOnce("note-injected", "recording an injected interaction pointer failed: " + ex.Message);
				}
			}
		}

		private static void Cleanup(GameObject holder)
		{
			if ((Object)(object)holder == (Object)null)
			{
				return;
			}
			try
			{
				Il2CppArrayBase<Interaction> componentsInChildren = holder.GetComponentsInChildren<Interaction>(true);
				int num = componentsInChildren?.Length ?? 0;
				for (int i = 0; i < num; i++)
				{
					Interaction val = componentsInChildren[i];
					if ((Object)(object)val != (Object)null)
					{
						_injected.Remove(((Il2CppObjectBase)val).Pointer);
					}
				}
			}
			catch (Exception ex)
			{
				LogOnce("cleanup-injected", "forgetting a half-built holder's interaction pointers failed: " + ex.Message);
			}
			try
			{
				holder.SetActive(false);
				((Object)holder).name = "PortalDeposit(failed)";
				Object.Destroy((Object)(object)holder);
			}
			catch (Exception ex2)
			{
				LogOnce("cleanup", "tearing down a half-built holder failed: " + ex2.Message);
			}
		}

		internal static string PositionText(Structure arch)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				Vector3 position = ((Component)arch).transform.position;
				return "(" + position.x.ToString("F1") + ", " + position.y.ToString("F1") + ", " + position.z.ToString("F1") + ")";
			}
			catch
			{
				return "(unknown)";
			}
		}

		private static string PathOf(Transform t)
		{
			string text = string.Empty;
			while ((Object)(object)t != (Object)null)
			{
				text = "/" + ((Object)t).name + text;
				t = t.parent;
			}
			return text;
		}

		private static bool SamePtr(Il2CppObjectBase a, Il2CppObjectBase b)
		{
			try
			{
				return a != null && b != null && a.Pointer == b.Pointer;
			}
			catch
			{
				return false;
			}
		}
	}
	internal static class ArchPromptConfig
	{
		private sealed class Entry
		{
			public PlayerStorageInteractionConfig Original;

			public PlayerStorageInteractionConfig Clone;

			public string CloneName;

			public string Label;
		}

		private sealed class ClonePair
		{
			public Entry Open;

			public Entry Destination;
		}

		[HarmonyPatch(typeof(PlayerStorageInteractionConfig), "CreateSession")]
		internal static class CreateSessionPostfixPatch
		{
			[HarmonyPostfix]
			public static void Postfix(PlayerStorageInteractionConfig __instance, Interaction interaction, InteractionSession __result)
			{
				try
				{
					if (!((Object)(object)__instance == (Object)null) && __result != null && ArchInteraction.TryGetArch(interaction, out var arch) && !((Object)(object)arch == (Object)null))
					{
						PortalRecord record;
						bool attuned = PortalRegistry.Current?.TryFindByArch(arch, out record) ?? false;
						PlayerStorageInteractionConfig val = CloneFor(__instance, attuned);
						if ((Object)(object)val != (Object)null)
						{
							__result.Config = (InteractionConfiguration)(object)val;
						}
					}
				}
				catch (Exception ex)
				{
					WarnOnce("create-session", "prompt label not applied: " + ex.Message);
				}
			}
		}

		[HarmonyPatch(typeof(LocalizationManager))]
		internal static class LanguagePatch
		{
			[HarmonyPostfix]
			[HarmonyPatch("Awake")]
			public static void AwakePostfix(LocalizationManager __instance)
			{
				ReapplyAll(__instance, "Awake");
			}

			[HarmonyPostfix]
			[HarmonyPatch("SetLanguage")]
			public static void SetLanguagePostfix(LocalizationManager __instance)
			{
				ReapplyAll(__instance, "SetLanguage");
			}
		}

		[HarmonyPatch(typeof(LocalizationManager), "Loc", new Type[]
		{
			typeof(string),
			typeof(bool)
		})]
		internal static class LocPatch
		{
			[HarmonyPostfix]
			public static void Postfix(string key, ref string __result)
			{
				Substitute(key, ref __result);
			}
		}

		[HarmonyPatch(typeof(LocalizationManager))]
		internal static class LocOverloadPatch
		{
			[HarmonyPostfix]
			[HarmonyPatch("Loc", new Type[]
			{
				typeof(string),
				typeof(Il2CppReferenceArray<Object>)
			})]
			public static void LocPostfix(string key, ref string __result)
			{
				Substitute(key, ref __result);
			}

			[HarmonyPostfix]
			[HarmonyPatch("LocFallback")]
			public static void LocFallbackPostfix(string key, ref string __result)
			{
				Substitute(key, ref __result);
			}
		}

		private const string OpenLabel = "Open Portal";

		private const string OpenCloneName = "PortalOpenInteractionConfig";

		private const string DestinationLabel = "Change Destination";

		private const string DestinationCloneName = "PortalDestinationInteractionConfig";

		private const string MenuToken = "menu";

		private const string Prefix = "[Portals][attune]";

		private static readonly Dictionary<IntPtr, ClonePair> _clones = new Dictionary<IntPtr, ClonePair>();

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

		private static readonly HashSet<string> _logged = new HashSet<string>();

		internal static void Register()
		{
			Patch(typeof(CreateSessionPostfixPatch), "PlayerStorageInteractionConfig.CreateSession");
			Patch(typeof(LanguagePatch), "LocalizationManager.Awake/SetLanguage");
			Patch(typeof(LocPatch), "LocalizationManager.Loc(string, bool)");
			Patch(typeof(LocOverloadPatch), "LocalizationManager.Loc(string, array)/LocFallback");
		}

		private static void Patch(Type patchClass, string what)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Expected O, but got Unknown
			try
			{
				Harmony.CreateAndPatchAll(patchClass, (string)null);
			}
			catch (Exception ex)
			{
				ManualLogSource log = Plugin.Log;
				bool flag = default(bool);
				BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(15, 3, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>("[Portals][attune]");
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(what);
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" not patched: ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(ex.Message);
				}
				log.LogWarning(val);
			}
		}

		private static void LogOnce(string key, string message)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Expected O, but got Unknown
			if (_logged.Add(key))
			{
				ManualLogSource log = Plugin.Log;
				bool flag = default(bool);
				BepInExInfoLogInterpolatedStringHandler val = new BepInExInfoLogInterpolatedStringHandler(1, 2, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>("[Portals][attune]");
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(message);
				}
				log.LogInfo(val);
			}
		}

		private static void WarnOnce(string key, string message)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Expected O, but got Unknown
			if (_logged.Add(key))
			{
				ManualLogSource log = Plugin.Log;
				bool flag = default(bool);
				BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(1, 2, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>("[Portals][attune]");
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(message);
				}
				log.LogWarning(val);
			}
		}

		private static void Substitute(string key, ref string result)
		{
			if (key != null && _entries.Count != 0 && (string.IsNullOrEmpty(result) || !(result != key)) && _entries.TryGetValue(key, out var value))
			{
				result = value;
			}
		}

		private static bool StillTheSameAsset(Entry entry, PlayerStorageInteractionConfig original)
		{
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Expected O, but got Unknown
			if (entry == null)
			{
				return true;
			}
			try
			{
				return (Object)(object)entry.Original != (Object)null && ((Il2CppObjectBase)entry.Original).Pointer == ((Il2CppObjectBase)original).Pointer;
			}
			catch (Exception ex)
			{
				ManualLogSource log = Plugin.Log;
				bool flag = default(bool);
				BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(43, 2, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>("[Portals][attune]");
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" re-checking a cached prompt config threw: ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(ex.Message);
				}
				log.LogWarning(val);
				return false;
			}
		}

		private static PlayerStorageInteractionConfig CloneFor(PlayerStorageInteractionConfig original, bool attuned)
		{
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Expected O, but got Unknown
			IntPtr pointer = ((Il2CppObjectBase)original).Pointer;
			if (_clones.TryGetValue(pointer, out var value) && (!StillTheSameAsset(value.Open, original) || !StillTheSameAsset(value.Destination, original)))
			{
				ManualLogSource log = Plugin.Log;
				bool flag = default(bool);
				BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(76, 1, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>("[Portals][attune]");
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" the cached prompt-config clones no longer belong to this asset - rebuilding");
				}
				log.LogWarning(val);
				_clones.Remove(pointer);
				value = null;
			}
			if (value == null)
			{
				value = new ClonePair();
				_clones[pointer] = value;
			}
			Entry entry = (attuned ? value.Destination : value.Open);
			if (entry != null && (Object)(object)entry.Clone != (Object)null)
			{
				return entry.Clone;
			}
			if (!((InteractionConfiguration)original).Localized)
			{
				LogOnce("label-pending", "prompt label left (loc key) - the config is not localized yet");
				return null;
			}
			string text = (attuned ? "PortalDestinationInteractionConfig" : "PortalOpenInteractionConfig");
			string text2 = (attuned ? "Change Destination" : "Open Portal");
			Object val2 = (Object)(object)Object.Instantiate<PlayerStorageInteractionConfig>(original);
			PlayerStorageInteractionConfig val3 = ((val2 != (Object)null) ? ((Il2CppObjectBase)val2).TryCast<PlayerStorageInteractionConfig>() : null);
			if ((Object)(object)val3 == (Object)null)
			{
				WarnOnce("label-clone-" + text, "prompt label not applied: the storage config could not be cloned for " + text2);
				return null;
			}
			((Object)val3).hideFlags = (HideFlags)61;
			((Object)val3).name = text;
			entry = new Entry
			{
				Original = original,
				Clone = val3,
				CloneName = text,
				Label = text2
			};
			if (attuned)
			{
				value.Destination = entry;
			}
			else
			{
				value.Open = entry;
			}
			LocalizationManager instance = LocalizationManager.Instance;
			int value2 = Apply(entry, instance);
			string key = ((InteractionConfiguration)val3).GetKey("menu");
			string text3 = (((Object)(object)instance != (Object)null) ? Lookup(instance, key) : null);
			LogOnce("label-set-" + text, $"prompt label set: '{text2}', {value2} keys registered; '{key}' -> '{text3 ?? "(missing)"}' in the live table");
			return val3;
		}

		private static void ReapplyAll(LocalizationManager lm, string source)
		{
			try
			{
				if ((Object)(object)lm == (Object)null || _clones.Count == 0)
				{
					return;
				}
				int num = 0;
				foreach (ClonePair value in _clones.Values)
				{
					num += Reapply(value.Open, lm);
					num += Reapply(value.Destination, lm);
				}
				if (num > 0)
				{
					LogOnce("reapply-" + source, $"prompt labels re-applied after {source}: {num} keys");
				}
			}
			catch (Exception ex)
			{
				WarnOnce("reapply-" + source, "prompt label re-apply after " + source + " failed: " + ex.Message);
			}
		}

		private static int Reapply(Entry entry, LocalizationManager lm)
		{
			if (entry == null || (Object)(object)entry.Clone == (Object)null || (Object)(object)entry.Original == (Object)null)
			{
				return 0;
			}
			return Apply(entry, lm);
		}

		private static int Apply(Entry entry, LocalizationManager lm)
		{
			int result = 0;
			if ((Object)(object)lm != (Object)null)
			{
				result = RegisterKeys(entry, lm);
				ClearCache(lm);
			}
			entry.Clone.storageMenuMessage = entry.Label;
			return result;
		}

		private static int RegisterKeys(Entry entry, LocalizationManager lm)
		{
			int num = 0;
			try
			{
				string key = ((InteractionConfiguration)entry.Original).GetKey(string.Empty);
				Dictionary<string, string> localizationStrings = ((InteractionConfiguration)entry.Original).GetLocalizationStrings();
				if (localizationStrings != null && !string.IsNullOrEmpty(key))
				{
					Enumerator<string, string> enumerator = localizationStrings.GetEnumerator();
					while (enumerator.MoveNext())
					{
						string key2 = enumerator.Current.Key;
						if (key2 == null || !key2.StartsWith(key, StringComparison.Ordinal))
						{
							continue;
						}
						string text = key2.Substring(key.Length);
						if (text.Length != 0 && !(text == "menu"))
						{
							string value = Lookup(lm, key2) ?? enumerator.Current.Value;
							if (!string.IsNullOrEmpty(value) && Write(lm, ((InteractionConfiguration)entry.Clone).GetKey(text), value))
							{
								num++;
							}
						}
					}
				}
				else
				{
					WarnOnce("register-strings", "prompt keys: the original config listed no localization strings; only the menu key is registered");
				}
			}
			catch (Exception ex)
			{
				WarnOnce("register-keys", "prompt keys not all registered: " + ex.Message);
			}
			if (Write(lm, ((InteractionConfiguration)entry.Clone).GetKey("menu"), entry.Label))
			{
				num++;
			}
			return num;
		}

		private static string Lookup(LocalizationManager lm, string key)
		{
			try
			{
				Dictionary<string, string> localizedStrings = lm.LocalizedStrings;
				if (localizedStrings != null && localizedStrings.ContainsKey(key))
				{
					return localizedStrings[key];
				}
			}
			catch (Exception ex)
			{
				WarnOnce("lookup", "live-table read failed, using the field text: " + ex.Message);
			}
			return null;
		}

		private static bool Write(LocalizationManager lm, string key, string value)
		{
			if (string.IsNullOrEmpty(key) || value == null)
			{
				return false;
			}
			bool flag = false;
			flag |= Put(lm._localizedStrings, key, value, "_localizedStrings");
			flag |= Put(lm.LocalizedStrings, key, value, "LocalizedStrings");
			flag |= Put(lm._localizedFallbackStrings, key, value, "_localizedFallbackStrings");
			flag |= Put(lm.FallbackLocalizedStrings, key, value, "FallbackLocalizedStrings");
			try
			{
				LocalizationManager._allKeys?.Add(key);
			}
			catch (Exception ex)
			{
				WarnOnce("all-keys", "key set not updated: " + ex.Message);
			}
			_entries[key] = value;
			return flag;
		}

		private static bool Put(Dictionary<string, string> table, string key, string value, string which)
		{
			if (table == null)
			{
				return false;
			}
			try
			{
				table[key] = value;
				return true;
			}
			catch (Exception ex)
			{
				WarnOnce("put-" + which, "write into " + which + " failed: " + ex.Message);
				return false;
			}
		}

		private static void ClearCache(LocalizationManager lm)
		{
			try
			{
				lm._cache?.Clear();
			}
			catch (Exception ex)
			{
				WarnOnce("cache-clear", "localization cache not cleared: " + ex.Message);
			}
		}
	}
	[HarmonyPatch(typeof(Structure))]
	public static class ArchSpawnPatch
	{
		[HarmonyPostfix]
		[HarmonyPatch("AfterSpawned")]
		public static void AfterSpawned(Structure __instance)
		{
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Expected O, but got Unknown
			try
			{
				if (!ArchTargeting.IsArch(__instance))
				{
					return;
				}
				ArchTargeting.NoteLoaded(__instance);
				if (ArchInteraction.TryInject(__instance, out var reason) || (reason != "source-missing" && reason != "not-built"))
				{
					return;
				}
				for (int i = 0; i < ArchInteraction.Pending.Count; i++)
				{
					if ((Object)(object)ArchInteraction.Pending[i] == (Object)(object)__instance)
					{
						return;
					}
				}
				ArchInteraction.Pending.Add(__instance);
			}
			catch (Exception ex)
			{
				ManualLogSource log = Plugin.Log;
				bool flag = default(bool);
				BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(42, 1, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("[Portals][attune] arch spawn hook failed: ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(ex.Message);
				}
				log.LogWarning(val);
			}
		}
	}
	internal readonly struct ArchSnapshot
	{
		internal Vector3 Position { get; }

		internal Vector3 OpeningAxis { get; }

		internal string Name { get; }

		internal int UniqueId { get; }

		internal ArchSnapshot(Vector3 position, Vector3 openingAxis, string name, int uniqueId)
		{
			//IL_0001: 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_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			Position = position;
			OpeningAxis = openingAxis;
			Name = name;
			UniqueId = uniqueId;
		}
	}
	internal static class ArchTargeting
	{
		internal const string ArchTemplateName = "Item_Decoration_IvyArch";

		private static PickingManager _pickingManager;

		internal static readonly List<Structure> Loaded = new List<Structure>();

		private static readonly List<Structure> _announced = new List<Structure>();

		internal static void NoteLoaded(Structure arch)
		{
			if ((Object)(object)arch == (Object)null || !IsArch(arch))
			{
				return;
			}
			for (int i = 0; i < Loaded.Count; i++)
			{
				if ((Object)(object)Loaded[i] == (Object)(object)arch)
				{
					return;
				}
			}
			Loaded.Add(arch);
		}

		internal static void AnnounceOnce(Structure arch, int id)
		{
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Expected O, but got Unknown
			for (int num = _announced.Count - 1; num >= 0; num--)
			{
				if ((Object)(object)_announced[num] == (Object)null)
				{
					_announced.RemoveAt(num);
				}
				else if ((Object)(object)_announced[num] == (Object)(object)arch)
				{
					return;
				}
			}
			_announced.Add(arch);
			ManualLogSource log = Plugin.Log;
			bool flag = default(bool);
			BepInExInfoLogInterpolatedStringHandler val = new BepInExInfoLogInterpolatedStringHandler(28, 2, ref flag);
			if (flag)
			{
				((BepInExLogInterpolatedStringHandler)val).AppendLiteral("[Portals][sync] arch id=");
				((BepInExLogInterpolatedStringHandler)val).AppendFormatted<int>(id);
				((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" at ");
				((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(ArchInteraction.PositionText(arch));
			}
			log.LogInfo(val);
		}

		internal static int UniqueIdOf(Structure arch)
		{
			try
			{
				return ((Object)(object)arch != (Object)null) ? arch._uniqueId : 0;
			}
			catch
			{
				return 0;
			}
		}

		internal static string NameOf(Structure arch)
		{
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Expected O, but got Unknown
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Expected O, but got Unknown
			if ((Object)(object)arch == (Object)null)
			{
				return "";
			}
			bool flag = default(bool);
			try
			{
				string customName = arch.GetCustomName();
				if (!string.IsNullOrWhiteSpace(customName))
				{
					return customName.Trim();
				}
			}
			catch (Exception ex)
			{
				ManualLogSource log = Plugin.Log;
				BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(32, 1, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("[Portals] GetCustomName failed: ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(ex.Message);
				}
				log.LogWarning(val);
			}
			try
			{
				string name = arch.GetName();
				if (!string.IsNullOrWhiteSpace(name))
				{
					return name.Trim();
				}
			}
			catch (Exception ex2)
			{
				ManualLogSource log2 = Plugin.Log;
				BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(26, 1, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("[Portals] GetName failed: ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(ex2.Message);
				}
				log2.LogWarning(val);
			}
			return "";
		}

		internal static bool IsUnderConstruction(Structure arch)
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Expected O, but got Unknown
			try
			{
				return (Object)(object)arch != (Object)null && (Object)(object)arch.buildSite != (Object)null;
			}
			catch (Exception ex)
			{
				ManualLogSource log = Plugin.Log;
				bool flag = default(bool);
				BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(33, 1, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("[Portals] buildSite read failed: ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(ex.Message);
				}
				log.LogWarning(val);
				return false;
			}
		}

		internal static bool TrySnapshot(Structure arch, out ArchSnapshot snapshot)
		{
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Expected O, but got Unknown
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			snapshot = default(ArchSnapshot);
			if ((Object)(object)arch == (Object)null)
			{
				return false;
			}
			try
			{
				if (arch.Dismantled || !arch.IsActive)
				{
					return false;
				}
				if (IsUnderConstruction(arch))
				{
					return false;
				}
				Vector3 position = ((Component)arch).transform.position;
				snapshot = new ArchSnapshot(position, OpeningAxis(arch), NameOf(arch), UniqueIdOf(arch));
				return true;
			}
			catch (Exception ex)
			{
				ManualLogSource log = Plugin.Log;
				bool flag = default(bool);
				BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(32, 1, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("[Portals] arch snapshot failed: ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(ex.Message);
				}
				log.LogWarning(val);
				snapshot = default(ArchSnapshot);
				return false;
			}
		}

		internal static bool IsArch(Structure s)
		{
			try
			{
				return (Object)(object)s != (Object)null && (Object)(object)s.Template != (Object)null && ((Object)s.Template).name == "Item_Decoration_IvyArch";
			}
			catch
			{
				return false;
			}
		}

		internal static bool TryGetAimedStructure(out Structure s)
		{
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Expected O, but got Unknown
			s = null;
			try
			{
				PickingManager pickingManager = GetPickingManager();
				if ((Object)(object)pickingManager == (Object)null)
				{
					return false;
				}
				Pickable selectedPickable = pickingManager.SelectedPickable;
				if ((Object)(object)selectedPickable == (Object)null)
				{
					return false;
				}
				GameObject gameObject = ((Component)selectedPickable).gameObject;
				if ((Object)(object)gameObject == (Object)null)
				{
					return false;
				}
				StructureInteraction val = gameObject.GetComponentInParent<StructureInteraction>();
				if ((Object)(object)val == (Object)null)
				{
					val = gameObject.GetComponentInChildren<StructureInteraction>(true);
				}
				if ((Object)(object)val != (Object)null)
				{
					s = val.GetStructure();
				}
				if ((Object)(object)s == (Object)null)
				{
					s = gameObject.GetComponentInParent<Structure>();
				}
				return (Object)(object)s != (Object)null;
			}
			catch (Exception ex)
			{
				ManualLogSource log = Plugin.Log;
				bool flag = default(bool);
				BepInExWarningLogInterpolatedStringHandler val2 = new BepInExWarningLogInterpolatedStringHandler(39, 1, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val2).AppendLiteral("[Portals] TryGetAimedStructure failed: ");
					((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<string>(ex.Message);
				}
				log.LogWarning(val2);
				s = null;
				return false;
			}
		}

		internal static List<Structure> FindArches()
		{
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Expected O, but got Unknown
			List<Structure> list = new List<Structure>();
			try
			{
				Il2CppArrayBase<Structure> val = Object.FindObjectsOfType<Structure>();
				if (val == null)
				{
					return list;
				}
				foreach (Structure item in val)
				{
					if (IsArch(item))
					{
						list.Add(item);
					}
				}
			}
			catch (Exception ex)
			{
				ManualLogSource log = Plugin.Log;
				bool flag = default(bool);
				BepInExWarningLogInterpolatedStringHandler val2 = new BepInExWarningLogInterpolatedStringHandler(29, 1, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val2).AppendLiteral("[Portals] FindArches failed: ");
					((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<string>(ex.Message);
				}
				log.LogWarning(val2);
			}
			return list;
		}

		internal static Vector3 OpeningAxis(Structure arch)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Expected O, but got Unknown
			//IL_002f: 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)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				Vector3 forward = ((Component)arch).transform.forward;
				forward.y = 0f;
				return (((Vector3)(ref forward)).sqrMagnitude > 0.0001f) ? ((Vector3)(ref forward)).normalized : Vector3.forward;
			}
			catch (Exception ex)
			{
				ManualLogSource log = Plugin.Log;
				bool flag = default(bool);
				BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(30, 1, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("[Portals] OpeningAxis failed: ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(ex.Message);
				}
				log.LogWarning(val);
				return Vector3.forward;
			}
		}

		private static PickingManager GetPickingManager()
		{
			if ((Object)(object)_pickingManager == (Object)null)
			{
				_pickingManager = Object.FindObjectOfType<PickingManager>();
			}
			return _pickingManager;
		}
	}
	internal static class ArchUsePatch
	{
		[HarmonyPatch(typeof(Interaction), "Use")]
		internal static class UsePrefixPatch
		{
			[HarmonyPrefix]
			public static bool Prefix(Interaction __instance, ref bool __result)
			{
				try
				{
					if (!ArchInteraction.TryGetArch(__instance, out var arch) || (Object)(object)arch == (Object)null)
					{
						return true;
					}
					__result = false;
					OnInteract(arch);
					return false;
				}
				catch (Exception ex)
				{
					WarnOnce("use-prefix", "Use prefix failed, deferring to the game: " + ex.Message);
					return true;
				}
			}
		}

		private const string Prefix = "[Portals][attune]";

		private static readonly HashSet<string> _logged = new HashSet<string>();

		internal static void Register()
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Expected O, but got Unknown
			try
			{
				Harmony.CreateAndPatchAll(typeof(UsePrefixPatch), (string)null);
			}
			catch (Exception ex)
			{
				ManualLogSource log = Plugin.Log;
				bool flag = default(bool);
				BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(30, 2, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>("[Portals][attune]");
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" Interaction.Use not patched: ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(ex.Message);
				}
				log.LogWarning(val);
			}
		}

		private static void WarnOnce(string key, string message)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Expected O, but got Unknown
			if (_logged.Add(key))
			{
				ManualLogSource log = Plugin.Log;
				bool flag = default(bool);
				BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(1, 2, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>("[Portals][attune]");
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(message);
				}
				log.LogWarning(val);
			}
		}

		internal static void OnInteract(Structure arch)
		{
			if (!((Object)(object)arch == (Object)null))
			{
				PortalRegistry current = PortalRegistry.Current;
				PortalRecord record;
				if (current == null)
				{
					Toast("Portals are not ready yet.", (NotificationType)1);
				}
				else if (!current.TryFindByArch(arch, out record))
				{
					ArchConfirmDialog.TryOpen(arch);
				}
				else if (current.Portals.Count < 2)
				{
					Toast("You need at least two Portals to travel the Bifrost", (NotificationType)1);
					Plugin.Log.LogInfo((object)"[Portals][destination] refused: only one portal");
				}
				else
				{
					PortalTool.RequestDestinationDialog(record);
				}
			}
		}

		private static void Toast(string message)
		{
			Toast(message, (NotificationType)0);
		}

		internal static void Toast(string message, NotificationType type)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Invalid comparison between Unknown and I4
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			if ((int)type == 1)
			{
				try
				{
					string text = message;
					int hashCode = message.GetHashCode();
					float num = 1f;
					Color val = default(Color);
					((Color)(ref val))..ctor(0.85f, 0.2f, 0.18f, 1f);
					NotificationMenu.DisplayStacking((NotificationType)1, (StackingType)0, ref text, ref hashCode, ref num, (Sprite)null, val, val);
					return;
				}
				catch (Exception ex)
				{
					WarnOnce("toast-red", "red notification failed, using default: " + ex.Message);
				}
			}
			try
			{
				string text2 = message;
				NotificationMenu.Display(type, ref text2, false);
			}
			catch (Exception ex2)
			{
				WarnOnce("toast", "notification failed: " + ex2.Message);
			}
		}
	}
	internal static class ArchWidgetPatch
	{
		[HarmonyPatch(typeof(PlayerStorageInteractionSession), "RefreshWidgetData")]
		internal static class RefreshWidgetDataPrefixPatch
		{
			[HarmonyPrefix]
			public static bool Prefix(PlayerStorageInteractionSession __instance)
			{
				try
				{
					Structure arch;
					return !ArchInteraction.TryGetArch((InteractionSession)(object)__instance, out arch) || !ArchInteraction.WidgetRefreshUnsafe(arch);
				}
				catch (Exception)
				{
					return true;
				}
			}
		}

		private const string Prefix = "[Portals][attune]";

		internal static void Register()
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Expected O, but got Unknown
			try
			{
				Harmony.CreateAndPatchAll(typeof(RefreshWidgetDataPrefixPatch), (string)null);
			}
			catch (Exception ex)
			{
				ManualLogSource log = Plugin.Log;
				bool flag = default(bool);
				BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(64, 2, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>("[Portals][attune]");
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" PlayerStorageInteractionSession.RefreshWidgetData not patched: ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(ex.Message);
				}
				log.LogWarning(val);
			}
		}
	}
	[HarmonyPatch(typeof(Character))]
	public static class CharacterSpawnPatch
	{
		[HarmonyPostfix]
		[HarmonyPatch("Spawned")]
		public static void Spawned(Character __instance)
		{
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			Type[] components = new Type[2]
			{
				typeof(TeleportEngine),
				typeof(PortalTool)
			};
			LocalPlayerTool.AttachOnSpawn(__instance, Plugin.Log, "Teleportation_Tool", Vector3.zero, components);
		}
	}
	internal static class ConfigRename
	{
		private const string Prefix = "[Portals][rename]";

		private const string OldGuid = "mugsy33.teleportation";

		private const string OldRegistryFolder = "Teleportation";

		internal static void Run(ConfigFile config, ManualLogSource log)
		{
			MoveSettings(config, log);
			MoveDevSettings(log);
			MoveRegistry(log);
		}

		private static void MoveSettings(ConfigFile config, ManualLogSource log)
		{
			//IL_0201: Unknown result type (might be due to invalid IL or missing references)
			//IL_0208: Expected O, but got Unknown
			//IL_01b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bf: Expected O, but got Unknown
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Expected O, but got Unknown
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Expected O, but got Unknown
			//IL_0133: Unknown result type (might be due to invalid IL or missing references)
			//IL_013a: Expected O, but got Unknown
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Expected O, but got Unknown
			//IL_0179: Unknown result type (might be due to invalid IL or missing references)
			//IL_0180: Expected O, but got Unknown
			bool flag = false;
			string text = null;
			bool flag2 = default(bool);
			try
			{
				text = config.ConfigFilePath;
				string text2 = Path.Combine(Paths.ConfigPath, "mugsy33.teleportation.cfg");
				string text3 = text2 + ".migrated";
				if (File.Exists(text))
				{
					if (File.Exists(text3))
					{
						File.Delete(text3);
						BepInExInfoLogInterpolatedStringHandler val = new BepInExInfoLogInterpolatedStringHandler(39, 2, ref flag2);
						if (flag2)
						{
							((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>("[Portals][rename]");
							((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" deleted the migrated legacy settings: ");
							((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(text3);
						}
						log.LogInfo(val);
					}
					else if (File.Exists(text2))
					{
						File.Move(text2, text3, overwrite: true);
						BepInExInfoLogInterpolatedStringHandler val = new BepInExInfoLogInterpolatedStringHandler(29, 2, ref flag2);
						if (flag2)
						{
							((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>("[Portals][rename]");
							((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" legacy settings archived to ");
							((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(text3);
						}
						log.LogInfo(val);
					}
				}
				else if (File.Exists(text2))
				{
					BepInExInfoLogInterpolatedStringHandler val = new BepInExInfoLogInterpolatedStringHandler(24, 2, ref flag2);
					if (flag2)
					{
						((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>("[Portals][rename]");
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" legacy settings found: ");
						((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(text2);
					}
					log.LogInfo(val);
					string text4 = text + ".tmp";
					File.Copy(text2, text4, overwrite: true);
					File.Move(text4, text, overwrite: true);
					flag = true;
					val = new BepInExInfoLogInterpolatedStringHandler(19, 2, ref flag2);
					if (flag2)
					{
						((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>("[Portals][rename]");
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" settings moved to ");
						((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(text);
					}
					log.LogInfo(val);
					config.Reload();
					File.Move(text2, text3, overwrite: true);
					val = new BepInExInfoLogInterpolatedStringHandler(29, 2, ref flag2);
					if (flag2)
					{
						((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>("[Portals][rename]");
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" legacy settings archived to ");
						((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(text3);
					}
					log.LogInfo(val);
				}
			}
			catch (Exception ex)
			{
				BepInExWarningLogInterpolatedStringHandler val2 = new BepInExWarningLogInterpolatedStringHandler(61, 2, ref flag2);
				if (flag2)
				{
					((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<string>("[Portals][rename]");
					((BepInExLogInterpolatedStringHandler)val2).AppendLiteral(" the settings could not be moved; the old file is untouched. ");
					((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<Exception>(ex);
				}
				log.LogWarning(val2);
				if (!flag || text == null)
				{
					return;
				}
				try
				{
					File.Delete(text);
				}
				catch (Exception ex2)
				{
					val2 = new BepInExWarningLogInterpolatedStringHandler(54, 2, ref flag2);
					if (flag2)
					{
						((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<string>("[Portals][rename]");
						((BepInExLogInterpolatedStringHandler)val2).AppendLiteral(" the half-written settings file could not be removed: ");
						((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<string>(ex2.Message);
					}
					log.LogWarning(val2);
				}
			}
		}

		private static void MoveDevSettings(ManualLogSource log)
		{
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Expected O, but got Unknown
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Expected O, but got Unknown
			bool flag = default(bool);
			try
			{
				string text = Path.Combine(Paths.ConfigPath, "mugsy33.teleportation.dev.cfg");
				string text2 = Path.Combine(Paths.ConfigPath, "mugsy33.bifrost.dev.cfg");
				if (File.Exists(text) && !File.Exists(text2))
				{
					File.Move(text, text2);
					BepInExInfoLogInterpolatedStringHandler val = new BepInExInfoLogInterpolatedStringHandler(23, 2, ref flag);
					if (flag)
					{
						((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>("[Portals][rename]");
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" dev settings moved to ");
						((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(text2);
					}
					log.LogInfo(val);
				}
			}
			catch (Exception ex)
			{
				BepInExWarningLogInterpolatedStringHandler val2 = new BepInExWarningLogInterpolatedStringHandler(65, 2, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<string>("[Portals][rename]");
					((BepInExLogInterpolatedStringHandler)val2).AppendLiteral(" the dev settings could not be moved; the old file is untouched. ");
					((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<Exception>(ex);
				}
				log.LogWarning(val2);
			}
		}

		private static void MoveRegistry(ManualLogSource log)
		{
			//IL_0190: Unknown result type (might be due to invalid IL or missing references)
			//IL_0197: Expected O, but got Unknown
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Expected O, but got Unknown
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Expected O, but got Unknown
			//IL_0154: Unknown result type (might be due to invalid IL or missing references)
			//IL_015b: Expected O, but got Unknown
			bool flag = default(bool);
			try
			{
				string text = Path.Combine(Paths.ConfigPath, "Teleportation");
				string text2 = Path.Combine(Paths.ConfigPath, "Bifrost");
				if (!Directory.Exists(text))
				{
					return;
				}
				Directory.CreateDirectory(text2);
				string[] files = Directory.GetFiles(text);
				int num = 0;
				BepInExInfoLogInterpolatedStringHandler val;
				for (int i = 0; i < files.Length; i++)
				{
					string fileName = Path.GetFileName(files[i]);
					string text3 = Path.Combine(text2, fileName);
					if (File.Exists(text3))
					{
						val = new BepInExInfoLogInterpolatedStringHandler(46, 3, ref flag);
						if (flag)
						{
							((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>("[Portals][rename]");
							((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" kept the existing ");
							((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(fileName);
							((BepInExLogInterpolatedStringHandler)val).AppendLiteral("; the legacy copy stays at ");
							((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(files[i]);
						}
						log.LogInfo(val);
					}
					else
					{
						File.Move(files[i], text3);
						num++;
					}
				}
				val = new BepInExInfoLogInterpolatedStringHandler(39, 4, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>("[Portals][rename]");
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" moved ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<int>(num);
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" of ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<int>(files.Length);
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" portal registry file(s) to ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(text2);
				}
				log.LogInfo(val);
				if (Directory.GetFiles(text).Length == 0 && Directory.GetDirectories(text).Length == 0)
				{
					Directory.Delete(text);
					val = new BepInExInfoLogInterpolatedStringHandler(33, 2, ref flag);
					if (flag)
					{
						((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>("[Portals][rename]");
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" removed the empty legacy folder ");
						((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(text);
					}
					log.LogInfo(val);
				}
			}
			catch (Exception ex)
			{
				BepInExWarningLogInterpolatedStringHandler val2 = new BepInExWarningLogInterpolatedStringHandler(72, 2, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<string>("[Portals][rename]");
					((BepInExLogInterpolatedStringHandler)val2).AppendLiteral(" the portal registries could not be moved; the old folder is untouched. ");
					((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<Exception>(ex);
				}
				log.LogWarning(val2);
			}
		}
	}
	internal static class DestinationDialog
	{
		private enum State
		{
			Idle,
			WaitingForMenu,
			Ready
		}

		[HarmonyPatch(typeof(InputFieldConfirmActionMenu), "_OnConfirmButtonPressed")]
		internal static class ConfirmPressPatch
		{
			[HarmonyPrefix]
			public static bool Prefix(InputFieldConfirmActionMenu __instance)
			{
				//IL_0053: Unknown result type (might be due to invalid IL or missing references)
				//IL_0059: Expected O, but got Unknown
				try
				{
					if (_state != State.Ready || _menuPointer == IntPtr.Zero || (Object)(object)__instance == (Object)null || ((Il2CppObjectBase)__instance).Pointer != _menuPointer)
					{
						return true;
					}
				}
				catch
				{
					return true;
				}
				try
				{
					return HandleConfirm();
				}
				catch (Exception ex)
				{
					ManualLogSource log = Plugin.Log;
					bool flag = default(bool);
					BepInExErrorLogInterpolatedStringHandler val = new BepInExErrorLogInterpolatedStringHandler(35, 2, ref flag);
					if (flag)
					{
						((BepInExLogInterpolatedStringHandler)val).AppendFormatted<Func<InputFieldConfirmActionMenu, bool>>((Func<InputFieldConfirmActionMenu, bool>)Prefix);
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" handling the confirm press threw: ");
						((BepInExLogInterpolatedStringHandler)val).AppendFormatted<Exception>(ex);
					}
					log.LogError(val);
					return false;
				}
			}
		}

		private const string Prefix = "[Portals][destination]";

		private const string Title = "Select Destination";

		private const string ConfirmCaptionKey = "common.confirm";

		private const string CancelCaptionKey = "common.cancel";

		private const string CloneName = "PortalDestinationDropdown";

		private const string SourceCaptionName = "Description";

		private const string FailureMessage = "The destination window could not be opened.";

		private const float ActivationTimeoutSeconds = 5f;

		private const float VanishGraceSeconds = 5f;

		private static readonly Vector2 FallbackAnchorMin = new Vector2(0.5f, 0f);

		private static readonly Vector2 FallbackAnchorMax = new Vector2(0.5f, 0f);

		private static readonly Vector2 FallbackPivot = new Vector2(0.5f, 0.5f);

		private static readonly Vector2 FallbackAnchoredPosition = new Vector2(0f, 65.1f);

		private static readonly Vector2 FallbackSizeDelta = new Vector2(160f, 30f);

		private static State _state = State.Idle;

		private static Menu _menu;

		private static InputFieldConfirmActionMenu _dialog;

		private static IntPtr _menuPointer;

		private static TMP_Dropdown _dropdown;

		private static Button _confirmButton;

		private static List<PortalRecord> _ordered;

		private static bool _hasBlank;

		private static int _selectedOrder;

		private static Action<PortalRecord> _onPick;

		private static float _openedAt;

		private static float _lastAliveAt;

		private static Action<ConfirmActionMenu> _cancelHandler;

		private static Action<int> _valueChangedHandler;

		internal static bool IsOpen => _state != State.Idle;

		internal static bool TryOpen(PortalRecord current, IReadOnlyList<PortalRecord> choices, PortalRecord preselected, Action<PortalRecord> onPick)
		{
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Expected O, but got Unknown
			//IL_0141: Unknown result type (might be due to invalid IL or missing references)
			//IL_0148: Expected O, but got Unknown
			//IL_022e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0235: Expected O, but got Unknown
			//IL_02a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ae: Expected O, but got Unknown
			//IL_02ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0306: Expected O, but got Unknown
			//IL_03ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b4: Expected O, but got Unknown
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Expected O, but got Unknown
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Expected O, but got Unknown
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0106: Expected O, but got Unknown
			//IL_018f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0196: Expected O, but got Unknown
			//IL_01bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0202: Unknown result type (might be due to invalid IL or missing references)
			//IL_020d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0218: Unknown result type (might be due to invalid IL or missing references)
			//IL_0220: Expected O, but got Unknown
			//IL_0352: Unknown result type (might be due to invalid IL or missing references)
			//IL_0359: Expected O, but got Unknown
			//IL_0438: Unknown result type (might be due to invalid IL or missing references)
			//IL_043f: Expected O, but got Unknown
			bool flag = default(bool);
			if (current == null || choices == null || choices.Count == 0 || onPick == null)
			{
				ManualLogSource log = Plugin.Log;
				BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(66, 1, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>("[Portals][destination]");
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" the picker was asked for with nothing to pick from - not opening.");
				}
				log.LogWarning(val);
				return false;
			}
			BepInExInfoLogInterpolatedStringHandler val2;
			if (_state != State.Idle)
			{
				ManualLogSource log2 = Plugin.Log;
				val2 = new BepInExInfoLogInterpolatedStringHandler(52, 2, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<string>("[Portals][destination]");
					((BepInExLogInterpolatedStringHandler)val2).AppendLiteral(" a destination window is already open (");
					((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<State>(_state);
					((BepInExLogInterpolatedStringHandler)val2).AppendLiteral(") - ignoring.");
				}
				log2.LogInfo(val2);
				return false;
			}
			MenuManager instance;
			try
			{
				instance = MenuManager.Instance;
			}
			catch (Exception ex)
			{
				ManualLogSource log3 = Plugin.Log;
				BepInExErrorLogInterpolatedStringHandler val3 = new BepInExErrorLogInterpolatedStringHandler(37, 2, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val3).AppendFormatted<string>("[Portals][destination]");
					((BepInExLogInterpolatedStringHandler)val3).AppendLiteral(" reading MenuManager.Instance threw: ");
					((BepInExLogInterpolatedStringHandler)val3).AppendFormatted<Exception>(ex);
				}
				log3.LogError(val3);
				return false;
			}
			bool flag2 = default(bool);
			if ((Object)(object)instance == (Object)null)
			{
				ManualLogSource log4 = Plugin.Log;
				BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(67, 1, ref flag2);
				if (flag2)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>("[Portals][destination]");
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" there is no MenuManager - the destination window cannot be opened.");
				}
				log4.LogWarning(val);
				return false;
			}
			InputFieldConfirmActionMenu prefab;
			try
			{
				prefab = instance.GetPrefab<InputFieldConfirmActionMenu>();
			}
			catch (Exception ex2)
			{
				ManualLogSource log5 = Plugin.Log;
				BepInExErrorLogInterpolatedStringHandler val3 = new BepInExErrorLogInterpolatedStringHandler(61, 2, ref flag2);
				if (flag2)
				{
					((BepInExLogInterpolatedStringHandler)val3).AppendFormatted<string>("[Portals][destination]");
					((BepInExLogInterpolatedStringHandler)val3).AppendLiteral(" MenuManager.GetPrefab<InputFieldConfirmActionMenu>() threw: ");
					((BepInExLogInterpolatedStringHandler)val3).AppendFormatted<Exception>(ex2);
				}
				log5.LogError(val3);
				return false;
			}
			if ((Object)(object)prefab == (Object)null)
			{
				ManualLogSource log6 = Plugin.Log;
				BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(97, 1, ref flag2);
				if (flag2)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>("[Portals][destination]");
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" MenuManager has no InputFieldConfirmActionMenu prefab - the destination window cannot be opened.");
				}
				log6.LogWarning(val);
				return false;
			}
			InputFieldConfirmActionMenuParameters val4;
			try
			{
				val4 = new InputFieldConfirmActionMenuParameters
				{
					Title = "Select Destination",
					Message = string.Empty,
					ConfirmMessage = "common.confirm",
					CancelMessage = "common.cancel",
					CloseOnConfirm = false,
					HideCancelButton = false,
					DontCloseOnEscape = false,
					defaultText = string.Empty,
					placeholderText = string.Empty,
					checkForProfanities = false
				};
			}
			catch (Exception ex3)
			{
				ManualLogSource log7 = Plugin.Log;
				BepInExErrorLogInterpolatedStringHandler val3 = new BepInExErrorLogInterpolatedStringHandler(53, 2, ref flag2);
				if (flag2)
				{
					((BepInExLogInterpolatedStringHandler)val3).AppendFormatted<string>("[Portals][destination]");
					((BepInExLogInterpolatedStringHandler)val3).AppendLiteral(" building the destination window's parameters threw: ");
					((BepInExLogInterpolatedStringHandler)val3).AppendFormatted<Exception>(ex3);
				}
				log7.LogError(val3);
				return false;
			}
			_cancelHandler = HandleCancel;
			try
			{
				((ConfirmActionMenuParameters)val4).OnCancel = DelegateSupport.ConvertDelegate<Action<ConfirmActionMenu>>((Delegate)_cancelHandler);
			}
			catch (Exception ex4)
			{
				ManualLogSource log8 = Plugin.Log;
				BepInExErrorLogInterpolatedStringHandler val3 = new BepInExErrorLogInterpolatedStringHandler(39, 2, ref flag2);
				if (flag2)
				{
					((BepInExLogInterpolatedStringHandler)val3).AppendFormatted<string>("[Portals][destination]");
					((BepInExLogInterpolatedStringHandler)val3).AppendLiteral(" converting the cancel callback threw: ");
					((BepInExLogInterpolatedStringHandler)val3).AppendFormatted<Exception>(ex4);
				}
				log8.LogError(val3);
				Forget();
				return false;
			}
			Menu val5;
			try
			{
				val5 = instance.OpenMenuPrefab((Menu)(object)prefab, (MenuParameters)(object)val4);
			}
			catch (Exception ex5)
			{
				ManualLogSource log9 = Plugin.Log;
				BepInExErrorLogInterpolatedStringHandler val3 = new BepInExErrorLogInterpolatedStringHandler(39, 2, ref flag2);
				if (flag2)
				{
					((BepInExLogInterpolatedStringHandler)val3).AppendFormatted<string>("[Portals][destination]");
					((BepInExLogInterpolatedStringHandler)val3).AppendLiteral(" opening the destination window threw: ");
					((BepInExLogInterpolatedStringHandler)val3).AppendFormatted<Exception>(ex5);
				}
				log9.LogError(val3);
				Forget();
				return false;
			}
			if ((Object)(object)val5 == (Object)null)
			{
				ManualLogSource log10 = Plugin.Log;
				BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(71, 1, ref flag2);
				if (flag2)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>("[Portals][destination]");
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" OpenMenuPrefab returned nothing - the destination window did not open.");
				}
				log10.LogWarning(val);
				Forget();
				return false;
			}
			_menu = val5;
			try
			{
				_menuPointer = ((Il2CppObjectBase)val5).Pointer;
				_dialog = ((Il2CppObjectBase)val5).TryCast<InputFieldConfirmActionMenu>();
			}
			catch (Exception ex6)
			{
				ManualLogSource log11 = Plugin.Log;
				BepInExErrorLogInterpolatedStringHandler val3 = new BepInExErrorLogInterpolatedStringHandler(32, 2, ref flag2);
				if (flag2)
				{
					((BepInExLogInterpolatedStringHandler)val3).AppendFormatted<string>("[Portals][destination]");
					((BepInExLogInterpolatedStringHandler)val3).AppendLiteral(" reading the opened menu threw: ");
					((BepInExLogInterpolatedStringHandler)val3).AppendFormatted<Exception>(ex6);
				}
				log11.LogError(val3);
				CloseAndFail();
				return false;
			}
			_onPick = onPick;
			_ordered = DestinationList.Order(choices);
			_selectedOrder = preselected?.AttunedOrder ?? current.DestinationOrder;
			_state = State.WaitingForMenu;
			_openedAt = SafeNow();
			_lastAliveAt = _openedAt;
			ManualLogSource log12 = Plugin.Log;
			val2 = new BepInExInfoLogInterpolatedStringHandler(35, 3, ref flag2);
			if (flag2)
			{
				((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<string>("[Portals][destination]");
				((BepInExLogInterpolatedStringHandler)val2).AppendLiteral(" window opening for ");
				((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<string>(current.Name);
				((BepInExLogInterpolatedStringHandler)val2).AppendLiteral(" with ");
				((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<int>(_ordered.Count);
				((BepInExLogInterpolatedStringHandler)val2).AppendLiteral(" choices.");
			}
			log12.LogInfo(val2);
			return true;
		}

		internal static void Tick()
		{
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Expected O, but got Unknown
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Expected O, but got Unknown
			//IL_013c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0143: Expected O, but got Unknown
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Expected O, but got Unknown
			if (_state == State.Idle)
			{
				return;
			}
			bool flag2 = default(bool);
			if (_state == State.WaitingForMenu)
			{
				bool flag;
				try
				{
					flag = (Object)(object)_menu != (Object)null && _menu.IsActive;
				}
				catch (Exception ex)
				{
					ManualLogSource log = Plugin.Log;
					BepInExErrorLogInterpolatedStringHandler val = new BepInExErrorLogInterpolatedStringHandler(35, 2, ref flag2);
					if (flag2)
					{
						((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>("[Portals][destination]");
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" reading the window's state threw: ");
						((BepInExLogInterpolatedStringHandler)val).AppendFormatted<Exception>(ex);
					}
					log.LogError(val);
					flag = false;
				}
				if (flag)
				{
					try
					{
						Furnish();
					}
					catch (Exception ex2)
					{
						ManualLogSource log2 = Plugin.Log;
						BepInExErrorLogInterpolatedStringHandler val = new BepInExErrorLogInterpolatedStringHandler(40, 2, ref flag2);
						if (flag2)
						{
							((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>("[Portals][destination]");
							((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" building the destination window threw: ");
							((BepInExLogInterpolatedStringHandler)val).AppendFormatted<Exception>(ex2);
						}
						log2.LogError(val);
						CloseAndFail();
						return;
					}
					_state = State.Ready;
					_lastAliveAt = SafeNow();
				}
				else if (SafeNow() - _openedAt > 5f)
				{
					ManualLogSource log3 = Plugin.Log;
					BepInExErrorLogInterpolatedStringHandler val = new BepInExErrorLogInterpolatedStringHandler(68, 2, ref flag2);
					if (flag2)
					{
						((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>("[Portals][destination]");
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" the window did not go active within ");
						((BepInExLogInterpolatedStringHandler)val).AppendFormatted<float>(5f, "F0");
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral("s of unscaled time - giving up.");
					}
					log3.LogError(val);
					CloseAndFail();
				}
			}
			else if (HasVanished())
			{
				ManualLogSource log4 = Plugin.Log;
				BepInExInfoLogInterpolatedStringHandler val2 = new BepInExInfoLogInterpolatedStringHandler(76, 1, ref flag2);
				if (flag2)
				{
					((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<string>("[Portals][destination]");
					((BepInExLogInterpolatedStringHandler)val2).AppendLiteral(" the destination window vanished without a callback - dropping its tracking.");
				}
				log4.LogInfo(val2);
				Forget();
			}
		}

		private static void Furnish()
		{
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: 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_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Expected O, but got Unknown
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: 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_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Expected O, but got Unknown
			//IL_0136: Unknown result type (might be due to invalid IL or missing references)
			//IL_013d: Expected O, but got Unknown
			//IL_01ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f2: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = ResolveInputFieldDiv();
			RectTransform val2 = (((Object)(object)val == (Object)null) ? null : AsRect(val.transform));
			Vector2 anchorMin;
			Vector2 anchorMax;
			Vector2 pivot;
			Vector2 anchoredPosition;
			Vector2 sizeDelta;
			Transform val3;
			bool flag = default(bool);
			BepInExInfoLogInterpolatedStringHandler val4;
			if ((Object)(object)val2 != (Object)null && (Object)(object)((Transform)val2).parent != (Object)null)
			{
				anchorMin = val2.anchorMin;
				anchorMax = val2.anchorMax;
				pivot = val2.pivot;
				anchoredPosition = val2.anchoredPosition;
				sizeDelta = val2.sizeDelta;
				val3 = ((Transform)val2).parent;
				ManualLogSource log = Plugin.Log;
				val4 = new BepInExInfoLogInterpolatedStringHandler(49, 1, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val4).AppendFormatted<string>("[Portals][destination]");
					((BepInExLogInterpolatedStringHandler)val4).AppendLiteral(" placement read from the live InputFieldDiv rect.");
				}
				log.LogInfo(val4);
			}
			else
			{
				anchorMin = FallbackAnchorMin;
				anchorMax = FallbackAnchorMax;
				pivot = FallbackPivot;
				anchoredPosition = FallbackAnchoredPosition;
				sizeDelta = FallbackSizeDelta;
				val3 = FindPanel();
				ManualLogSource log2 = Plugin.Log;
				BepInExWarningLogInterpolatedStringHandler val5 = new BepInExWarningLogInterpolatedStringHandler(98, 1, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val5).AppendFormatted<string>("[Portals][destination]");
					((BepInExLogInterpolatedStringHandler)val5).AppendLiteral(" the live InputFieldDiv rect could not be read - using the captured placement on the menu's Panel.");
				}
				log2.LogWarning(val5);
			}
			if ((Object)(object)val3 == (Object)null)
			{
				throw new InvalidOperationException("the destination window has no Panel to host the pulldown");
			}
			string route;
			TMP_Dropdown obj = FindLiveDropdown(out route);
			if ((Object)(object)obj == (Object)null)
			{
				throw new InvalidOperationException("no live pulldown could be found to clone");
			}
			ManualLogSource log3 = Plugin.Log;
			val4 = new BepInExInfoLogInterpolatedStringHandler(23, 2, ref flag);
			if (flag)
			{
				((BepInExLogInterpolatedStringHandler)val4).AppendFormatted<string>("[Portals][destination]");
				((BepInExLogInterpolatedStringHandler)val4).AppendLiteral(" pulldown cloned from ");
				((BepInExLogInterpolatedStringHandler)val4).AppendFormatted<string>(route);
				((BepInExLogInterpolatedStringHandler)val4).AppendLiteral(".");
			}
			log3.LogInfo(val4);
			GameObject obj2 = Object.Instantiate<GameObject>(((Component)obj).gameObject);
			if ((Object)(object)obj2 == (Object)null)
			{
				throw new InvalidOperationException("cloning the live pulldown returned nothing");
			}
			((Object)obj2).name = "PortalDestinationDropdown";
			obj2.transform.SetParent(val3, false);
			obj2.SetActive(true);
			_dropdown = obj2.GetComponent<TMP_Dropdown>();
			if ((Object)(object)_dropdown == (Object)null)
			{
				throw new InvalidOperationException("the cloned pulldown carries no TMP_Dropdown");
			}
			if ((Object)(object)val != (Object)null)
			{
				val.SetActive(false);
			}
			HideSourceCaption(obj2);
			PlaceClone(obj2, anchorMin, anchorMax, pivot, anchoredPosition, sizeDelta);
			PopulateOptions();
			ResolveConfirmButton();
			AttachValueChanged();
		}

		private static void HideSourceCaption(GameObject cloneObject)
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Expected O, but got Unknown
			try
			{
				Transform val = cloneObject.transform.Find("Description");
				if ((Object)(object)val != (Object)null)
				{
					((Component)val).gameObject.SetActive(false);
				}
			}
			catch (Exception ex)
			{
				ManualLogSource log = Plugin.Log;
				bool flag = default(bool);
				BepInExWarningLogInterpolatedStringHandler val2 = new BepInExWarningLogInterpolatedStringHandler(42, 2, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<string>("[Portals][destination]");
					((BepInExLogInterpolatedStringHandler)val2).AppendLiteral(" hiding the clone's source caption threw: ");
					((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<string>(ex.Message);
				}
				log.LogWarning(val2);
			}
		}

		private static void PlaceClone(GameObject cloneObject, Vector2 anchorMin, Vector2 anchorMax, Vector2 pivot, Vector2 anchoredPosition, Vector2 sizeDelta)
		{
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Expected O, but got Unknown
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: 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_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Expected O, but got Unknown
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_010f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0128: Unknown result type (might be due to invalid IL or missing references)
			//IL_0141: Unknown result type (might be due to invalid IL or missing references)
			RectTransform val = AsRect(cloneObject.transform);
			if ((Object)(object)val == (Object)null)
			{
				throw new InvalidOperationException("the cloned pulldown's transform is not a RectTransform");
			}
			bool flag = default(bool);
			try
			{
				ContentSizeFitter component = cloneObject.GetComponent<ContentSizeFitter>();
				if ((Object)(object)component != (Object)null)
				{
					((Behaviour)component).enabled = false;
				}
			}
			catch (Exception ex)
			{
				ManualLogSource log = Plugin.Log;
				BepInExWarningLogInterpolatedStringHandler val2 = new BepInExWarningLogInterpolatedStringHandler(48, 2, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<string>("[Portals][destination]");
					((BepInExLogInterpolatedStringHandler)val2).AppendLiteral(" disabling the clone's ContentSizeFitter threw: ");
					((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<string>(ex.Message);
				}
				log.LogWarning(val2);
			}
			val.anchorMin = anchorMin;
			val.anchorMax = anchorMax;
			val.pivot = pivot;
			val.anchoredPosition = anchoredPosition;
			val.sizeDelta = sizeDelta;
			ManualLogSource log2 = Plugin.Log;
			BepInExInfoLogInterpolatedStringHandler val3 = new BepInExInfoLogInterpolatedStringHandler(75, 6, ref flag);
			if (flag)
			{
				((BepInExLogInterpolatedStringHandler)val3).AppendFormatted<string>("[Portals][destination]");
				((BepInExLogInterpolatedStringHandler)val3).AppendLiteral(" pulldown placed: anchoredPosition=");
				((BepInExLogInterpolatedStringHandler)val3).AppendFormatted<Vector2>(val.anchoredPosition);
				((BepInExLogInterpolatedStringHandler)val3).AppendLiteral(" sizeDelta=");
				((BepInExLogInterpolatedStringHandler)val3).AppendFormatted<Vector2>(val.sizeDelta);
				((BepInExLogInterpolatedStringHandler)val3).AppendLiteral(" ");
				((BepInExLogInterpolatedStringHandler)val3).AppendLiteral("anchorMin=");
				((BepInExLogInterpolatedStringHandler)val3).AppendFormatted<Vector2>(val.anchorMin);
				((BepInExLogInterpolatedStringHandler)val3).AppendLiteral(" anchorMax=");
				((BepInExLogInterpolatedStringHandler)val3).AppendFormatted<Vector2>(val.anchorMax);
				((BepInExLogInterpolatedStringHandler)val3).AppendLiteral(" pivot=");
				((BepInExLogInterpolatedStringHandler)val3).AppendFormatted<Vector2>(val.pivot);
			}
			log2.LogInfo(val3);
		}

		private static void PopulateOptions()
		{
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Expected O, but got Unknown
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Expected O, but got Unknown
			List<string> list = DestinationList.Labels(_ordered);
			int num = -1;
			if (_selectedOrder > 0)
			{
				for (int i = 0; i < _ordered.Count; i++)
				{
					if (_ordered[i].AttunedOrder == _selectedOrder)
					{
						num = i;
						break;
					}
				}
			}
			_hasBlank = num < 0;
			_dropdown.options.Clear();
			if (_hasBlank)
			{
				_dropdown.options.Add(new OptionData(string.Empty));
			}
			for (int j = 0; j < list.Count; j++)
			{
				_dropdown.options.Add(new OptionData(list[j]));
			}
			_dropdown.value = ((!_hasBlank) ? num : 0);
			_dropdown.RefreshShownValue();
		}

		private static void ResolveConfirmButton()
		{
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Expected O, but got Unknown
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Expected O, but got Unknown
			_confirmButton = null;
			RectTransform val = (((Object)(object)_dialog == (Object)null) ? null : ((ConfirmActionMenu)_dialog).ConfirmButton);
			bool flag = default(bool);
			if ((Object)(object)val == (Object)null)
			{
				ManualLogSource log = Plugin.Log;
				BepInExWarningLogInterpolatedStringHandler val2 = new BepInExWarningLogInterpolatedStringHandler(63, 1, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<string>("[Portals][destination]");
					((BepInExLogInterpolatedStringHandler)val2).AppendLiteral(" the window exposes no ConfirmButton - confirm cannot be gated.");
				}
				log.LogWarning(val2);
				return;
			}
			_confirmButton = ((Component)val).GetComponent<Button>();
			if ((Object)(object)_confirmButton == (Object)null)
			{
				ManualLogSource log2 = Plugin.Log;
				BepInExWarningLogInterpolatedStringHandler val2 = new BepInExWarningLogInterpolatedStringHandler(78, 1, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<string>("[Portals][destination]");
					((BepInExLogInterpolatedStringHandler)val2).AppendLiteral(" the ConfirmButton carries no UnityEngine.UI.Button - confirm cannot be gated.");
				}
				log2.LogWarning(val2);
			}
			else
			{
				((Selectable)_confirmButton).interactable = !_hasBlank;
			}
		}

		private static void AttachValueChanged()
		{
			_valueChangedHandler = HandleValueChanged;
			((UnityEvent<int>)(object)_dropdown.onValueChanged).AddListener(DelegateSupport.ConvertDelegate<UnityAction<int>>((Delegate)_valueChangedHandler));
		}

		private static void HandleValueChanged(int value)
		{
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Expected O, but got Unknown
			try
			{
				if (!((Object)(object)_confirmButton == (Object)null))
				{
					((Selectable)_confirmButton).interactable = !_hasBlank || value != 0;
				}
			}
			catch (Exception ex)
			{
				ManualLogSource log = Plugin.Log;
				bool flag = default(bool);
				BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(36, 2, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>("[Portals][destination]");
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" updating the confirm button threw: ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(ex.Message);
				}
				log.LogWarning(val);
			}
		}

		private static void HandleCancel(ConfirmActionMenu menu)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Expected O, but got Unknown
			if (_state != State.Idle)
			{
				Forget();
				ManualLogSource log = Plugin.Log;
				bool flag = default(bool);
				BepInExInfoLogInterpolatedStringHandler val = new BepInExInfoLogInterpolatedStringHandler(29, 1, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>("[Portals][destination]");
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" cancelled - nothing changed.");
				}
				log.LogInfo(val);
			}
		}

		private static bool HandleConfirm()
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Expected O, but got Unknown
			//IL_0152: Unknown result type (might be due to invalid IL or missing references)
			//IL_0159: Expected O, but got Unknown
			//IL_01a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ae: Expected O, but got Unknown
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Expected O, but got Unknown
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Expected O, but got Unknown
			int num;
			try
			{
				num = (((Object)(object)_dropdown == (Object)null) ? (-1) : _dropdown.value);
			}
			catch (Exception ex)
			{
				ManualLogSource log = Plugin.Log;
				bool flag = default(bool);
				BepInExErrorLogInterpolatedStringHandler val = new BepInExErrorLogInterpolatedStringHandler(41, 2, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>("[Portals][destination]");
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" reading the pulldown's selection threw: ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<Exception>(ex);
				}
				log.LogError(val);
				return false;
			}
			bool flag2 = default(bool);
			if (_hasBlank && num <= 0)
			{
				ManualLogSource log2 = Plugin.Log;
				BepInExInfoLogInterpolatedStringHandler val2 = new BepInExInfoLogInterpolatedStringHandler(45, 1, ref flag2);
				if (flag2)
				{
					((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<string>("[Portals][destination]");
					((BepInExLogInterpolatedStringHandler)val2).AppendLiteral(" confirm ignored: no destination is selected.");
				}
				log2.LogInfo(val2);
				return false;
			}
			int num2 = (_hasBlank ? (num - 1) : num);
			if (_ordered == null || num2 < 0 || num2 >= _ordered.Count)
			{
				ManualLogSource log3 = Plugin.Log;
				BepInExWarningLogInterpolatedStringHandler val3 = new BepInExWarningLogInterpolatedStringHandler(45, 2, ref flag2);
				if (flag2)
				{
					((BepInExLogInterpolatedStringHandler)val3).AppendFormatted<string>("[Portals][destination]");
					((BepInExLogInterpolatedStringHandler)val3).AppendLiteral(" confirm ignored: selection ");
					((BepInExLogInterpolatedStringHandler)val3).AppendFormatted<int>(num);
					((BepInExLogInterpolatedStringHandler)val3).AppendLiteral(" names no portal.");
				}
				log3.LogWarning(val3);
				return false;
			}
			PortalRecord portalRecord = _ordered[num2];
			Action<PortalRecord> onPick = _onPick;
			Menu menu = _menu;
			Forget();
			try
			{
				if ((Object)(object)menu != (Object)null)
				{
					menu.Close();
				}
			}
			catch (Exception ex2)
			{
				ManualLogSource log4 = Plugin.Log;
				BepInExWarningLogInterpolatedStringHandler val3 = new BepInExWarningLogInterpolatedStringHandler(39, 2, ref flag2);
				if (flag2)
				{
					((BepInExLogInterpolatedStringHandler)val3).AppendFormatted<string>("[Portals][destination]");
					((BepInExLogInterpolatedStringHandler)val3).AppendLiteral(" closing the destination window threw: ");
					((BepInExLogInterpolatedStringHandler)val3).AppendFormatted<string>(ex2.Message);
				}
				log4.LogWarning(val3);
			}
			if (onPick != null && portalRecord != null)
			{
				try
				{
					onPick(portalRecord);
				}
				catch (Exception ex3)
				{
					ManualLogSource log5 = Plugin.Log;
					BepInExErrorLogInterpolatedStringHandler val = new BepInExErrorLogInterpolatedStringHandler(39, 2, ref flag2);
					if (flag2)
					{
						((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>("[Portals][destination]");
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" storing the chosen destination threw: ");
						((BepInExLogInterpolatedStringHandler)val).AppendFormatted<Exception>(ex3);
					}
					log5.LogError(val);
				}
			}
			return false;
		}

		internal static void Register()
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Expected O, but got Unknown
			try
			{
				Harmony.CreateAndPatchAll(typeof(ConfirmPressPatch), (string)null);
			}
			catch (Exception ex)
			{
				ManualLogSource log = Plugin.Log;
				bool flag = default(bool);
				BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(66, 2, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>("[Portals][destination]");
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" InputFieldConfirmActionMenu._OnConfirmButtonPressed not patched: ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(ex.Message);
				}
				log.LogWarning(val);
			}
		}

		internal static void Reset()
		{
			Forget();
			_lastAliveAt = 0f;
			_openedAt = 0f;
		}

		private static void Forget()
		{
			_state = State.Idle;
			_menu = null;
			_dialog = null;
			_menuPointer = IntPtr.Zero;
			_dropdown = null;
			_confirmButton = null;
			_ordered = null;
			_hasBlank = false;
			_onPick = null;
			_selectedOrder = 0;
		}

		private static void CloseAndFail()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Expected O, but got Unknown
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Expected O, but got Unknown
			bool flag = default(bool);
			try
			{
				if ((Object)(object)_menu != (Object)null)
				{
					_menu.Close();
				}
			}
			catch (Exception ex)
			{
				ManualLogSource log = Plugin.Log;
				BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(46, 2, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>("[Portals][destination]");
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" closing the failed destination window threw: ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(ex.Message);
				}
				log.LogWarning(val);
			}
			Forget();
			try
			{
				ArchUsePatch.Toast("The destination window could not be opened.", (NotificationType)1);
			}
			catch (Exception ex2)
			{
				ManualLogSource log2 = Plugin.Log;
				BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(26, 2, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>("[Portals][destination]");
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" the failure toast threw: ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(ex2.Message);
				}
				log2.LogWarning(val);
			}
		}

		private static bool HasVanished()
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Expected O, but got Unknown
			float num = SafeNow();
			bool flag;
			try
			{
				flag = (Object)(object)_menu != (Object)null && _menu.IsActive;
			}
			catch (Exception ex)
			{
				ManualLogSource log = Plugin.Log;
				bool flag2 = default(bool);
				BepInExErrorLogInterpolatedStringHandler val = new BepInExErrorLogInterpolatedStringHandler(35, 2, ref flag2);
				if (flag2)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>("[Portals][destination]");
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" reading the window's state threw: ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<Exception>(ex);
				}
				log.LogError(val);
				flag = false;
			}
			if (flag)
			{
				_lastAliveAt = num;
				return false;
			}
			return num - _lastAliveAt > 5f;
		}

		private static GameObject ResolveInputFieldDiv()
		{
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Expected O, but got Unknown
			try
			{
				InputFieldHelper val = (((Object)(object)_dialog == (Object)null) ? null : _dialog.InputFieldHelper);
				return ((Object)(object)val == (Object)null) ? null : ((Component)val).gameObject;
			}
			catch (Exception ex)
			{
				ManualLogSource log = Plugin.Log;
				bool flag = default(bool);
				BepInExWarningLogInterpolatedStringHandler val2 = new BepInExWarningLogInterpolatedStringHandler(46, 2, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<string>("[Portals][destination]");
					((BepInExLogInterpolatedStringHandler)val2).AppendLiteral(" reading the window's InputFieldHelper threw: ");
					((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<string>(ex.Message);
				}
				log.LogWarning(val2);
				return null;
			}
		}

		private static Transform FindPanel()
		{
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Expected O, but got Unknown
			try
			{
				Transform val = (((Object)(object)_menu == (Object)null) ? null : ((Component)_menu).transform);
				return ((Object)(object)val == (Object)null) ? null : FindDescendant(val, "Panel");
			}
			catch (Exception ex)
			{
				ManualLogSource log = Plugin.Log;
				bool flag = default(bool);
				BepInExWarningLogInterpolatedStringHandler val2 = new BepInExWarningLogInterpolatedStringHandler(41, 2, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<string>("[Portals][destination]");
					((BepInExLogInterpolatedStringHandler)val2).AppendLiteral(" walking the window for its Panel threw: ");
					((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<string>(ex.Message);
				}
				log.LogWarning(val2);
				return null;
			}
		}

		private static Transform FindDescendant(Transform root, string name)
		{
			for (int i = 0; i < root.childCount; i++)
			{
				Transform child = root.GetChild(i);
				if (!((Object)(object)child == (Object)null))
				{
					if (string.Equals(((Object)child).name, name, StringComparison.Ordinal))
					{
						return child;
					}
					Transform val = FindDescendant(child, name);
					if ((Object)(object)val != (Object)null)
					{
						return val;
					}
				}
			}
			return null;
		}

		private static TMP_Dropdown FindLiveDropdown(out string route)
		{
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Expected O, but got Unknown
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: Expected O, but got Unknown
			//IL_0190: Unknown result type (might be due to invalid IL or missing references)
			//IL_0197: Expected O, but got Unknown
			route = "nothing";
			bool flag = default(bool);
			try
			{
				Il2CppArrayBase<WorkstationMenu> val = Resources.FindObjectsOfTypeAll<WorkstationMenu>();
				for (int i = 0; i < val.Length; i++)
				{
					WorkstationMenu val2 = val[i];
					if (!((Object)(object)val2 == (Object)null))
					{
						TMP_Dropdown outpostSelectionDropdown = val2.outpostSelectionDropdown;
						if ((Object)(object)outpostSelectionDropdown != (Object)null)
						{
							route = "WorkstationMenu.outpostSelectionDropdown";
							return outpostSelectionDropdown;
						}
					}
				}
			}
			catch (Exception ex)
			{
				ManualLogSource log = Plugin.Log;
				BepInExWarningLogInterpolatedStringHandler val3 = new BepInExWarningLogInterpolatedStringHandler(34, 2, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val3).AppendFormatted<string>("[Portals][destination]");
					((BepInExLogInterpolatedStringHandler)val3).AppendLiteral(" the WorkstationMenu route threw: ");
					((BepInExLogInterpolatedStringHandler)val3).AppendFormatted<string>(ex.Message);
				}
				log.LogWarning(val3);
			}
			try
			{
				Il2CppArrayBase<VillagerListController> val4 = Resources.FindObjectsOfTypeAll<VillagerListController>();
				for (int j = 0; j < val4.Length; j++)
				{
					VillagerListController val5 = val4[j];
					if (!((Object)(object)val5 == (Object)null))
					{
						TMP_Dropdown outpostSelectionDropdown2 = val5.outpostSelectionDropdown;
						if ((Object)(object)outpostSelectionDropdown2 != (Object)null)
						{
							route = "VillagerListController.outpostSelectionDropdown";
							return outpostSelectionDropdown2;
						}
					}
				}
			}
			catch (Exception ex2)
			{
				ManualLogSource log2 = Plugin.Log;
				BepInExWarningLogInterpolatedStringHandler val3 = new BepInExWarningLogInterpolatedStringHandler(41, 2, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val3).AppendFormatted<string>("[Portals][destination]");
					((BepInExLogInterpolatedStringHandler)val3).AppendLiteral(" the VillagerListController route threw: ");
					((BepInExLogInterpolatedStringHandler)val3).AppendFormatted<string>(ex2.Message);
				}
				log2.LogWarning(val3);
			}
			try
			{
				Il2CppArrayBase<TMP_Dropdown> val6 = Resources.FindObjectsOfTypeAll<TMP_Dropdown>();
				for (int k = 0; k < val6.Length; k++)
				{
					TMP_Dropdown val7 = val6[k];
					if (!((Object)(object)val7 == (Object)null) && !IsUnderOurMenu(((Component)val7).transform))
					{
						route = "Resources.FindObjectsOfTypeAll<TMP_Dropdown>() scan";
						return val7;
					}
				}
			}
			catch (Exception ex3)
			{
				ManualLogSource log3 = Plugin.Log;
				BepInExWarningLogInterpolatedStringHandler val3 = new BepInExWarningLogInterpolatedStringHandler(38, 2, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val3).AppendFormatted<string>("[Portals][destination]");
					((BepInExLogInterpolatedStringHandler)val3).AppendLiteral(" the whole-scene pulldown scan threw: ");
					((BepInExLogInterpolatedStringHandler)val3).AppendFormatted<string>(ex3.Message);
				}
				log3.LogWarning(val3);
			}
			return null;
		}

		private static bool IsUnderOurMenu(Transform t)
		{
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Expected O, but got Unknown
			try
			{
				Transform val = (((Object)(object)_menu == (Object)null) ? null : ((Component)_menu).transform);
				if ((Object)(object)val == (Object)null)
				{
					return false;
				}
				Transform val2 = t;
				while ((Object)(object)val2 != (Object)null)
				{
					if (val2 == val || ((Il2CppObjectBase)val2).Pointer == ((Il2CppObjectBase)val).Pointer)
					{
						return true;
					}
					val2 = val2.parent;
				}
			}
			catch (Exception ex)
			{
				ManualLogSource log = Plugin.Log;
				bool flag = default(bool);
				BepInExWarningLogInterpolatedStringHandler val3 = new BepInExWarningLogInterpolatedStringHandler(38, 2, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val3).AppendFormatted<string>("[Portals][destination]");
					((BepInExLogInterpolatedStringHandler)val3).AppendLiteral(" testing a pulldown's ancestry threw: ");
					((BepInExLogInterpolatedStringHandler)val3).AppendFormatted<string>(ex.Message);
				}
				log.LogWarning(val3);
			}
			return false;
		}

		private static RectTransform AsRect(Transform t)
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Expected O, but got Unknown
			try
			{
				return ((Object)(object)t == (Object)null) ? null : ((Il2CppObjectBase)t).TryCast<RectTransform>();
			}
			catch (Exception ex)
			{
				ManualLogSource log = Plugin.Log;
				bool flag = default(bool);
				BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(32, 2, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>("[Portals][destination]");
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" reading a RectTransform threw: ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(ex.Message);
				}
				log.LogWarning(val);
				return null;
			}
		}

		private static float SafeNow()
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Expected O, but got Unknown
			try
			{
				return Time.unscaledTime;
			}
			catch (Exception ex)
			{
				ManualLogSource log = Plugin.Log;
				bool flag = default(bool);
				BepInExErrorLogInterpolatedStringHandler val = new BepInExErrorLogInterpolatedStringHandler(26, 2, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>("[Portals][destination]");
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" reading the clock threw: ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<Exception>(ex);
				}
				log.LogError(val);
				return 0f;
			}
		}
	}
	internal static class DestinationList
	{
		internal static int CompareNatural(string a, string b)
		{
			bool flag = string.IsNullOrEmpty(a);
			bool flag2 = string.IsNullOrEmpty(b);
			if (flag && flag2)
			{
				return 0;
			}
			if (flag)
			{
				return -1;
			}
			if (flag2)
			{
				return 1;
			}
			int i = 0;
			int j = 0;
			while (i < a.Length && j < b.Length)
			{
				char c = a[i];
				char c2 = b[j];
				if (IsDigit(c) && IsDigit(c2))
				{
					int num = i;
					int num2 = j;
					for (; i < a.Length && IsDigit(a[i]); i++)
					{
					}
					for (; j < b.Length && IsDigit(b[j]); j++)
					{
					}
					int k;
					for (k = num; k < i - 1 && a[k] == '0'; k++)
					{
					}
					int l;
					for (l = num2; l < j - 1 && b[l] == '0'; l++)
					{
					}
					int num3 = i - k;
					int num4 = j - l;
					if (num3 != num4)
					{
						if (num3 >= num4)
						{
							return 1;
						}
						return -1;
					}
					for (int m = 0; m < num3; m++)
					{
						char c3 = a[k + m];
						char c4 = b[l + m];
						if (c3 != c4)
						{
							if (c3 >= c4)
							{
								return 1;
							}
							return -1;
						}
					}
					int num5 = i - num;
					int num6 = j - num2;
					if (num5 != num6)
					{
						if (num5 >= num6)
						{
							return 1;
						}
						return -1;
					}
					continue;
				}
				char c5 = char.ToUpperInvariant(c);
				char c6 = char.ToUpperInvariant(c2);
				if (c5 != c6)
				{
					if (c5 >= c6)
					{
						return 1;
					}
					return -1;
				}
				i++;
				j++;
			}
			if (i < a.Length)
			{
				return 1;
			}
			if (j < b.Length)
			{
				return -1;
			}
			return 0;
		}

		internal static List<PortalRecord> Order(IReadOnlyList<PortalRecord> portals)
		{
			List<PortalRecord> list = new List<PortalRecord>();
			if (portals == null)
			{
				return list;
			}
			for (int i = 0; i < portals.Count; i++)
			{
				if (portals[i] != null)
				{
					list.Add(portals[i]);
				}
			}
			list.Sort(CompareRecords);
			return list;
		}

		internal static List<string> Labels(IReadOnlyList<PortalRecord> ordered)
		{
			List<string> list = new List<string>();
			if (ordered == null)
			{
				return list;
			}
			for (int i = 0; i < ordered.Count; i++)
			{
				PortalRecord portalRecord = ordered[i];
				if (portalRecord == null)
				{
					list.Add(string.Empty);
					continue;
				}
				string text = portalRecord.Name ?? string.Empty;
				list.Add(Collides(ordered, i, text) ? $"{text} {portalRecord.AttunedOrder}" : text);
			}
			return list;
		}

		private static bool Collides(IReadOnlyList<PortalRecord> ordered, int index, string name)
		{
			for (int i = 0; i < ordered.Count; i++)
			{
				if (i != index)
				{
					PortalRecord portalRecord = ordered[i];
					if (portalRecord != null && CompareNatural(name, portalRecord.Name ?? string.Empty) == 0)
					{
						return true;
					}
				}
			}
			return false;
		}

		private static int CompareRecords(PortalRecord x, PortalRecord y)
		{
			int num = CompareNatural(x.Name, y.Name);
			if (num == 0)
			{
				return x.AttunedOrder.CompareTo(y.AttunedOrder);
			}
			return num;
		}

		private static bool IsDigit(char c)
		{
			if (c >= '0')
			{
				return c <= '9';
			}
			return false;
		}
	}
	internal sealed class ItemCost
	{
		private ItemInfo _info;

		private bool _resolved;

		private bool _errorLogged;

		internal string ItemName { get; }

		internal int Count { get; }

		internal bool IsFree => Count == 0;

		internal string ConfigKey { get; set; } = "cost";

		internal ItemInfo Info
		{
			get
			{
				EnsureResolved();
				return _info;
			}
		}

		internal bool IsResolved
		{
			get
			{
				EnsureResolved();
				return (Object)(object)_info != (Object)null;
			}
		}

		private ItemCost(string itemName, int count)
		{
			ItemName = itemName;
			Count = count;
		}

		internal static ItemCost Unresolvable(string raw)
		{
			return new ItemCost(raw ?? string.Empty, -1);
		}

		internal static bool TryParse(string text, out ItemCost cost, out string error)
		{
			cost = null;
			error = null;
			if (string.IsNullOrWhiteSpace(text))
			{
				error = "empty cost string";
				cost = Unresolvable(text);
				return false;
			}
			int num = text.LastIndexOf(':');
			if (num < 0)
			{
				error = "missing ':' in '" + text + "' (expected <name>:<count>)";
				cost = Unresolvable(text);
				return false;
			}
			string text2 = text.Substring(0, num).Trim();
			string text3 = text.Substring(num + 1).Trim();
			if (text2.Length == 0)
			{
				error = "empty item name in '" + text + "'";
				cost = Unresolvable(text);
				return false;
			}
			if (!int.TryParse(text3, out var result) || result < 0)
			{
				error = $"invalid count '{text3}' in '{text}' (expected a non-negative integer)";
				cost = Unresolvable(text);
				return false;
			}
			cost = new ItemCost(text2, result);
			return true;
		}

		internal string Describe()
		{
			if (IsFree)
			{
				return "nothing";
			}
			if (IsResolved)
			{
				return $"{Count} {ItemName}";
			}
			return ItemName + " (unknown item)";
		}

		private void EnsureResolved()
		{
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Expected O, but got Unknown
			//IL_012e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0135: Expected O, but got Unknown
			if (_resolved || IsFree || Count < 0)
			{
				return;
			}
			ItemInfoDatabase val = ResolveDatabase();
			if ((Object)(object)val == (Object)null)
			{
				return;
			}
			List<ItemInfo> val2 = null;
			bool flag = default(bool);
			try
			{
				ItemInfoList completeItemInfoList = val.CompleteItemInfoList;
				val2 = (((Object)(object)completeItemInfoList != (Object)null) ? completeItemInfoList.itemInfoList : null);
			}
			catch (Exception ex)
			{
				ManualLogSource log = Plugin.Log;
				BepInExWarningLogInterpolatedStringHandler val3 = new BepInExWarningLogInterpolatedStringHandler(39, 1, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val3).AppendLiteral("[Portals][cost] item list read failed: ");
					((BepInExLogInterpolatedStringHandler)val3).AppendFormatted<string>(ex.Message);
				}
				log.LogWarning(val3);
				return;
			}
			if (val2 == null)
			{
				return;
			}
			int count;
			try
			{
				count = val2.Count;
			}
			catch
			{
				return;
			}
			for (int i = 0; i < count; i++)
			{
				ItemInfo val4;
				try
				{
					val4 = val2[i];
				}
				catch
				{
					continue;
				}
				if (!((Object)(object)val4 == (Object)null))
				{
					string text;
					try
					{
						text = val4.Loc("name", (Il2CppStringArray)null);
					}
					catch
					{
						continue;
					}
					if (!string.IsNullOrEmpty(text) && string.Equals(text.Trim(), ItemName, StringComparison.Ordinal))
					{
						_info = val4;
						break;
					}
				}
			}
			_resolved = true;
			if ((Object)(object)_info == (Object)null && !_errorLogged)
			{
				_errorLogged = true;
				ManualLogSource log2 = Plugin.Log;
				BepInExErrorLogInterpolatedStringHandler val5 = new BepInExErrorLogInterpolatedStringHandler(35, 2, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val5).AppendLiteral("[Portals][cost] unknown item '");
					((BepInExLogInterpolatedStringHandler)val5).AppendFormatted<string>(ItemName);
					((BepInExLogInterpolatedStringHandler)val5).AppendLiteral("' in ");
					((BepInExLogInterpolatedStringHandler)val5).AppendFormatted<string>(ConfigKey);
				}
				log2.LogError(val5);
			}
		}

		private static ItemInfoDatabase ResolveDatabase()
		{
			try
			{
				ItemDatabaseManager val = Object.FindObjectOfType<ItemDatabaseManager>();
				return ((Object)(object)val != (Object)null) ? val.Database : null;
			}
			catch
			{
				return null;
			}
		}
	}
	[HarmonyPatch(typeof(PlayerSurvival))]
	public static class PlayerDamagePatch
	{
		[HarmonyPrefix]
		[HarmonyPatch("DoHardLand")]
		public static bool Prefix(PlayerSurvival __instance)
		{
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Expected O, but got Unknown
			try
			{
				if (Time.time < TeleportEngine.SuppressDamageUntil)
				{
					if (Plugin.DebugLogging)
					{
						Plugin.Log.LogInfo((object)"Teleport: hard-land fall damage suppressed (teleport window).");
					}
					return false;
				}
				return true;
			}
			catch (Exception ex)
			{
				ManualLogSource log = Plugin.Log;
				bool flag = default(bool);
				BepInExErrorLogInterpolatedStringHandler val = new BepInExErrorLogInterpolatedStringHandler(53, 1, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("PlayerDamagePatch error (letting hard-land through): ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<Exception>(ex);
				}
				log.LogError(val);
				return true;
			}
		}
	}
	[BepInPlugin("mugsy33.bifrost", "Bifrost", "0.2.0")]
	public class Plugin : BasePlugin
	{
		public const string PluginGuid = "mugsy33.bifrost";

		public const string PluginName = "Bifrost";

		public const string PluginVersion = "0.2.0";

		internal static ManualLogSource Log;

		internal static ConfigEntry<string> ConfigPortalCost;

		internal static ConfigEntry<bool> ConfigRuneRainbow;

		internal static ConfigEntry<string> ConfigRuneColor;

		internal static ItemCost PortalCost;

		internal const float DefaultSafeDropHeight = 1f;

		internal const float DefaultProximityRadius = 1f;

		internal const float DefaultRuneScale = 6f;

		internal static readonly float SafeDropHeight = 1f;

		internal static readonly float ProximityRadius = 1f;

		internal static readonly float RuneScale = 6f;

		internal const bool DefaultRuneRainbow = true;

		internal const string DefaultRuneColorHex = "#33FF66";

		internal static Color RuneColor = new Color(0.2f, 1f, 0.4f, 1f);

		internal static readonly bool DebugLogging = false;

		internal static bool RuneRainbow => ConfigRuneRainbow.Value;

		public override void Load()
		{
			//IL_015a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0161: Expected O, but got Unknown
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Expected O, but got Unknown
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ac: Expected O, but got Unknown
			Log = ((BasePlugin)this).Log;
			ConfigRename.Run(((BasePlugin)this).Config, Log);
			ConfigPortalCost = ((BasePlugin)this).Config.Bind<string>("Portals", "PortalCost", "Jotun Blood:5", "Item cost to open a portal on an Ivy Arch, as <display name>:<count>. A count of 0 makes opening free; a name that does not resolve refuses opening, so a misspelt config never yields a free portal.");
			bool flag = default(bool);
			if (ItemCost.TryParse(ConfigPortalCost.Value, out var cost, out var error))
			{
				PortalCost = cost;
			}
			else
			{
				PortalCost = cost;
				ManualLogSource log = Log;
				BepInExErrorLogInterpolatedStringHandler val = new BepInExErrorLogInterpolatedStringHandler(35, 2, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("[Portals][cost] bad PortalCost '");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(ConfigPortalCost.Value);
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("': ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(error);
				}
				log.LogError(val);
			}
			PortalCost.ConfigKey = "PortalCost";
			ConfigRuneRainbow = ((BasePlugin)this).Config.Bind<bool>("Portals", "RuneRainbow", true, "Cycle the rune effect on an open portal through rainbow colours. Turn it off to use RuneColor instead.");
			ConfigRuneColor = ((BasePlugin)this).Config.Bind<string>("Portals", "RuneColor", "#33FF66", "Colour of the rune effect on an open portal, as a hex value such as #33FF66. Named colours such as \"cyan\" also work. Ignored while RuneRainbow is on.");
			RuneColor = ParseRuneColor(ConfigRuneColor.Value);
			ClassInjector.RegisterTypeInIl2Cpp<TeleportEngine>();
			ClassInjector.RegisterTypeInIl2Cpp<PortalTool>();
			Harmony.CreateAndPatchAll(typeof(CharacterSpawnPatch), (string)null);
			Harmony.CreateAndPatchAll(typeof(PlayerDamagePatch), (string)null);
			try
			{
				Harmony.CreateAndPatchAll(typeof(ArchSpawnPatch), (string)null);
			}
			catch (Exception ex)
			{
				ManualLogSource log2 = Log;
				BepInExWarningLogInterpolatedStringHandler val2 = new BepInExWarningLogInterpolatedStringHandler(54, 1, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val2).AppendLiteral("[Portals][attune] Structure.AfterSpawned not patched: ");
					((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<string>(ex.Message);
				}
				log2.LogWarning(val2);
			}
			ArchUsePatch.Register();
			ArchWidgetPatch.Register();
			ArchPromptConfig.Register();
			DestinationDialog.Register();
			ManualLogSource log3 = Log;
			BepInExInfoLogInterpolatedStringHandler val3 = new BepInExInfoLogInterpolatedStringHandler(10, 2, ref flag);
			if (flag)
			{
				((BepInExLogInterpolatedStringHandler)val3).AppendFormatted<string>("Bifrost");
				((BepInExLogInterpolatedStringHandler)val3).AppendLiteral(" v");
				((BepInExLogInterpolatedStringHandler)val3).AppendFormatted<string>("0.2.0");
				((BepInExLogInterpolatedStringHandler)val3).AppendLiteral(" loaded.");
			}
			log3.LogInfo(val3);
		}

		private static Color ParseRuneColor(string value)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Expected O, but got Unknown
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			Color result = default(Color);
			if (!string.IsNullOrWhiteSpace(value) && ColorUtility.TryParseHtmlString(value.Trim(), ref result))
			{
				return result;
			}
			ManualLogSource log = Log;
			bool flag = default(bool);
			BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(82, 2, ref flag);
			if (flag)
			{
				((BepInExLogInterpolatedStringHandler)val).AppendLiteral("[Portals][visual] RuneColor '");
				((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(value);
				((BepInExLogInterpolatedStringHandler)val).AppendLiteral("' is not a hex value or a known colour name - using ");
				((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>("#33FF66");
				((BepInExLogInterpolatedStringHandler)val).AppendLiteral(".");
			}
			log.LogWarning(val);
			return RuneColor;
		}
	}
	internal static class PortalNaming
	{
		private const string Prefix = "[Portals][name]";

		internal static void ApplyPortalName(Structure arch, PortalRecord record)
		{
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: Expected O, but got Unknown
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Expected O, but got Unknown
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Expected O, but got Unknown
			if ((Object)(object)arch == (Object)null || record == null)
			{
				return;
			}
			bool flag = default(bool);
			try
			{
				string customName = arch.GetCustomName();
				BepInExInfoLogInterpolatedStringHandler val;
				if (!string.IsNullOrWhiteSpace(customName))
				{
					ManualLogSource log = Plugin.Log;
					val = new BepInExInfoLogInterpolatedStringHandler(65, 2, ref flag);
					if (flag)
					{
						((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>("[Portals][name]");
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" the arch is already called '");
						((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(customName);
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral("' - leaving the player's name alone.");
					}
					log.LogInfo(val);
					return;
				}
				string text = $"Portal {record.AttunedOrder}";
				arch.Rpc_ChangeName(text);
				record.Name = text;
				PortalRegistry.Current?.Save();
				ManualLogSource log2 = Plugin.Log;
				val = new BepInExInfoLogInterpolatedStringHandler(17, 2, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>("[Portals][name]");
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" arch renamed to ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(text);
				}
				log2.LogInfo(val);
			}
			catch (Exception ex)
			{
				ManualLogSource log3 = Plugin.Log;
				BepInExErrorLogInterpolatedStringHandler val2 = new BepInExErrorLogInterpolatedStringHandler(26, 2, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<string>("[Portals][name]");
					((BepInExLogInterpolatedStringHandler)val2).AppendLiteral(" renaming the arch threw: ");
					((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<Exception>(ex);
				}
				log3.LogError(val2);
				ArchUsePatch.Toast("The portal could not be renamed.", (NotificationType)1);
			}
		}
	}
	public sealed class PortalRecord
	{
		public string Name { get; set; }

		public int UniqueId { get; set; }

		public float X { get; set; }

		public float Y { get; set; }

		public float Z { get; set; }

		public float ForwardX { get; set; }

		public float ForwardZ { get; set; }

		public string Island { get; set; }

		public int AttunedOrder { get; set; }

		public int DestinationOrder { get; set; }
	}
	public sealed class RegistryFile
	{
		public int Version { get; set; } = 1;

		public string SessionId { get; set; }

		public List<PortalRecord> Portals { get; set; } = new List<PortalRecord>();

		public int LastTravelledTo { get; set; }

		public int LastCameFrom { get; set; }
	}
	internal sealed class PortalRegistry
	{
		private const float MatchRadius = 0.5f;

		private const float MoveEpsilon = 0.05f;

		private const float AxisEpsilon = 0.001f;

		private const float DismantleCheckRadius = 25f;

		private const int MissingTicksToDrop = 3;

		private readonly RegistryFile _file;

		private readonly Dictionary<PortalRecord, int> _missCounts = new Dictionary<PortalRecord, int>();

		internal static PortalRegistry Current { get; private set; }

		internal IReadOnlyList<PortalRecord> Portals => _file.Portals;

		internal int LastTravelledTo => _file.LastTravelledTo;

		internal int LastCameFrom => _file.LastCameFrom;

		private PortalRegistry(RegistryFile file)
		{
			_file = file;
		}

		internal static bool TryLoad()
		{
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Expected O, but got Unknown
			if (!SessionIdentity.TryGetSessionId(out var id))
			{
				return false;
			}
			RegistryFile registryFile = PortalStore.Load(id);
			bool num = Validate(registryFile);
			Current = new PortalRegistry(registryFile);
			ManualLogSource log = Plugin.Log;
			bool flag = default(bool);
			BepInExInfoLogInterpolatedStringHandler val = new BepInExInfoLogInterpolatedStringHandler(37, 2, ref flag);
			if (flag)
			{
				((BepInExLogInterpolatedStringHandler)val).AppendLiteral("[Portals][store] loaded ");
				((BepInExLogInterpolatedStringHandler)val).AppendFormatted<int>(registryFile.Portals.Count);
				((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" portals for ");
				((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(id);
			}
			log.LogInfo(val);
			if (num)
			{
				Current.Save();
			}
			return true;
		}

		private static bool Validate(RegistryFile file)
		{
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Expected O, but got Unknown
			//IL_0199: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a0: Expected O, but got Unknown
			bool result = false;
			List<PortalRecord> portals = file.Portals;
			for (int num = portals.Count - 1; num >= 0; num--)
			{
				if (portals[num] == null)
				{
					portals.RemoveAt(num);
					Plugin.Log.LogWarning((object)"[Portals][store] dropped an empty portal entry");
					result = true;
				}
			}
			int num2 = 0;
			foreach (PortalRecord item in portals)
			{
				if (item.AttunedOrder > num2)
				{
					num2 = item.AttunedOrder;
				}
			}
			HashSet<int> hashSet = new HashSet<int>();
			bool flag = default(bool);
			foreach (PortalRecord item2 in portals)
			{
				if (!hashSet.Add(item2.AttunedOrder))
				{
					int num3 = ++num2;
					ManualLogSource log = Plugin.Log;
					BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(77, 3, ref flag);
					if (flag)
					{
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral("[Portals][store] ");
						((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(item2.Name);
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" shares AttunedOrder ");
						((BepInExLogInterpolatedStringHandler)val).AppendFormatted<int>(item2.AttunedOrder);
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" with an earlier portal; renumbered to ");
						((BepInExLogInterpolatedStringHandler)val).AppendFormatted<int>(num3);
					}
					log.LogWarning(val);
					item2.AttunedOrder = num3;
					hashSet.Add(num3);
					result = true;
				}
			}
			foreach (PortalRecord item3 in portals)
			{
				if (item3.DestinationOrder > 0 && (item3.DestinationOrder == item3.AttunedOrder || !hashSet.Contains(item3.DestinationOrder)))
				{
					ManualLogSource log2 = Plugin.Log;
					BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(80, 2, ref flag);
					if (flag)
					{
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral("[Portals][store] ");
						((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(item3.Name);
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" points at portal ");
						((BepInExLogInterpolatedStringHandler)val).AppendFormatted<int>(item3.DestinationOrder);
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral(", which no longer exists; destination cleared");
					}
					log2.LogWarning(val);
					item3.DestinationOrder = 0;
					result = true;
				}
			}
			return result;
		}

		internal bool TryFindByArch(Structure arch, out PortalRecord record)
		{
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			record = null;
			if ((Object)(object)arch == (Object)null)
			{
				return false;
			}
			int num = ArchTargeting.UniqueIdOf(arch);
			if (num != 0)
			{
				foreach (PortalRecord portal in _file.Portals)
				{
					if (portal.UniqueId == num)
					{
						record = portal;
						return true;
					}
				}
			}
			Vector3 position;
			try
			{
				position = ((Component)arch).transform.position;
			}
			catch
			{
				return false;
			}
			if (TryBackfillByPosition(position, num, out record))
			{
				if (num != 0)
				{
					Save();
				}
				return true;
			}
			return false;
		}

		private bool TryBackfillByPosition(Vector3 pos, int id, out PortalRecord record)
		{
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Expected O, but got Unknown
			record = null;
			bool flag = default(bool);
			foreach (PortalRecord portal in _file.Portals)
			{
				if (portal.UniqueId != 0 || !(Vector3.Distance(new Vector3(portal.X, portal.Y, portal.Z), pos) <= 0.5f))
				{
					continue;
				}
				record = portal;
				if (id != 0)
				{
					portal.UniqueId = id;
					ManualLogSource log = Plugin.Log;
					BepInExInfoLogInterpolatedStringHandler val = new BepInExInfoLogInterpolatedStringHandler(37, 2, ref flag);
					if (flag)
					{
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral("[Portals][sync] back-filled id ");
						((BepInExLogInterpolatedStringHandler)val).AppendFormatted<int>(id);
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" onto ");
						((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(portal.Name);
					}
					log.LogInfo(val);
				}
				return true;
			}
			return false;
		}

		internal PortalRecord Attune(ArchSnapshot snapshot)
		{
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Expected O, but got Unknown
			//IL_0113: Unknown result type (might be due to invalid IL or missing references)
			//IL_0125: Unknown result type (might be due to invalid IL or missing references)
			//IL_0137: Unknown result type (might be due to invalid IL or missing references)
			//IL_0149: Unknown result type (might be due to invalid IL or missing references)
			//IL_015b: Unknown result type (might be due to invalid IL or missing references)
			int num = 1;
			foreach (PortalRecord portal in _file.Portals)
			{
				if (portal.AttunedOrder >= num)
				{
					num = portal.AttunedOrder + 1;
				}
			}
			string text = snapshot.Name ?? "";
			string text2 = (string.IsNullOrEmpty(text) ? $"Portal {num}" : text);
			ManualLogSource log = Plugin.Log;
			bool flag = default(bool);
			BepInExInfoLogInterpolatedStringHandler val = new BepInExInfoLogInterpolatedStringHandler(54, 3, ref flag);
			if (flag)
			{
				((BepInExLogInterpolatedStringHandler)val).AppendLiteral("[Portals][name] attuning arch id ");
				((BepInExLogInterpolatedStringHandler)val).AppendFormatted<int>(snapshot.UniqueId);
				((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" as '");
				((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(text2);
				((BepInExLogInterpolatedStringHandler)val).AppendLiteral("' (arch name '");
				((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(text);
				((BepInExLogInterpolatedStringHandler)val).AppendLiteral("')");
			}
			log.LogInfo(val);
			PortalRecord portalRecord = new PortalRecord
			{
				Name = text2,
				UniqueId = snapshot.UniqueId,
				X = snapshot.Position.x,
				Y = snapshot.Position.y,
				Z = snapshot.Position.z,
				ForwardX = snapshot.OpeningAxis.x,
				ForwardZ = snapshot.OpeningAxis.z,
				Island = "",
				AttunedOrder = num
			};
			_file.Portals.Add(portalRecord);
			Save();
			return portalRecord;
		}

		internal PortalRecord Attune(Structure arch)
		{
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Expected O, but got Unknown
			if (!ArchTargeting.TrySnapshot(arch, out var snapshot))
			{
				Plugin.Log.LogWarning((object)"[Portals][attune] attune refused: the arch could not be read");
				return null;
			}
			PortalRecord portalRecord = Attune(snapshot);
			try
			{
				PortalVisuals.Apply(portalRecord, arch);
			}
			catch (Exception ex)
			{
				ManualLogSource log = Plugin.Log;
				bool flag = default(bool);
				BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(42, 1, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("[Portals][visual] apply on attune failed: ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(ex.Message);
				}
				log.LogWarning(val);
			}
			return portalRecord;
		}

		internal void SetDestination(PortalRecord from, PortalRecord to)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Expected O, but got Unknown
			if (from != null && to != null)
			{
				from.DestinationOrder = to.AttunedOrder;
				Save();
				ManualLogSource log = Plugin.Log;
				bool flag = default(bool);
				BepInExInfoLogInterpolatedStringHandler val = new BepInExInfoLogInterpolatedStringHandler(27, 2, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("[Portals][destination] ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(from.Name);
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" -> ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(to.Name);
				}
				log.LogInfo(val);
			}
		}

		internal bool TryGetDestination(PortalRecord current, out PortalRecord destination)
		{
			destination = null;
			if (current == null || current.DestinationOrder <= 0)
			{
				return false;
			}
			foreach (PortalRecord portal in _file.Portals)
			{
				if (portal != null && portal != current && portal.AttunedOrder == current.DestinationOrder)
				{
					destination = portal;
					return true;
				}
			}
			return false;
		}

		private void ClearDestinationsTo(int order)
		{
			if (order <= 0)
			{
				return;
			}
			foreach (PortalRecord portal in _file.Portals)
			{
				if (portal != null && portal.DestinationOrder == order)
				{
					portal.DestinationOrder = 0;
				}
			}
		}

		internal void RecordTrip(PortalRecord from, PortalRecord to)
		{
			if (from != null && to != null)
			{
				_file.LastCameFrom = from.AttunedOrder;
				_file.LastTravelledTo = to.AttunedOrder;
				Save();
			}
		}

		internal void Save()
		{
			PortalStore.Save(_file);
		}

		internal bool Drop(PortalRecord record)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Expected O, but got Unknown
			if (record == null)
			{
				return false;
			}
			try
			{
				PortalVisuals.Remove(record);
			}
			catch (Exception ex)
			{
				ManualLogSource log = Plugin.Log;
				bool flag = default(bool);
				BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(41, 1, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("[Portals][visual] remove on drop failed: ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(ex.Message);
				}
				log.LogWarning(val);
			}
			bool num = _file.Portals.Remove(record);
			if (num)
			{
				ClearDestinationsTo(record.AttunedOrder);
				Save();
			}
			return num;
		}

		internal void Sync(List<Structure> loaded, Vector3 player)
		{
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Expected O, but got Unknown
			//IL_014d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0154: Expected O, but got Unknown
			//IL_04f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_04fc: Expected O, but got Unknown
			//IL_01b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ba: Expected O, but got Unknown
			//IL_055a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0561: Expected O, but got Unknown
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0479: Unknown result type (might be due to invalid IL or missing references)
			//IL_0487: 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_020c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0221: Unknown result type (might be due to invalid IL or missing references)
			//IL_023c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0267: Unknown result type (might be due to invalid IL or missing references)
			//IL_026e: Expected O, but got Unknown
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_036a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0378: Unknown result type (might be due to invalid IL or missing references)
			//IL_0386: Unknown result type (might be due to invalid IL or missing references)
			//IL_0394: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0306: Unknown result type (might be due to invalid IL or missing references)
			//IL_0325: Unknown result type (might be due to invalid IL or missing references)
			//IL_0344: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_03da: Expected O, but got Unknown
			if (loaded == null)
			{
				return;
			}
			for (int num = loaded.Count - 1; num >= 0; num--)
			{
				if ((Object)(object)loaded[num] == (Object)null)
				{
					loaded.RemoveAt(num);
				}
			}
			bool flag = false;
			HashSet<PortalRecord> hashSet = new HashSet<PortalRecord>();
			bool flag2 = default(bool);
			for (int i = 0; i < loaded.Count; i++)
			{
				Structure val = loaded[i];
				int uniqueId;
				bool dismantled;
				Vector3 position;
				Vector3 val2;
				string text;
				try
				{
					uniqueId = val._uniqueId;
					dismantled = val.Dismantled;
					position = ((Component)val).transform.position;
					val2 = ArchTargeting.OpeningAxis(val);
					text = ArchTargeting.NameOf(val);
				}
				catch (Exception ex)
				{
					ManualLogSource log = Plugin.Log;
					BepInExWarningLogInterpolatedStringHandler val3 = new BepInExWarningLogInterpolatedStringHandler(34, 1, ref flag2);
					if (flag2)
					{
						((BepInExLogInterpolatedStringHandler)val3).AppendLiteral("[Portals][sync] arch read failed: ");
						((BepInExLogInterpolatedStringHandler)val3).AppendFormatted<string>(ex.Message);
					}
					log.LogWarning(val3);
					continue;
				}
				ArchTargeting.AnnounceOnce(val, uniqueId);
				PortalRecord record = null;
				if (uniqueId != 0)
				{
					foreach (PortalRecord portal in _file.Portals)
					{
						if (portal.UniqueId == uniqueId)
						{
							record = portal;
							break;
						}
					}
					if (record == null && TryBackfillByPosition(position, uniqueId, out record))
					{
						flag = true;
					}
				}
				if (record == null)
				{
					continue;
				}
				hashSet.Add(record);
				if (dismantled)
				{
					try
					{
						PortalVisuals.Remove(record);
					}
					catch (Exception ex2)
					{
						ManualLogSource log2 = Plugin.Log;
						BepInExWarningLogInterpolatedStringHandler val3 = new BepInExWarningLogInterpolatedStringHandler(46, 1, ref flag2);
						if (flag2)
						{
							((BepInExLogInterpolatedStringHandler)val3).AppendLiteral("[Portals][visual] remove on dismantle failed: ");
							((BepInExLogInterpolatedStringHandler)val3).AppendFormatted<string>(ex2.Message);
						}
						log2.LogWarning(val3);
					}
					_file.Portals.Remove(record);
					_missCounts.Remove(record);
					ClearDestinationsTo(record.AttunedOrder);
					ManualLogSource log3 = Plugin.Log;
					BepInExInfoLogInterpolatedStringHandler val4 = new BepInExInfoLogInterpolatedStringHandler(41, 1, ref flag2);
					if (flag2)
					{
						((BepInExLogInterpolatedStringHandler)val4).AppendLiteral("[Portals][sync] ");
						((BepInExLogInterpolatedStringHandler)val4).AppendFormatted<string>(record.Name);
						((BepInExLogInterpolatedStringHandler)val4).AppendLiteral(" dropped: arch dismantled");
					}
					log3.LogInfo(val4);
					flag = true;
					continue;
				}
				bool num2 = Vector3.Distance(new Vector3(record.X, record.Y, record.Z), position) > 0.05f;
				bool flag3 = Mathf.Abs(record.ForwardX - val2.x) > 0.001f || Mathf.Abs(record.ForwardZ - val2.z) > 0.001f;
				if (num2 || flag3)
				{
					ManualLogSource log4 = Plugin.Log;
					BepInExInfoLogInterpolatedStringHandler val4 = new BepInExInfoLogInterpolatedStringHandler(39, 7, ref flag2);
					if (flag2)
					{
						((BepInExLogInterpolatedStringHandler)val4).AppendLiteral("[Portals][sync] ");
						((BepInExLogInterpolatedStringHandler)val4).AppendFormatted<string>(record.Name);
						((BepInExLogInterpolatedStringHandler)val4).AppendLiteral(" moved ");
						((BepInExLogInterpolatedStringHandler)val4).AppendLiteral("(");
						((BepInExLogInterpolatedStringHandler)val4).AppendFormatted<float>(record.X, "F1");
						((BepInExLogInterpolatedStringHandler)val4).AppendLiteral(", ");
						((BepInExLogInterpolatedStringHandler)val4).AppendFormatted<float>(record.Y, "F1");
						((BepInExLogInterpolatedStringHandler)val4).AppendLiteral(", ");
						((BepInExLogInterpolatedStringHandler)val4).AppendFormatted<float>(record.Z, "F1");
						((BepInExLogInterpolatedStringHandler)val4).AppendLiteral(") -> (");
						((BepInExLogInterpolatedStringHandler)val4).AppendFormatted<float>(position.x, "F1");
						((BepInExLogInterpolatedStringHandler)val4).AppendLiteral(", ");
						((BepInExLogInterpolatedStringHandler)val4).AppendFormatted<float>(position.y, "F1");
						((BepInExLogInterpolatedStringHandler)val4).AppendLiteral(", ");
						((BepInExLogInterpolatedStringHandler)val4).AppendFormatted<float>(position.z, "F1");
						((BepInExLogInterpolatedStringHandler)val4).AppendLiteral(")");
					}
					log4.LogInfo(val4);
					record.X = position.x;
					record.Y = position.y;
					record.Z = position.z;
					record.ForwardX = val2.x;
					record.ForwardZ = val2.z;
					flag = true;
				}
				if (!string.IsNullOrEmpty(text) && text != record.Name)
				{
					ManualLogSource log5 = Plugin.Log;
					BepInExInfoLogInterpolatedStringHandler val4 = new BepInExInfoLogInterpolatedStringHandler(28, 2, ref flag2);
					if (flag2)
					{
						((BepInExLogInterpolatedStringHandler)val4).AppendLiteral("[Portals][sync] ");
						((BepInExLogInterpolatedStringHandler)val4).AppendFormatted<string>(record.Name);
						((BepInExLogInterpolatedStringHandler)val4).AppendLiteral(" renamed to ");
						((BepInExLogInterpolatedStringHandler)val4).AppendFormatted<string>(text);
					}
					log5.LogInfo(val4);
					record.Name = text;
					flag = true;
				}
			}
			for (int num3 = _file.Portals.Count - 1; num3 >= 0; num3--)
			{
				PortalRecord portalRecord = _file.Portals[num3];
				if (hashSet.Contains(portalRecord))
				{
					_missCounts[portalRecord] = 0;
				}
				else
				{
					float num4 = player.x - portalRecord.X;
					float num5 = player.z - portalRecord.Z;
					if (!(num4 * num4 + num5 * num5 <= 625f))
					{
						_missCounts[portalRecord] = 0;
					}
					else
					{
						int value;
						int num6 = (_missCounts.TryGetValue(portalRecord, out value) ? value : 0) + 1;
						if (num6 >= 3)
						{
							try
							{
								PortalVisuals.Remove(portalRecord);
							}
							catch (Exception ex3)
							{
								ManualLogSource log6 = Plugin.Log;
								BepInExWarningLogInterpolatedStringHandler val3 = new BepInExWarningLogInterpolatedStringHandler(44, 1, ref flag2);
								if (flag2)
								{
									((BepInExLogInterpolatedStringHandler)val3).AppendLiteral("[Portals][visual] remove on missing failed: ");
									((BepInExLogInterpolatedStringHandler)val3).AppendFormatted<string>(ex3.Message);
								}
								log6.LogWarning(val3);
							}
							_file.Portals.RemoveAt(num3);
							_missCounts.Remove(portalRecord);
							ClearDestinationsTo(portalRecord.AttunedOrder);
							ManualLogSource log7 = Plugin.Log;
							BepInExInfoLogInterpolatedStringHandler val4 = new BepInExInfoLogInterpolatedStringHandler(38, 1, ref flag2);
							if (flag2)
							{
								((BepInExLogInterpolatedStringHandler)val4).AppendLiteral("[Portals][sync] ");
								((BepInExLogInterpolatedStringHandler)val4).AppendFormatted<string>(portalRecord.Name);
								((BepInExLogInterpolatedStringHandler)val4).AppendLiteral(" dropped: arch missing");
							}
							log7.LogInfo(val4);
							flag = true;
						}
						else
						{
							_missCounts[portalRecord] = num6;
						}
					}
				}
			}
			if (flag)
			{
				Save();
			}
		}
	}
	internal static class PortalStore
	{
		private static readonly JsonSerializerOptions Options = new JsonSerializerOptions
		{
			WriteIndented = true
		};

		internal const string RegistryFolder = "Bifrost";

		internal static string PathFor(string sessionId)
		{
			return Path.Combine(Paths.ConfigPath, "Bifrost", "portals-" + sessionId + ".json");
		}

		internal static RegistryFile Load(string sessionId)
		{
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Expected O, but got Unknown
			string path = PathFor(sessionId);
			try
			{
				if (!File.Exists(path))
				{
					return new RegistryFile
					{
						SessionId = sessionId
					};
				}
				RegistryFile registryFile = JsonSerializer.Deserialize<RegistryFile>(File.ReadAllText(path), Options);
				if (registryFile == null)
				{
					return new RegistryFile
					{
						SessionId = sessionId
					};
				}
				RegistryFile registryFile2 = registryFile;
				if (registryFile2.Portals == null)
				{
					List<PortalRecord> list = (registryFile2.Portals = new List<PortalRecord>());
				}
				registryFile2 = registryFile;
				if (registryFile2.SessionId == null)
				{
					string text = (registryFile2.SessionId = sessionId);
				}
				return registryFile;
			}
			catch (Exception ex)
			{
				ManualLogSource log = Plugin.Log;
				bool flag = default(bool);
				BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(53, 2, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("[Portals][store] load failed for ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(sessionId);
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" (");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(ex.Message);
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("); starting empty.");
				}
				log.LogWarning(val);
				return new RegistryFile
				{
					SessionId = sessionId
				};
			}
		}

		internal static void Save(RegistryFile file)
		{
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Expected O, but got Unknown
			string text = PathFor(file.SessionId);
			try
			{
				Directory.CreateDirectory(Path.GetDirectoryName(text));
				string text2 = text + ".tmp";
				File.WriteAllText(text2, JsonSerializer.Serialize(file, Options));
				File.Copy(text2, text, overwrite: true);
				File.Delete(text2);
			}
			catch (Exception ex)
			{
				ManualLogSource log = Plugin.Log;
				bool flag = default(bool);
				BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(35, 2, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("[Portals][store] save failed for ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(file.SessionId);
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral(": ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(ex.Message);
				}
				log.LogWarning(val);
			}
		}
	}
	public class PortalTool : MonoBehaviour
	{
		private Character _character;

		private TeleportEngine _engine;

		private bool _loaded;

		private bool _swept;

		private float _nextPendingDrain;

		private const float PendingDrainSeconds = 2f;

		private PortalRecord _nearby;

		private int _side;

		private PortalRecord _arrival;

		private static PortalRecord _pendingDestination;

		private static int _pendingFrame;

		private const float ExitDistance = 1.5f;

		private const float PlaneEpsilon = 0.01f;

		internal static Character LocalCharacter { get; private set; }

		internal PortalRecord NearbyPortal => _nearby;

		private void Start()
		{
			_character = ((Component)this).GetComponentInParent<Character>();
			LocalCharacter = _character;
			_engine = ((Component)this).GetComponent<TeleportEngine>();
			if ((Object)(object)_character == (Object)null)
			{
				Plugin.Log.LogWarning((object)"PortalTool: Character not resolved in Start; will retry each frame.");
			}
		}

		private void Update()
		{
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Expected O, but got Unknown
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Expected O, but got Unknown
			//IL_017a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0180: Expected O, but got Unknown
			//IL_0203: Unknown result type (might be due to invalid IL or missing references)
			//IL_020a: Expected O, but got Unknown
			bool flag = default(bool);
			try
			{
				if (!_loaded)
				{
					if (!PortalRegistry.TryLoad())
					{
						return;
					}
					_loaded = true;
					_pendingDestination = null;
					_pendingFrame = 0;
					ArchConfirmDialog.Reset();
					DestinationDialog.Reset();
					try
					{
						PortalVisuals.Clear();
					}
					catch (Exception ex)
					{
						ManualLogSource log = Plugin.Log;
						BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(40, 1, ref flag);
						if (flag)
						{
							((BepInExLogInterpolatedStringHandler)val).AppendLiteral("[Portals][visual] clear on load failed: ");
							((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(ex.Message);
						}
						log.LogWarning(val);
					}
					try
					{
						PortalVisuals.ApplyAll(PortalRegistry.Current);
						return;
					}
					catch (Exception ex2)
					{
						ManualLogSource log2 = Plugin.Log;
						BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(40, 1, ref flag);
						if (flag)
						{
							((BepInExLogInterpolatedStringHandler)val).AppendLiteral("[Portals][visual] apply on load failed: ");
							((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(ex2.Message);
						}
						log2.LogWarning(val);
						return;
					}
				}
				if ((Object)(object)_character == (Object)null)
				{
					_character = ((Component)this).GetComponentInParent<Character>();
					if ((Object)(object)_character == (Object)null)
					{
						return;
					}
					LocalCharacter = _character;
				}
				if ((Object)(object)_engine == (Object)null)
				{
					_engine = ((Component)this).GetComponent<TeleportEngine>();
					if ((Object)(object)_engine == (Object)null)
					{
						return;
					}
				}
				if (!_swept)
				{
					_swept = true;
					SweepArches();
				}
				if (Time.time >= _nextPendingDrain)
				{
					_nextPendingDrain = Time.time + 2f;
					DrainPending();
					if (_engine.IsIdle)
					{
						SyncPortals();
						try
						{
							PortalVisuals.ApplyAll(PortalRegistry.Current);
						}
						catch (Exception ex3)
						{
							ManualLogSource log3 = Plugin.Log;
							BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(40, 1, ref flag);
							if (flag)
							{
								((BepInExLogInterpolatedStringHandler)val).AppendLiteral("[Portals][visual] apply on tick failed: ");
								((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(ex3.Message);
							}
							log3.LogWarning(val);
						}
					}
				}
				PortalVisuals.Tick();
				DestinationDialog.Tick();
				if (!_character.IsDead && !_character.IsKnockedDown() && !((Object)(object)_character.MountedObject != (Object)null) && (_pendingDestination == null || !TryOpenPendingDestination()))
				{
					TrackTravel();
				}
			}
			catch (Exception ex4)
			{
				ManualLogSource log4 = Plugin.Log;
				BepInExErrorLogInterpolatedStringHandler val2 = new BepInExErrorLogInterpolatedStringHandler(23, 1, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val2).AppendLiteral("PortalTool flow error: ");
					((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<Exception>(ex4);
				}
				log4.LogError(val2);
			}
		}

		private void SweepArches()
		{
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Expected O, but got Unknown
			try
			{
				List<Structure> list = ArchTargeting.FindArches();
				for (int i = 0; i < list.Count; i++)
				{
					Structure val = list[i];
					if (!((Object)(object)val == (Object)null))
					{
						ArchTargeting.NoteLoaded(val);
						if (!ArchInteraction.IsInjected(val) && !ArchInteraction.TryInject(val, out var reason) && (!(reason != "source-missing") || !(reason != "not-built")))
						{
							ArchInteraction.Pending.Add(val);
						}
					}
				}
			}
			catch (Exception ex)
			{
				ManualLogSource log = Plugin.Log;
				bool flag = default(bool);
				BepInExWarningLogInterpolatedStringHandler val2 = new BepInExWarningLogInterpolatedStringHandler(37, 1, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val2).AppendLiteral("[Portals][attune] arch sweep failed: ");
					((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<string>(ex.Message);
				}
				log.LogWarning(val2);
			}
		}

		private void DrainPending()
		{
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Expected O, but got Unknown
			try
			{
				List<Structure> pending = ArchInteraction.Pending;
				for (int num = pending.Count - 1; num >= 0; num--)
				{
					Structure val = pending[num];
					if ((Object)(object)val == (Object)null || ArchInteraction.IsInjected(val) || ArchInteraction.TryInject(val, out var _))
					{
						pending.RemoveAt(num);
					}
				}
			}
			catch (Exception ex)
			{
				ManualLogSource log = Plugin.Log;
				bool flag = default(bool);
				BepInExWarningLogInterpolatedStringHandler val2 = new BepInExWarningLogInterpolatedStringHandler(40, 1, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val2).AppendLiteral("[Portals][attune] pending drain failed: ");
					((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<string>(ex.Message);
				}
				log.LogWarning(val2);
			}
		}

		private void SyncPortals()
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Expected O, but got Unknown
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			PortalRegistry current = PortalRegistry.Current;
			if (current == null)
			{
				return;
			}
			Vector3 position;
			try
			{
				position = ((Component)_character).transform.position;
			}
			catch (Exception ex)
			{
				ManualLogSource log = Plugin.Log;
				bool flag = default(bool);
				BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(45, 1, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("[Portals][sync] player position read failed: ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(ex.Message);
				}
				log.LogWarning(val);
				return;
			}
			current.Sync(ArchTargeting.Loaded, position);
		}

		private void TrackTravel()
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Expected O, but got Unknown
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Expected O, but got Unknown
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_012f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0136: Expected O, but got Unknown
			PortalRegistry current = PortalRegistry.Current;
			if (current == null)
			{
				return;
			}
			Vector3 position;
			bool flag = default(bool);
			try
			{
				position = ((Component)_character).transform.position;
			}
			catch (Exception ex)
			{
				ManualLogSource log = Plugin.Log;
				BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(47, 1, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("[Portals][travel] player position read failed: ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(ex.Message);
				}
				log.LogWarning(val);
				return;
			}
			float proximityRadius = Plugin.ProximityRadius;
			if (_arrival != null && !WithinRadius(_arrival, position, proximityRadius))
			{
				ManualLogSource log2 = Plugin.Log;
				BepInExInfoLogInterpolatedStringHandler val2 = new BepInExInfoLogInterpolatedStringHandler(33, 1, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val2).AppendLiteral("[Portals][travel] re-armed: left ");
					((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<string>(_arrival.Name);
				}
				log2.LogInfo(val2);
				_arrival = null;
			}
			PortalRecord portalRecord = NearestWithin(current, position, proximityRadius);
			if (portalRecord == null)
			{
				_nearby = null;
				_side = 0;
				return;
			}
			if (portalRecord != _nearby)
			{
				_nearby = portalRecord;
				_side = 0;
			}
			int num = SideOf(portalRecord, position);
			if (num == 0)
			{
				return;
			}
			if (_side == 0)
			{
				_side = num;
			}
			else if (num != _side)
			{
				int side = _side;
				_side = num;
				ManualLogSource log3 = Plugin.Log;
				BepInExInfoLogInterpolatedStringHandler val2 = new BepInExInfoLogInterpolatedStringHandler(33, 3, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val2).AppendLiteral("[Portals][travel] crossed ");
					((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<string>(portalRecord.Name);
					((BepInExLogInterpolatedStringHandler)val2).AppendLiteral(" (");
					((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<int>(side);
					((BepInExLogInterpolatedStringHandler)val2).AppendLiteral(" -> ");
					((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<int>(num);
					((BepInExLogInterpolatedStringHandler)val2).AppendLiteral(")");
				}
				log3.LogInfo(val2);
				if (_arrival == null)
				{
					Travel(portalRecord);
				}
			}
		}

		private void Travel(PortalRecord current)
		{
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Expected O, but got Unknown
			PortalRegistry current2 = PortalRegistry.Current;
			if (current2 == null || current == null)
			{
				return;
			}
			if (current2.Portals.Count == 1)
			{
				TravelTo(current, current);
				return;
			}
			if (current2.TryGetDestination(current, out var destination))
			{
				TravelTo(current, destination);
				return;
			}
			ArchUsePatch.Toast("No destination set - press E on the portal to choose one.", (NotificationType)1);
			ManualLogSource log = Plugin.Log;
			bool flag = default(bool);
			BepInExInfoLogInterpolatedStringHandler val = new BepInExInfoLogInterpolatedStringHandler(38, 1, ref flag);
			if (flag)
			{
				((BepInExLogInterpolatedStringHandler)val).AppendLiteral("[Portals][travel] no destination from ");
				((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(current.Name);
			}
			log.LogInfo(val);
		}

		private void TravelTo(PortalRecord current, PortalRecord target)
		{
			//IL_006f: 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_01bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c3: Expected O, but got Unknown
			//IL_010e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0115: Expected O, but got Unknown
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Expected O, but got Unknown
			PortalRegistry current2 = PortalRegistry.Current;
			if (current2 == null || current == null || target == null || !_engine.IsIdle)
			{
				return;
			}
			Vector3 destination = default(Vector3);
			((Vector3)(ref destination))..ctor(target.X + target.ForwardX * 1.5f, target.Y, target.Z + target.ForwardZ * 1.5f);
			Vector3 facing = default(Vector3);
			((Vector3)(ref facing))..ctor(target.ForwardX, 0f, target.ForwardZ);
			bool flag = default(bool);
			if (!_engine.Request(destination, facing))
			{
				float cooldownRemaining = _engine.CooldownRemaining;
				if (cooldownRemaining > 0f)
				{
					ManualLogSource log = Plugin.Log;
					BepInExInfoLogInterpolatedStringHandler val = new BepInExInfoLogInterpolatedStringHandler(57, 3, ref flag);
					if (flag)
					{
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral("[Portals][travel] ");
						((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(current.Name);
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" -> ");
						((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(target.Name);
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" refused: teleport cooldown, ");
						((BepInExLogInterpolatedStringHandler)val).AppendFormatted<float>(cooldownRemaining, "F2");
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral("s left");
					}
					log.LogInfo(val);
				}
				else
				{
					ManualLogSource log2 = Plugin.Log;
					BepInExWarningLogInterpolatedStringHandler val2 = new BepInExWarningLogInterpolatedStringHandler(75, 2, ref flag);
					if (flag)
					{
						((BepInExLogInterpolatedStringHandler)val2).AppendLiteral("[Portals][travel] ");
						((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<string>(current.Name);
						((BepInExLogInterpolatedStringHandler)val2).AppendLiteral(" -> ");
						((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<string>(target.Name);
						((BepInExLogInterpolatedStringHandler)val2).AppendLiteral(" refused: the engine would not start (no PlayerDrive)");
					}
					log2.LogWarning(val2);
				}
				if (cooldownRemaining >= 1f || cooldownRemaining <= 0f)
				{
					ArchUsePatch.Toast("The portal is still settling.", (NotificationType)1);
				}
			}
			else
			{
				current2.RecordTrip(current, target);
				_arrival = target;
				_nearby = null;
				_side = 0;
				Toast("Travelled to " + target.Name + ".");
				ManualLogSource log3 = Plugin.Log;
				BepInExInfoLogInterpolatedStringHandler val = new BepInExInfoLogInterpolatedStringHandler(22, 2, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("[Portals][travel] ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(current.Name);
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" -> ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(target.Name);
				}
				log3.LogInfo(val);
			}
		}

		internal static void RequestDestinationDialog(PortalRecord record)
		{
			if (record != null)
			{
				_pendingDestination = record;
				_pendingFrame = Time.frameCount;
			}
		}

		private bool TryOpenPendingDestination()
		{
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: Expected O, but got Unknown
			if (Time.frameCount == _pendingFrame)
			{
				return false;
			}
			if (!_engine.IsIdle || ArchConfirmDialog.IsOpen || DestinationDialog.IsOpen)
			{
				return false;
			}
			PortalRecord pendingDestination = _pendingDestination;
			_pendingDestination = null;
			PortalRegistry registry = PortalRegistry.Current;
			if (registry == null || pendingDestination == null)
			{
				return true;
			}
			List<PortalRecord> list = new List<PortalRecord>();
			IReadOnlyList<PortalRecord> portals = registry.Portals;
			for (int i = 0; i < portals.Count; i++)
			{
				PortalRecord portalRecord = portals[i];
				if (portalRecord != null && portalRecord != pendingDestination)
				{
					list.Add(portalRecord);
				}
			}
			if (list.Count == 0)
			{
				return true;
			}
			registry.TryGetDestination(pendingDestination, out var destination);
			PortalRecord from = pendingDestination;
			if (!DestinationDialog.TryOpen(pendingDestination, list, destination, delegate(PortalRecord picked)
			{
				registry.SetDestination(from, picked);
				Toast(from.Name + " now leads to " + picked.Name + ".");
			}))
			{
				ManualLogSource log = Plugin.Log;
				bool flag = default(bool);
				BepInExErrorLogInterpolatedStringHandler val = new BepInExErrorLogInterpolatedStringHandler(66, 1, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("[Portals][destination] the destination window would not open for ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(from.Name);
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral(".");
				}
				log.LogError(val);
				ArchUsePatch.Toast("The destination window could not be opened.", (NotificationType)1);
			}
			return true;
		}

		private static PortalRecord NearestWithin(PortalRegistry registry, Vector3 player, float radius)
		{
			//IL_001e: 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)
			PortalRecord result = null;
			float num = radius * radius;
			IReadOnlyList<PortalRecord> portals = registry.Portals;
			for (int i = 0; i < portals.Count; i++)
			{
				PortalRecord portalRecord = portals[i];
				if (portalRecord != null)
				{
					float num2 = player.x - portalRecord.X;
					float num3 = player.z - portalRecord.Z;
					float num4 = num2 * num2 + num3 * num3;
					if (num4 <= num)
					{
						num = num4;
						result = portalRecord;
					}
				}
			}
			return result;
		}

		private static bool WithinRadius(PortalRecord record, Vector3 player, float radius)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			float num = player.x - record.X;
			float num2 = player.z - record.Z;
			return num * num + num2 * num2 <= radius * radius;
		}

		private static int SideOf(PortalRecord record, Vector3 player)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			float num = player.x - record.X;
			float num2 = player.z - record.Z;
			float num3 = num * record.ForwardX + num2 * record.ForwardZ;
			if (num3 > 0.01f)
			{
				return 1;
			}
			if (num3 < -0.01f)
			{
				return -1;
			}
			return 0;
		}

		private void Toast(string message)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Expected O, but got Unknown
			try
			{
				string text = message;
				NotificationMenu.Display((NotificationType)0, ref text, false);
			}
			catch (Exception ex)
			{
				ManualLogSource log = Plugin.Log;
				bool flag = default(bool);
				BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(26, 1, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("PortalTool notify failed: ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(ex.Message);
				}
				log.LogWarning(val);
			}
		}
	}
	internal static class PortalVisuals
	{
		private sealed class Entry
		{
			internal Structure Arch;

			internal GameObject RuneFx;

			internal readonly List<VisualEffect> Effects = new List<VisualEffect>();

			internal readonly List<Light> Lights = new List<Light>();
		}

		private static readonly Dictionary<PortalRecord, Entry> _entries = new Dictionary<PortalRecord, Entry>();

		private const string VfxColorProperty = "Color";

		private const float RainbowSpeed = 0.15f;

		private static Color _fixedApplied = new Color(0f, 0f, 0f, 0f);

		private static GameObject _runeTemplate;

		private static Vector3 _runeTemplateScale = Vector3.one;

		private static float _nextRuneSearch;

		internal static void Apply(PortalRecord record, Structure arch)
		{
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Expected O, but got Unknown
			if (record == null || (Object)(object)arch == (Object)null)
			{
				return;
			}
			if (_entries.TryGetValue(record, out var value))
			{
				if ((Object)(object)value.Arch == (Object)(object)arch)
				{
					PositionRuneFx(value, arch);
					if ((Object)(object)value.RuneFx == (Object)null)
					{
						AttachRuneFx(record, value, arch);
					}
					return;
				}
				RemoveEntry(record, value);
			}
			Entry entry = new Entry
			{
				Arch = arch
			};
			string text = (AttachRuneFx(record, entry, arch) ? "rune fx attached" : "no rune fx yet");
			_entries[record] = entry;
			ManualLogSource log = Plugin.Log;
			bool flag = default(bool);
			BepInExInfoLogInterpolatedStringHandler val = new BepInExInfoLogInterpolatedStringHandler(28, 2, ref flag);
			if (flag)
			{
				((BepInExLogInterpolatedStringHandler)val).AppendLiteral("[Portals][visual] applied ");
				((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(record.Name);
				((BepInExLogInterpolatedStringHandler)val).AppendLiteral(": ");
				((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(text);
			}
			log.LogInfo(val);
		}

		internal static void Remove(PortalRecord record)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Expected O, but got Unknown
			if (record != null && _entries.TryGetValue(record, out var value))
			{
				RemoveEntry(record, value);
				ManualLogSource log = Plugin.Log;
				bool flag = default(bool);
				BepInExInfoLogInterpolatedStringHandler val = new BepInExInfoLogInterpolatedStringHandler(26, 1, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("[Portals][visual] removed ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(record.Name);
				}
				log.LogInfo(val);
			}
		}

		internal static void Clear()
		{
			if (_entries.Count == 0)
			{
				return;
			}
			foreach (PortalRecord item in new List<PortalRecord>(_entries.Keys))
			{
				Remove(item);
			}
			_entries.Clear();
		}

		internal static void ApplyAll(PortalRegistry registry)
		{
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Expected O, but got Unknown
			if (registry == null)
			{
				return;
			}
			List<Structure> loaded = ArchTargeting.Loaded;
			if (loaded == null)
			{
				return;
			}
			bool flag = default(bool);
			for (int i = 0; i < loaded.Count; i++)
			{
				Structure val = loaded[i];
				if ((Object)(object)val == (Object)null)
				{
					continue;
				}
				try
				{
					if (registry.TryFindByArch(val, out var record))
					{
						Apply(record, val);
					}
				}
				catch (Exception ex)
				{
					ManualLogSource log = Plugin.Log;
					BepInExWarningLogInterpolatedStringHandler val2 = new BepInExWarningLogInterpolatedStringHandler(32, 1, ref flag);
					if (flag)
					{
						((BepInExLogInterpolatedStringHandler)val2).AppendLiteral("[Portals][visual] apply failed: ");
						((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<string>(ex.Message);
					}
					log.LogWarning(val2);
				}
			}
		}

		private static bool AttachRuneFx(PortalRecord record, Entry entry, Structure arch)
		{
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Expected O, but got Unknown
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Expected O, but got Unknown
			if ((Object)(object)entry.RuneFx != (Object)null)
			{
				return true;
			}
			GameObject val = RuneTemplate();
			if ((Object)(object)val == (Object)null)
			{
				return false;
			}
			try
			{
				GameObject val2 = Object.Instantiate<GameObject>(val);
				val2.transform.SetParent((Transform)null, true);
				val2.transform.localScale = _runeTemplateScale * Plugin.RuneScale;
				val2.SetActive(true);
				entry.RuneFx = val2;
				CollectColorTargets(entry, val2);
				ApplyColor(entry, CurrentColor());
				PositionRuneFx(entry, arch);
				ManualLogSource log = Plugin.Log;
				bool flag = default(bool);
				BepInExInfoLogInterpolatedStringHandler val3 = new BepInExInfoLogInterpolatedStringHandler(38, 1, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val3).AppendLiteral("[Portals][visual] rune fx attached to ");
					((BepInExLogInterpolatedStringHandler)val3).AppendFormatted<string>(record.Name);
				}
				log.LogInfo(val3);
				return true;
			}
			catch (Exception ex)
			{
				ManualLogSource log2 = Plugin.Log;
				bool flag2 = default(bool);
				BepInExWarningLogInterpolatedStringHandler val4 = new BepInExWarningLogInterpolatedStringHandler(41, 1, ref flag2);
				if (flag2)
				{
					((BepInExLogInterpolatedStringHandler)val4).AppendLiteral("[Portals][visual] rune fx attach failed: ");
					((BepInExLogInterpolatedStringHandler)val4).AppendFormatted<string>(ex.Message);
				}
				log2.LogWarning(val4);
				return false;
			}
		}

		private static void PositionRuneFx(Entry entry, Structure arch)
		{
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Expected O, but got Unknown
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)entry.RuneFx == (Object)null || (Object)(object)arch == (Object)null)
			{
				return;
			}
			try
			{
				entry.RuneFx.transform.position = ((Component)arch).transform.position;
			}
			catch (Exception ex)
			{
				ManualLogSource log = Plugin.Log;
				bool flag = default(bool);
				BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(45, 1, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("[Portals][visual] rune fx reposition failed: ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(ex.Message);
				}
				log.LogWarning(val);
			}
		}

		private static Color CurrentColor()
		{
			//IL_002c: 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 (Plugin.RuneRainbow)
			{
				return Color.HSVToRGB(Mathf.Repeat(Time.time * 0.15f, 1f), 1f, 1f);
			}
			return Plugin.RuneColor;
		}

		private static void CollectColorTargets(Entry entry, GameObject clone)
		{
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Expected O, but got Unknown
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f9: Expected O, but got Unknown
			entry.Effects.Clear();
			entry.Lights.Clear();
			bool flag = default(bool);
			try
			{
				Il2CppArrayBase<VisualEffect> componentsInChildren = clone.GetComponentsInChildren<VisualEffect>(true);
				if (componentsInChildren != null)
				{
					foreach (VisualEffect item in componentsInChildren)
					{
						if ((Object)(object)item != (Object)null)
						{
							entry.Effects.Add(item);
						}
					}
				}
			}
			catch (Exception ex)
			{
				ManualLogSource log = Plugin.Log;
				BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(38, 1, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("[Portals][visual] vfx collect failed: ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(ex.Message);
				}
				log.LogWarning(val);
			}
			try
			{
				Il2CppArrayBase<Light> componentsInChildren2 = clone.GetComponentsInChildren<Light>(true);
				if (componentsInChildren2 == null)
				{
					return;
				}
				foreach (Light item2 in componentsInChildren2)
				{
					if ((Object)(object)item2 != (Object)null)
					{
						entry.Lights.Add(item2);
					}
				}
			}
			catch (Exception ex2)
			{
				ManualLogSource log2 = Plugin.Log;
				BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(40, 1, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("[Portals][visual] light collect failed: ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(ex2.Message);
				}
				log2.LogWarning(val);
			}
		}

		private static void ApplyColor(Entry entry, Color color)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			Vector4 val = default(Vector4);
			((Vector4)(ref val))..ctor(color.r, color.g, color.b, color.a);
			for (int i = 0; i < entry.Effects.Count; i++)
			{
				VisualEffect val2 = entry.Effects[i];
				if ((Object)(object)val2 == (Object)null)
				{
					continue;
				}
				try
				{
					if (val2.HasVector4("Color"))
					{
						val2.SetVector4("Color", val);
					}
				}
				catch
				{
				}
			}
			for (int j = 0; j < entry.Lights.Count; j++)
			{
				Light val3 = entry.Lights[j];
				if (!((Object)(object)val3 == (Object)null))
				{
					try
					{
						val3.color = color;
					}
					catch
					{
					}
				}
			}
		}

		internal static void Tick()
		{
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: 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_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: 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)
			if (_entries.Count == 0)
			{
				return;
			}
			if (!Plugin.RuneRainbow)
			{
				Color runeColor = Plugin.RuneColor;
				if (runeColor == _fixedApplied)
				{
					return;
				}
				_fixedApplied = runeColor;
				{
					foreach (Entry value in _entries.Values)
					{
						ApplyColor(value, runeColor);
					}
					return;
				}
			}
			Color color = CurrentColor();
			foreach (Entry value2 in _entries.Values)
			{
				ApplyColor(value2, color);
			}
		}

		private static GameObject RuneTemplate()
		{
			//IL_00f5: 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_017c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0183: Expected O, but got Unknown
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: Expected O, but got Unknown
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_runeTemplate != (Object)null)
			{
				return _runeTemplate;
			}
			if (Time.time < _nextRuneSearch)
			{
				return null;
			}
			_nextRuneSearch = Time.time + 10f;
			bool flag = default(bool);
			try
			{
				Il2CppArrayBase<Structure> val = Resources.FindObjectsOfTypeAll<Structure>();
				if (val == null)
				{
					return null;
				}
				foreach (Structure item in val)
				{
					if ((Object)(object)item == (Object)null)
					{
						continue;
					}
					string name;
					try
					{
						name = ((Object)((Component)item).gameObject).name;
					}
					catch
					{
						continue;
					}
					if (name == null || name.IndexOf("Runestone", StringComparison.OrdinalIgnoreCase) < 0 || name.IndexOf("(Clone)", StringComparison.Ordinal) >= 0)
					{
						continue;
					}
					Transform val2;
					try
					{
						val2 = ((Component)item).transform.Find("FX/VFXRunestone");
					}
					catch
					{
						val2 = null;
					}
					if (!((Object)(object)val2 == (Object)null))
					{
						GameObject obj3 = Object.Instantiate<GameObject>(((Component)val2).gameObject);
						obj3.SetActive(false);
						Object.DontDestroyOnLoad((Object)(object)obj3);
						_runeTemplate = obj3;
						try
						{
							_runeTemplateScale = val2.localScale;
						}
						catch
						{
							_runeTemplateScale = Vector3.one;
						}
						ManualLogSource log = Plugin.Log;
						BepInExInfoLogInterpolatedStringHandler val3 = new BepInExInfoLogInterpolatedStringHandler(48, 1, ref flag);
						if (flag)
						{
							((BepInExLogInterpolatedStringHandler)val3).AppendLiteral("[Portals][visual] rune template captured from '");
							((BepInExLogInterpolatedStringHandler)val3).AppendFormatted<string>(name);
							((BepInExLogInterpolatedStringHandler)val3).AppendLiteral("'");
						}
						log.LogInfo(val3);
						return _runeTemplate;
					}
				}
				Plugin.Log.LogInfo((object)"[Portals][visual] no resident runestone template found yet");
				return null;
			}
			catch (Exception ex)
			{
				ManualLogSource log2 = Plugin.Log;
				BepInExWarningLogInterpolatedStringHandler val4 = new BepInExWarningLogInterpolatedStringHandler(47, 1, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val4).AppendLiteral("[Portals][visual] rune template search failed: ");
					((BepInExLogInterpolatedStringHandler)val4).AppendFormatted<string>(ex.Message);
				}
				log2.LogWarning(val4);
				return null;
			}
		}

		private static void RemoveEntry(PortalRecord record, Entry entry)
		{
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Expected O, but got Unknown
			_entries.Remove(record);
			try
			{
				if ((Object)(object)entry.RuneFx != (Object)null)
				{
					Object.Destroy((Object)(object)entry.RuneFx);
				}
			}
			catch (Exception ex)
			{
				ManualLogSource log = Plugin.Log;
				bool flag = default(bool);
				BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(42, 1, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("[Portals][visual] rune fx destroy failed: ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(ex.Message);
				}
				log.LogWarning(val);
			}
			entry.RuneFx = null;
			entry.Effects.Clear();
			entry.Lights.Clear();
			entry.Arch = null;
		}
	}
	internal static class SessionIdentity
	{
		internal static bool TryGetSessionId(out string id)
		{
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Expected O, but got Unknown
			id = null;
			try
			{
				StorageManager val = Object.FindObjectOfType<StorageManager>();
				if ((Object)(object)val == (Object)null)
				{
					return false;
				}
				string activeSessionID = val.ActiveSessionID;
				if (string.IsNullOrEmpty(activeSessionID))
				{
					return false;
				}
				id = activeSessionID;
				return true;
			}
			catch (Exception ex)
			{
				ManualLogSource log = Plugin.Log;
				bool flag = default(bool);
				BepInExWarningLogInterpolatedStringHandler val2 = new BepInExWarningLogInterpolatedStringHandler(41, 1, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val2).AppendLiteral("[Portals][store] session id read failed: ");
					((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<string>(ex.Message);
				}
				log.LogWarning(val2);
				return false;
			}
		}
	}
	public class TeleportEngine : MonoBehaviour
	{
		private enum State
		{
			IDLE,
			ARRIVING,
			SETTLING
		}

		public static float SuppressDamageUntil = -999f;

		private const float SafeHighLift = 20f;

		private const float ArriveTimeout = 1.5f;

		private const float Cooldown = 0.5f;

		private Character _character;

		private PlayerDrive _playerDrive;

		private PlayerSurvival _survival;

		private float _capsuleRadius = 0.441f;

		private float _capsuleHeight = 1.913f;

		private State _state;

		private float _lastCycleTime = -999f;

		private float _faceHoldUntil = -999f;

		private float _arriveStart;

		private float _destX;

		private float _destZ;

		private float _fallbackY;

		private Vector3 _facing;

		private Transform _cameraPivot;

		public bool IsIdle => _state == State.IDLE;

		public float CooldownRemaining => Mathf.Max(0f, 0.5f - (Time.time - _lastCycleTime));

		private void Start()
		{
			_character = ((Component)this).GetComponentInParent<Character>();
			if ((Object)(object)_character == (Object)null)
			{
				Plugin.Log.LogWarning((object)"TeleportEngine: Character not resolved in Start; will retry each frame.");
			}
			CacheCapsuleDims();
		}

		private void Update()
		{
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Expected O, but got Unknown
			try
			{
				if ((Object)(object)_character == (Object)null)
				{
					_character = ((Component)this).GetComponentInParent<Character>();
					if ((Object)(object)_character == (Object)null)
					{
						return;
					}
					CacheCapsuleDims();
				}
				switch (_state)
				{
				case State.ARRIVING:
					UpdateArriving();
					break;
				case State.SETTLING:
					UpdateSettling();
					break;
				}
				if (Time.time < _faceHoldUntil)
				{
					ApplyFacing();
				}
			}
			catch (Exception ex)
			{
				ManualLogSource log = Plugin.Log;
				bool flag = default(bool);
				BepInExErrorLogInterpolatedStringHandler val = new BepInExErrorLogInterpolatedStringHandler(26, 1, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("Teleportation flow error: ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<Exception>(ex);
				}
				log.LogError(val);
				_state = State.IDLE;
				_lastCycleTime = Time.time;
			}
		}

		public bool Request(Vector3 destination)
		{
			//IL_0001: 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)
			return Request(destination, Vector3.zero);
		}

		public bool Request(Vector3 destination, Vector3 facing)
		{
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_011a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0120: Expected O, but got Unknown
			if (_state != State.IDLE)
			{
				return false;
			}
			if (Time.time - _lastCycleTime < 0.5f)
			{
				return false;
			}
			if ((Object)(object)_character == (Object)null)
			{
				_character = ((Component)this).GetComponentInParent<Character>();
				if ((Object)(object)_character == (Object)null)
				{
					return false;
				}
				CacheCapsuleDims();
			}
			_playerDrive = ResolvePlayerDrive();
			if ((Object)(object)_playerDrive == (Object)null)
			{
				Plugin.Log.LogWarning((object)"Teleport aborted: PlayerDrive not resolved.");
				return false;
			}
			_destX = destination.x;
			_destZ = destination.z;
			_fallbackY = destination.y;
			_facing = facing;
			_playerDrive.Teleport(new Vector3(_destX, ((Component)_character).transform.position.y + 20f, _destZ));
			SuppressDamageUntil = Time.time + 3.5f;
			PreventHardLand(6f);
			_state = State.ARRIVING;
			_arriveStart = Time.time;
			if (Plugin.DebugLogging)
			{
				ManualLogSource log = Plugin.Log;
				bool flag = default(bool);
				BepInExInfoLogInterpolatedStringHandler val = new BepInExInfoLogInterpolatedStringHandler(42, 3, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("[Portals][engine] request destination=(");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<float>(_destX, "F1");
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral(",");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<float>(_fallbackY, "F1");
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral(",");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<float>(_destZ, "F1");
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral(")");
				}
				log.LogInfo(val);
			}
			return true;
		}

		private void UpdateArriving()
		{
			if (TerrainHitAt(_destX, _destZ) || Time.time - _arriveStart >= 1.5f)
			{
				_state = State.SETTLING;
			}
		}

		private void UpdateSettling()
		{
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Expected O, but got Unknown
			//IL_0103: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: Expected O, but got Unknown
			float groundY;
			string source;
			bool num = SampleGroundY(_destX, _destZ, _fallbackY, out groundY, out source);
			float destX = _destX;
			float destZ = _destZ;
			float num2 = groundY + Plugin.SafeDropHeight;
			bool flag = default(bool);
			if (!num)
			{
				ManualLogSource log = Plugin.Log;
				BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(69, 3, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("Teleport: no ground under destination (");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<float>(destX, "F1");
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral(",");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<float>(destZ, "F1");
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral(") - best-effort drop from y=");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<float>(num2, "F1");
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral(".");
				}
				log.LogWarning(val);
			}
			SuppressDamageUntil = Time.time + 1.5f;
			PreventHardLand(6f);
			_playerDrive.Teleport(new Vector3(destX, num2, destZ));
			ApplyFacing();
			_faceHoldUntil = Time.time + 0.4f;
			if (Plugin.DebugLogging)
			{
				ManualLogSource log2 = Plugin.Log;
				BepInExInfoLogInterpolatedStringHandler val2 = new BepInExInfoLogInterpolatedStringHandler(42, 4, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val2).AppendLiteral("[Portals][engine] settled at (");
					((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<float>(destX, "F1");
					((BepInExLogInterpolatedStringHandler)val2).AppendLiteral(",");
					((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<float>(groundY, "F1");
					((BepInExLogInterpolatedStringHandler)val2).AppendLiteral(",");
					((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<float>(destZ, "F1");
					((BepInExLogInterpolatedStringHandler)val2).AppendLiteral(") ground=");
					((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<string>(source);
					((BepInExLogInterpolatedStringHandler)val2).AppendLiteral(".");
				}
				log2.LogInfo(val2);
			}
			_lastCycleTime = Time.time;
			_state = State.IDLE;
		}

		private void ApplyFacing()
		{
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Expected O, but got Unknown
			//IL_010f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0115: Expected O, but got Unknown
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: 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)
			if (((Vector3)(ref _facing)).sqrMagnitude < 0.0001f)
			{
				return;
			}
			Vector3 val = default(Vector3);
			((Vector3)(ref val))..ctor(_facing.x, 0f, _facing.z);
			if (((Vector3)(ref val)).sqrMagnitude < 0.0001f)
			{
				return;
			}
			Quaternion rotation = Quaternion.LookRotation(((Vector3)(ref val)).normalized, Vector3.up);
			bool flag = default(bool);
			try
			{
				if ((Object)(object)_character != (Object)null)
				{
					((Component)_character).transform.rotation = rotation;
				}
			}
			catch (Exception ex)
			{
				ManualLogSource log = Plugin.Log;
				BepInExWarningLogInterpolatedStringHandler val2 = new BepInExWarningLogInterpolatedStringHandler(42, 1, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val2).AppendLiteral("[Portals][engine] body facing set failed: ");
					((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<string>(ex.Message);
				}
				log.LogWarning(val2);
			}
			try
			{
				if ((Object)(object)_cameraPivot == (Object)null)
				{
					_cameraPivot = ResolveCameraPivot();
				}
				if ((Object)(object)_cameraPivot != (Object)null)
				{
					Vector3 eulerAngles = _cameraPivot.eulerAngles;
					eulerAngles.y = ((Quaternion)(ref rotation)).eulerAngles.y;
					_cameraPivot.eulerAngles = eulerAngles;
				}
			}
			catch (Exception ex2)
			{
				ManualLogSource log2 = Plugin.Log;
				BepInExWarningLogInterpolatedStringHandler val2 = new BepInExWarningLogInterpolatedStringHandler(44, 1, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val2).AppendLiteral("[Portals][engine] camera facing set failed: ");
					((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<string>(ex2.Message);
				}
				log2.LogWarning(val2);
			}
		}

		private Transform ResolveCameraPivot()
		{
			//IL_0109: Unknown result type (might be due to invalid IL or missing references)
			//IL_0110: Expected O, but got Unknown
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Expected O, but got Unknown
			bool flag = default(bool);
			try
			{
				Il2CppArrayBase<CinemachineVirtualCamera> val = Resources.FindObjectsOfTypeAll<CinemachineVirtualCamera>();
				if (val == null)
				{
					return null;
				}
				foreach (CinemachineVirtualCamera item in val)
				{
					if ((Object)(object)item == (Object)null)
					{
						continue;
					}
					GameObject gameObject;
					try
					{
						gameObject = ((Component)item).gameObject;
					}
					catch
					{
						continue;
					}
					if ((Object)(object)gameObject == (Object)null || !gameObject.activeInHierarchy)
					{
						continue;
					}
					string name = ((Object)gameObject).name;
					if (name == null || name.IndexOf("TPFCamera", StringComparison.OrdinalIgnoreCase) < 0)
					{
						continue;
					}
					Transform follow = ((CinemachineVirtualCameraBase)item).Follow;
					if ((Object)(object)follow != (Object)null)
					{
						ManualLogSource log = Plugin.Log;
						BepInExInfoLogInterpolatedStringHandler val2 = new BepInExInfoLogInterpolatedStringHandler(46, 2, ref flag);
						if (flag)
						{
							((BepInExLogInterpolatedStringHandler)val2).AppendLiteral("[Portals][engine] camera pivot '");
							((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<string>(((Object)follow).name);
							((BepInExLogInterpolatedStringHandler)val2).AppendLiteral("' from vcam '");
							((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<string>(name);
							((BepInExLogInterpolatedStringHandler)val2).AppendLiteral("'");
						}
						log.LogInfo(val2);
						return follow;
					}
				}
			}
			catch (Exception ex)
			{
				ManualLogSource log2 = Plugin.Log;
				BepInExWarningLogInterpolatedStringHandler val3 = new BepInExWarningLogInterpolatedStringHandler(47, 1, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val3).AppendLiteral("[Portals][engine] camera pivot resolve failed: ");
					((BepInExLogInterpolatedStringHandler)val3).AppendFormatted<string>(ex.Message);
				}
				log2.LogWarning(val3);
			}
			return null;
		}

		private PlayerDrive ResolvePlayerDrive()
		{
			PlayerCharacter val = ((Il2CppObjectBase)_character).TryCast<PlayerCharacter>();
			if ((Object)(object)val != (Object)null && (Object)(object)val._pd != (Object)null)
			{
				return val._pd;
			}
			return ((Component)this).GetComponentInParent<PlayerDrive>();
		}

		private bool TerrainHitAt(float x, float z)
		{
			//IL_000c: 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_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			Il2CppStructArray<RaycastHit> val = Physics.RaycastAll(new Vector3(x, ((Component)_character).transform.position.y + 300f, z), Vector3.down, 1000f);
			if (val == null)
			{
				return false;
			}
			foreach (RaycastHit item in (Il2CppArrayBase<RaycastHit>)(object)val)
			{
				RaycastHit current = item;
				if (!((Object)(object)((RaycastHit)(ref current)).collider == (Object)null) && (Object)(object)((Component)((RaycastHit)(ref current)).collider).GetComponent<Terrain>() != (Object)null)
				{
					return true;
				}
			}
			return false;
		}

		private bool SampleGroundY(float x, float z, float fallbackY, out float groundY, out string source)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: 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_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			groundY = fallbackY;
			source = "void";
			Il2CppStructArray<RaycastHit> val = Physics.RaycastAll(new Vector3(x, ((Component)_character).transform.position.y + 300f, z), Vector3.down, 1000f);
			if (val == null || ((Il2CppArrayBase<RaycastHit>)(object)val).Length == 0)
			{
				return false;
			}
			bool flag = false;
			float num = 0f;
			bool flag2 = false;
			float num2 = 0f;
			foreach (RaycastHit item in (Il2CppArrayBase<RaycastHit>)(object)val)
			{
				RaycastHit current = item;
				Collider collider = ((RaycastHit)(ref current)).collider;
				if ((Object)(object)collider == (Object)null || (Object)(object)((Component)collider).GetComponentInParent<Character>() == (Object)(object)_character || collider.isTrigger)
				{
					continue;
				}
				float y = ((RaycastHit)(ref current)).point.y;
				if ((Object)(object)((Component)collider).GetComponent<Terrain>() != (Object)null)
				{
					if (!flag || y > num)
					{
						flag = true;
						num = y;
					}
				}
				else if (!((Object)(object)((Component)collider).GetComponentInParent<Structure>() == (Object)null) && (!flag2 || y > num2))
				{
					flag2 = true;
					num2 = y;
				}
			}
			if (flag2 && (!flag || num2 >= num))
			{
				groundY = num2;
				source = "floor";
				return true;
			}
			if (flag)
			{
				groundY = num;
				source = "terrain";
				return true;
			}
			if (flag2)
			{
				groundY = num2;
				source = "floor";
				return true;
			}
			return false;
		}

		private void CacheCapsuleDims()
		{
			if (!((Object)(object)_character == (Object)null))
			{
				CapsuleCollider componentInChildren = ((Component)_character).GetComponentInChildren<CapsuleCollider>();
				if ((Object)(object)componentInChildren != (Object)null)
				{
					_capsuleRadius = componentInChildren.radius;
					_capsuleHeight = componentInChildren.height;
				}
				_survival = ((Component)_character).GetComponentInChildren<PlayerSurvival>();
			}
		}

		private void PreventHardLand(float seconds)
		{
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Expected O, but got Unknown
			try
			{
				if ((Object)(object)_survival == (Object)null)
				{
					_survival = ((Component)_character).GetComponentInChildren<PlayerSurvival>();
				}
				if ((Object)(object)_survival != (Object)null)
				{
					_survival.PreventHardLandForSeconds(seconds);
				}
				else
				{
					Plugin.Log.LogWarning((object)"Teleport: PlayerSurvival not resolved; skipping hard-land prevention.");
				}
			}
			catch (Exception ex)
			{
				ManualLogSource log = Plugin.Log;
				bool flag = default(bool);
				BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(44, 1, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("Teleport: PreventHardLandForSeconds failed: ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(ex.Message);
				}
				log.LogWarning(val);
			}
		}
	}
	public static class MyPluginInfo
	{
		public const string PLUGIN_GUID = "Bifrost";

		public const string PLUGIN_NAME = "Bifrost";

		public const string PLUGIN_VERSION = "0.2.0";
	}
}
namespace AskaShared.Game
{
	public static class LocalPlayerTool
	{
		private static bool _failureLogged;

		public static Character LocalCharacter { get; private set; }

		public static GameObject AttachOnSpawn(Character character, ManualLogSource log, string objectName, Vector3 localPosition, params Type[] components)
		{
			//IL_0130: Unknown result type (might be due to invalid IL or missing references)
			//IL_0137: Expected O, but got Unknown
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Expected O, but got Unknown
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Expected O, but got Unknown
			bool flag = default(bool);
			try
			{
				if ((Object)(object)character == (Object)null)
				{
					return null;
				}
				if (!character.IsPlayer() || ((NetworkBehaviour)character).GetLocalAuthorityMask() != 1)
				{
					return null;
				}
				LocalCharacter = character;
				if (string.IsNullOrEmpty(objectName))
				{
					throw new ArgumentException("objectName is required and must be unique to this mod.", "objectName");
				}
				Transform transform = ((Component)character).gameObject.transform;
				if ((Object)(object)transform.Find(objectName) != (Object)null)
				{
					return null;
				}
				GameObject val = new GameObject(objectName);
				val.transform.SetParent(transform, false);
				val.transform.localPosition = localPosition;
				if (components != null)
				{
					foreach (Type type in components)
					{
						if (type != null)
						{
							val.AddComponent(Il2CppType.From(type));
						}
					}
				}
				ManualLogSource val2 = log;
				if (val2 != null)
				{
					BepInExInfoLogInterpolatedStringHandler val3 = new BepInExInfoLogInterpolatedStringHandler(29, 2, ref flag);
					if (flag)
					{
						((BepInExLogInterpolatedStringHandler)val3).AppendFormatted<string>(objectName);
						((BepInExLogInterpolatedStringHandler)val3).AppendLiteral(" attached to local player '");
						((BepInExLogInterpolatedStringHandler)val3).AppendFormatted<string>(((Object)((Component)character).gameObject).name);
						((BepInExLogInterpolatedStringHandler)val3).AppendLiteral("'.");
					}
					val2.LogInfo(val3);
				}
				return val;
			}
			catch (Exception ex)
			{
				if (!_failureLogged)
				{
					_failureLogged = true;
					ManualLogSource val2 = log;
					if (val2 != null)
					{
						BepInExErrorLogInterpolatedStringHandler val4 = new BepInExErrorLogInterpolatedStringHandler(121, 2, ref flag);
						if (flag)
						{
							((BepInExLogInterpolatedStringHandler)val4).AppendFormatted<string>(objectName);
							((BepInExLogInterpolatedStringHandler)val4).AppendLiteral(": attaching to the local player threw - this mod will do nothing this session, reported once rather than once per spawn: ");
							((BepInExLogInterpolatedStringHandler)val4).AppendFormatted<Exception>(ex);
						}
						val2.LogError(val4);
					}
				}
				return null;
			}
		}
	}
}