using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Configuration;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using TMPro;
using UnityEngine;
using UnityEngine.EventSystems;
using UnityEngine.Events;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: AssemblyCompany("FraileyPortalSelector")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("0.4.7.0")]
[assembly: AssemblyInformationalVersion("0.4.7+d00154020f09ce26374950d6b5ed9ba8f39b3265")]
[assembly: AssemblyProduct("BetterPortals")]
[assembly: AssemblyTitle("FraileyPortalSelector")]
[assembly: AssemblyVersion("0.4.7.0")]
[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 FraileyPortalSelector
{
	[BepInPlugin("com.fraileywoodworks.portalselector", "BetterPortals", "0.4.7")]
	public sealed class Plugin : BaseUnityPlugin
	{
		public const string Guid = "com.fraileywoodworks.portalselector";

		public const string Name = "BetterPortals";

		public const string Version = "0.4.7";

		internal const int MaxNameLength = 32;

		internal static Plugin Instance;

		internal static readonly Harmony Harmony = new Harmony("com.fraileywoodworks.portalselector");

		private void Awake()
		{
			Instance = this;
			Harmony.PatchAll();
			if (!Application.isBatchMode)
			{
				PortalVisualSettings.Bind(((BaseUnityPlugin)this).Config);
				((Component)this).gameObject.AddComponent<PortalController>();
			}
			((BaseUnityPlugin)this).Logger.LogInfo((object)string.Format("{0} {1} loaded; portal names capped at {2} characters", "BetterPortals", "0.4.7", 32));
		}

		private void OnDestroy()
		{
			Harmony.UnpatchSelf();
		}

		internal static void LogDebug(string message)
		{
			Plugin instance = Instance;
			if (instance != null)
			{
				((BaseUnityPlugin)instance).Logger.LogDebug((object)message);
			}
		}
	}
	internal static class PortalVisualSettings
	{
		internal const float DefaultTitleFontSize = 40f;

		internal const float DefaultEntryFontSize = 31f;

		internal const float DefaultHintFontSize = 17f;

		internal const float DefaultBiomeFontSize = 9.3f;

		internal const float DefaultHomeIconSize = 13.2f;

		internal const float DefaultOutlineWidth = 0f;

		internal const float DefaultHoverScale = 1.1f;

		internal const float DefaultHoverExpandSeconds = 0.08f;

		internal const float DefaultHoverContractSeconds = 0.1f;

		internal const float DefaultPanelWidth = 620f;

		internal const float DefaultPanelYOffset = 0f;

		internal const float DefaultRowHeight = 46f;

		internal const float DefaultRowSpacing = 2f;

		internal const float DefaultMaxListHeight = 414f;

		internal const float DefaultBackdropOpacity = 1f;

		internal const float DefaultFadeInSeconds = 0.06f;

		internal const float DefaultFadeOutSeconds = 0.05f;

		internal const float DefaultTriggerMultiplier = 1.5625f;

		internal const float DefaultRowKnotGap = 18f;

		private const string DefaultTitleColor = "#FF8F00FF";

		private const string DefaultEntryColor = "#FFFFFFFF";

		private const string DefaultHintColor = "#B8B8B3FF";

		private const string DefaultBiomeColor = "#FFFFFFFF";

		private const string DefaultOutlineColor = "#000000D9";

		private const string DefaultOrnamentColor = "#FF8F00FF";

		private static ConfigEntry<float> titleFontSize;

		private static ConfigEntry<float> entryFontSize;

		private static ConfigEntry<float> hintFontSize;

		private static ConfigEntry<float> biomeFontSize;

		private static ConfigEntry<float> homeIconSize;

		private static ConfigEntry<string> titleColor;

		private static ConfigEntry<string> entryColor;

		private static ConfigEntry<string> hintColor;

		private static ConfigEntry<string> biomeColor;

		private static ConfigEntry<string> outlineColor;

		private static ConfigEntry<float> outlineWidth;

		private static ConfigEntry<float> hoverScale;

		private static ConfigEntry<float> hoverExpandSeconds;

		private static ConfigEntry<float> hoverContractSeconds;

		private static ConfigEntry<float> panelWidth;

		private static ConfigEntry<float> panelYOffset;

		private static ConfigEntry<float> rowHeight;

		private static ConfigEntry<float> rowSpacing;

		private static ConfigEntry<float> maxListHeight;

		private static ConfigEntry<float> backdropOpacity;

		private static ConfigEntry<string> ornamentColor;

		private static ConfigEntry<bool> showMenuOrnament;

		private static ConfigEntry<bool> showRowKnots;

		private static ConfigEntry<float> rowKnotGap;

		private static ConfigEntry<float> fadeInSeconds;

		private static ConfigEntry<float> fadeOutSeconds;

		private static ConfigEntry<float> triggerMultiplier;

		private static ConfigEntry<bool> showBiomeSubtitle;

		private static ConfigEntry<bool> preferHomeOnOpen;

		private static ConfigEntry<bool> showControlHints;

		private static ConfigEntry<KeyboardShortcut> setHomeKeyboardShortcut;

		internal static float TitleFontSize => Clamp(titleFontSize, 40f, 12f, 96f);

		internal static float EntryFontSize => Clamp(entryFontSize, 31f, 12f, 72f);

		internal static float HintFontSize => Clamp(hintFontSize, 17f, 8f, 48f);

		internal static float BiomeFontSize => Clamp(biomeFontSize, 9.3f, 8f, 48f);

		internal static float HomeIconSize => Clamp(homeIconSize, 13.2f, 12f, 36f);

		internal static Color TitleColor => ParseColor(titleColor, "#FF8F00FF");

		internal static Color EntryColor => ParseColor(entryColor, "#FFFFFFFF");

		internal static Color HintColor => ParseColor(hintColor, "#B8B8B3FF");

		internal static Color BiomeColor => ParseColor(biomeColor, "#FFFFFFFF");

		internal static Color OutlineColor => ParseColor(outlineColor, "#000000D9");

		internal static float OutlineWidth => Clamp(outlineWidth, 0f, 0f, 1f);

		internal static float HoverScale => Clamp(hoverScale, 1.1f, 1f, 1.5f);

		internal static float HoverExpandSeconds => Clamp(hoverExpandSeconds, 0.08f, 0.01f, 1f);

		internal static float HoverContractSeconds => Clamp(hoverContractSeconds, 0.1f, 0.01f, 1f);

		internal static float PanelWidth => Clamp(panelWidth, 620f, 320f, 1400f);

		internal static float PanelYOffset => Clamp(panelYOffset, 0f, -500f, 500f);

		internal static float RowHeight => Clamp(rowHeight, 46f, 28f, 96f);

		internal static float RowSpacing => Clamp(rowSpacing, 2f, 0f, 24f);

		internal static float MaxListHeight => Clamp(maxListHeight, 414f, 80f, 900f);

		internal static float BackdropOpacity => Clamp(backdropOpacity, 1f, 0f, 1f);

		internal static Color OrnamentColor => ParseColor(ornamentColor, "#FF8F00FF");

		internal static bool ShowMenuOrnament => showMenuOrnament?.Value ?? true;

		internal static bool ShowRowKnots => showRowKnots?.Value ?? true;

		internal static float RowKnotGap => Clamp(rowKnotGap, 18f, 0f, 100f);

		internal static float FadeInSeconds => Clamp(fadeInSeconds, 0.06f, 0.01f, 1f);

		internal static float FadeOutSeconds => Clamp(fadeOutSeconds, 0.05f, 0.01f, 1f);

		internal static float TriggerMultiplier => Clamp(triggerMultiplier, 1.5625f, 1f, 2f);

		internal static bool ShowBiomeSubtitle => showBiomeSubtitle?.Value ?? true;

		internal static bool PreferHomeOnOpen => preferHomeOnOpen?.Value ?? true;

		internal static bool ShowControlHints => showControlHints?.Value ?? true;

		internal static KeyboardShortcut SetHomeKeyboardShortcut => (KeyboardShortcut)(((??)setHomeKeyboardShortcut?.Value) ?? new KeyboardShortcut((KeyCode)104, Array.Empty<KeyCode>()));

		internal static void Bind(ConfigFile config)
		{
			//IL_045e: Unknown result type (might be due to invalid IL or missing references)
			titleFontSize = BindRange(config, "Visual - Typography", "Title Font Size", 40f, 12f, 96f, "Portal selector heading size.");
			entryFontSize = BindRange(config, "Visual - Typography", "Entry Font Size", 31f, 12f, 72f, "Destination row text size.");
			hintFontSize = BindRange(config, "Visual - Typography", "Hint Font Size", 17f, 8f, 48f, "Size of the close-instruction text below the heading.");
			biomeFontSize = BindRange(config, "Visual - Typography", "Biome Font Size", 9.3f, 8f, 48f, "Size of the optional biome subtitle beneath each portal name.");
			homeIconSize = BindRange(config, "Visual - Typography", "Home Icon Size", 13.2f, 12f, 36f, "Size of Valheim's native favorite-star icon beside the selected Home portal.");
			titleColor = BindColor(config, "Visual - Typography", "Title Color", "#FF8F00FF", "Heading color as #RRGGBB or #RRGGBBAA.");
			entryColor = BindColor(config, "Visual - Typography", "Entry Color", "#FFFFFFFF", "Destination text color as #RRGGBB or #RRGGBBAA.");
			hintColor = BindColor(config, "Visual - Typography", "Hint Color", "#B8B8B3FF", "Instruction text color as #RRGGBB or #RRGGBBAA.");
			biomeColor = BindColor(config, "Visual - Typography", "Biome Color", "#FFFFFFFF", "Biome subtitle color as #RRGGBB or #RRGGBBAA.");
			outlineColor = BindColor(config, "Visual - Typography", "Font Outline Color", "#000000D9", "Text outline color as #RRGGBB or #RRGGBBAA.");
			outlineWidth = BindRange(config, "Visual - Typography", "Font Outline Width", 0f, 0f, 1f, "TextMesh Pro outline width for all selector text.");
			hoverScale = BindRange(config, "Visual - Hover", "Hover Scale", 1.1f, 1f, 1.5f, "Scale of the selected or hovered destination label.");
			hoverExpandSeconds = BindRange(config, "Visual - Hover", "Hover Expand Duration", 0.08f, 0.01f, 1f, "Seconds used for the eased hover expansion.");
			hoverContractSeconds = BindRange(config, "Visual - Hover", "Hover Contract Duration", 0.1f, 0.01f, 1f, "Seconds used for the eased hover contraction.");
			panelWidth = BindRange(config, "Visual - Layout", "Panel Width", 620f, 320f, 1400f, "Width of the centered portal selector in native UI units.");
			panelYOffset = BindRange(config, "Visual - Layout", "Panel Y Offset", 0f, -500f, 500f, "Vertical offset from screen center in native UI units.");
			rowHeight = BindRange(config, "Visual - Layout", "Row Height", 46f, 28f, 96f, "Height of each destination row.");
			rowSpacing = BindRange(config, "Visual - Layout", "Row Spacing", 2f, 0f, 24f, "Vertical spacing between destination rows.");
			maxListHeight = BindRange(config, "Visual - Layout", "Maximum List Height", 414f, 80f, 900f, "Maximum visible destination-list height before scrolling.");
			backdropOpacity = BindRange(config, "Visual - Layout", "Dark Backdrop Opacity", 1f, 0f, 1f, "Opacity multiplier for Valheim's native dark backdrop; 1 preserves the v20 appearance.");
			ornamentColor = BindColor(config, "Visual - Ornaments", "Ornament and Knot Color", "#FF8F00FF", "Menu ornament and row-knot color as #RRGGBB or #RRGGBBAA.");
			showMenuOrnament = config.Bind<bool>("Visual - Ornaments", "Show Menu Ornament", true, "Show Valheim's native menu ornament behind the selector.");
			showRowKnots = config.Bind<bool>("Visual - Ornaments", "Show Row Knots", true, "Show the native knot marks beside a hovered or controller-selected destination.");
			rowKnotGap = BindRange(config, "Visual - Ornaments", "Row Knot Gap", 18f, 0f, 100f, "Horizontal gap between the rendered destination label and each native knot mark.");
			fadeInSeconds = BindRange(config, "Visual - Animation", "Fade In Duration", 0.06f, 0.01f, 1f, "Seconds used for the selector fade-in.");
			fadeOutSeconds = BindRange(config, "Visual - Animation", "Fade Out Duration", 0.05f, 0.01f, 1f, "Seconds used for the selector fade-out.");
			triggerMultiplier = BindRange(config, "Portal Interaction", "Portal Trigger Multiplier", 1.5625f, 1f, 2f, "Client-local trigger and open-menu range multiplier. The server enforces a fixed 9.375-metre safety limit.");
			showBiomeSubtitle = config.Bind<bool>("Portal List", "Show Biome Subtitle", true, "Show the portal's biome in smaller white text beneath its name.");
			preferHomeOnOpen = config.Bind<bool>("Portal List", "Prefer Home On Open", true, "Select and scroll to the Home portal when the list opens.");
			showControlHints = config.Bind<bool>("Portal List", "Show Control Hints", true, "Show short keyboard or controller instructions above the destination list.");
			setHomeKeyboardShortcut = config.Bind<KeyboardShortcut>("Portal List", "Set Home Keyboard Shortcut", new KeyboardShortcut((KeyCode)104, Array.Empty<KeyCode>()), "Keyboard shortcut that sets or clears Home on the selected destination.");
			MigrateLegacyVisualDefaults(config);
			Watch<float>(titleFontSize);
			Watch<float>(entryFontSize);
			Watch<float>(hintFontSize);
			Watch<float>(biomeFontSize);
			Watch<float>(homeIconSize);
			Watch<string>(titleColor);
			Watch<string>(entryColor);
			Watch<string>(hintColor);
			Watch<string>(biomeColor);
			Watch<string>(outlineColor);
			Watch<float>(outlineWidth);
			Watch<float>(hoverScale);
			Watch<float>(hoverExpandSeconds);
			Watch<float>(hoverContractSeconds);
			Watch<float>(panelWidth);
			Watch<float>(panelYOffset);
			Watch<float>(rowHeight);
			Watch<float>(rowSpacing);
			Watch<float>(maxListHeight);
			Watch<float>(backdropOpacity);
			Watch<string>(ornamentColor);
			Watch<bool>(showMenuOrnament);
			Watch<bool>(showRowKnots);
			Watch<float>(rowKnotGap);
			Watch<float>(fadeInSeconds);
			Watch<float>(fadeOutSeconds);
			Watch<float>(triggerMultiplier);
			Watch<bool>(showBiomeSubtitle);
			Watch<bool>(preferHomeOnOpen);
			Watch<bool>(showControlHints);
			Watch<KeyboardShortcut>(setHomeKeyboardShortcut);
		}

		private static void MigrateLegacyVisualDefaults(ConfigFile config)
		{
			bool flag = false;
			if (Mathf.Approximately(biomeFontSize.Value, 15.5f))
			{
				biomeFontSize.Value = 9.3f;
				flag = true;
			}
			if (Mathf.Approximately(homeIconSize.Value, 22f))
			{
				homeIconSize.Value = 13.2f;
				flag = true;
			}
			if (Mathf.Approximately(panelYOffset.Value, 120f))
			{
				panelYOffset.Value = 0f;
				flag = true;
			}
			if (Mathf.Approximately(triggerMultiplier.Value, 1.25f))
			{
				triggerMultiplier.Value = 1.5625f;
				flag = true;
			}
			if (string.Equals(entryColor.Value?.Trim(), "#DBDBDBFF", StringComparison.OrdinalIgnoreCase))
			{
				entryColor.Value = "#FFFFFFFF";
				flag = true;
			}
			if (flag)
			{
				config.Save();
			}
		}

		private static ConfigEntry<float> BindRange(ConfigFile config, string section, string key, float value, float minimum, float maximum, string description)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Expected O, but got Unknown
			return config.Bind<float>(section, key, value, new ConfigDescription(description, (AcceptableValueBase)(object)new AcceptableValueRange<float>(minimum, maximum), Array.Empty<object>()));
		}

		private static ConfigEntry<string> BindColor(ConfigFile config, string section, string key, string value, string description)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Expected O, but got Unknown
			return config.Bind<string>(section, key, value, new ConfigDescription(description, (AcceptableValueBase)null, Array.Empty<object>()));
		}

		private static void Watch<T>(ConfigEntry<T> entry)
		{
			entry.SettingChanged += OnSettingChanged;
		}

		private static void OnSettingChanged(object sender, EventArgs args)
		{
			PortalController.Instance?.MarkVisualsDirty();
		}

		private static float Clamp(ConfigEntry<float> entry, float fallback, float minimum, float maximum)
		{
			return Mathf.Clamp(entry?.Value ?? fallback, minimum, maximum);
		}

		private static Color ParseColor(ConfigEntry<string> entry, string fallback)
		{
			//IL_004b: 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)
			string text = entry?.Value;
			if (!string.IsNullOrWhiteSpace(text))
			{
				text = text.Trim();
				if (!text.StartsWith("#", StringComparison.Ordinal))
				{
					text = "#" + text;
				}
				Color result = default(Color);
				if (ColorUtility.TryParseHtmlString(text, ref result))
				{
					return result;
				}
			}
			Color result2 = default(Color);
			ColorUtility.TryParseHtmlString(fallback, ref result2);
			return result2;
		}
	}
	internal static class PortalNames
	{
		internal static string Sanitize(string value)
		{
			if (string.IsNullOrEmpty(value))
			{
				return string.Empty;
			}
			string text = new string(value.Where((char c) => c >= ' ' && c != '\u007f').Take(32).ToArray());
			if (text.Length > 0 && char.IsHighSurrogate(text[text.Length - 1]))
			{
				text = text.Substring(0, text.Length - 1);
			}
			return text;
		}
	}
	internal static class PortalHome
	{
		private const string KeyPrefix = "com.fraileywoodworks.portalselector.home.v1.";

		private static string CurrentKey()
		{
			ZNet instance = ZNet.instance;
			if (!((Object)(object)instance == (Object)null))
			{
				return "com.fraileywoodworks.portalselector.home.v1." + instance.GetWorldUID();
			}
			return null;
		}

		internal static bool TryGet(out ZDOID id)
		{
			//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_0084: 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)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			id = ZDOID.None;
			Player localPlayer = Player.m_localPlayer;
			string text = CurrentKey();
			if (!Object.op_Implicit((Object)(object)localPlayer) || string.IsNullOrEmpty(text) || localPlayer.m_customData == null || !localPlayer.m_customData.TryGetValue(text, out var value))
			{
				return false;
			}
			string[] array = value.Split(new char[1] { ':' });
			if (array.Length != 2 || !long.TryParse(array[0], NumberStyles.Integer, CultureInfo.InvariantCulture, out var result) || !uint.TryParse(array[1], NumberStyles.Integer, CultureInfo.InvariantCulture, out var result2))
			{
				return false;
			}
			id = new ZDOID(result, result2);
			return id != ZDOID.None;
		}

		internal static bool Set(ZDOID id)
		{
			//IL_001c: 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)
			Player localPlayer = Player.m_localPlayer;
			string text = CurrentKey();
			if (!Object.op_Implicit((Object)(object)localPlayer) || string.IsNullOrEmpty(text) || id == ZDOID.None)
			{
				return false;
			}
			Player val = localPlayer;
			if (val.m_customData == null)
			{
				val.m_customData = new Dictionary<string, string>();
			}
			localPlayer.m_customData[text] = ((ZDOID)(ref id)).UserID.ToString(CultureInfo.InvariantCulture) + ":" + ((ZDOID)(ref id)).ID.ToString(CultureInfo.InvariantCulture);
			return true;
		}

		internal static bool Clear()
		{
			Player localPlayer = Player.m_localPlayer;
			string text = CurrentKey();
			if (Object.op_Implicit((Object)(object)localPlayer) && !string.IsNullOrEmpty(text) && localPlayer.m_customData != null)
			{
				return localPlayer.m_customData.Remove(text);
			}
			return false;
		}
	}
	internal static class PortalBiomes
	{
		internal static Biome Normalize(int value)
		{
			//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_000e: Unknown result type (might be due to invalid IL or missing references)
			Biome val = (Biome)value;
			if (Rank(val) >= 9)
			{
				return (Biome)0;
			}
			return val;
		}

		internal static int Rank(Biome biome)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Invalid comparison between Unknown and I4
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Invalid comparison between Unknown and I4
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Expected I4, but got Unknown
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Invalid comparison between Unknown and I4
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Invalid comparison between Unknown and I4
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Invalid comparison between Unknown and I4
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Invalid comparison between Unknown and I4
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Invalid comparison between Unknown and I4
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Invalid comparison between Unknown and I4
			if ((int)biome <= 16)
			{
				switch (biome - 1)
				{
				default:
					if ((int)biome != 8)
					{
						if ((int)biome != 16)
						{
							break;
						}
						return 4;
					}
					return 1;
				case 0:
					return 0;
				case 1:
					return 2;
				case 3:
					return 3;
				case 2:
					break;
				}
			}
			else if ((int)biome <= 64)
			{
				if ((int)biome == 32)
				{
					return 6;
				}
				if ((int)biome == 64)
				{
					return 7;
				}
			}
			else
			{
				if ((int)biome == 256)
				{
					return 8;
				}
				if ((int)biome == 512)
				{
					return 5;
				}
			}
			return 9;
		}

		internal static string DisplayName(Biome biome)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Invalid comparison between Unknown and I4
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Invalid comparison between Unknown and I4
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Expected I4, but got Unknown
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Invalid comparison between Unknown and I4
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Invalid comparison between Unknown and I4
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Invalid comparison between Unknown and I4
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Invalid comparison between Unknown and I4
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Invalid comparison between Unknown and I4
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Invalid comparison between Unknown and I4
			if ((int)biome <= 16)
			{
				switch (biome - 1)
				{
				default:
					if ((int)biome != 8)
					{
						if ((int)biome != 16)
						{
							break;
						}
						return "Plains";
					}
					return "Black Forest";
				case 0:
					return "Meadows";
				case 1:
					return "Swamp";
				case 3:
					return "Mountains";
				case 2:
					break;
				}
			}
			else if ((int)biome <= 64)
			{
				if ((int)biome == 32)
				{
					return "Ashlands";
				}
				if ((int)biome == 64)
				{
					return "Deep North";
				}
			}
			else
			{
				if ((int)biome == 256)
				{
					return "Ocean";
				}
				if ((int)biome == 512)
				{
					return "Mistlands";
				}
			}
			return "Other";
		}
	}
	internal static class PortalOrderLedger
	{
		private static readonly Dictionary<ZDOID, long> Orders = new Dictionary<ZDOID, long>();

		private static long loadedWorld;

		private static long nextOrder = 1L;

		private static bool initialized;

		private static bool loadingWorld;

		internal static void BeginWorldLoad()
		{
			loadingWorld = true;
		}

		internal static void EndWorldLoad(ZDOMan manager)
		{
			if (loadingWorld)
			{
				loadingWorld = false;
				if (manager != null)
				{
					Ensure(manager.GetPortalList());
				}
			}
		}

		internal static void PrepareObservation()
		{
			if (!loadingWorld && !initialized && !((Object)(object)ZNet.instance == (Object)null) && ZNet.instance.IsServer())
			{
				ZDOMan instance = ZDOMan.instance;
				IEnumerable<ZDO> enumerable = ((instance != null) ? instance.GetPortalList() : null);
				Ensure(enumerable ?? Enumerable.Empty<ZDO>());
			}
		}

		internal static void Ensure(IEnumerable<ZDO> portals)
		{
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)ZNet.instance == (Object)null || !ZNet.instance.IsServer())
			{
				return;
			}
			LoadCurrentWorld();
			bool flag = false;
			foreach (ZDOID item in from id in (from z in portals
					where z != null && z.IsValid()
					select z.m_uid).Distinct()
				orderby (ulong)((ZDOID)(ref id)).UserID, ((ZDOID)(ref id)).ID
				select id)
			{
				if (!Orders.ContainsKey(item))
				{
					Orders[item] = nextOrder++;
					flag = true;
				}
			}
			initialized = true;
			if (flag)
			{
				Save();
			}
		}

		internal static long Get(ZDOID id)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			if (!Orders.TryGetValue(id, out var value))
			{
				return long.MaxValue;
			}
			return value;
		}

		internal static void Observe(ZDO zdo)
		{
			//IL_0051: 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)
			if (!loadingWorld && initialized && !((Object)(object)ZNet.instance == (Object)null) && ZNet.instance.IsServer() && zdo != null && zdo.IsValid())
			{
				if (ZNet.instance.GetWorldUID() != loadedWorld)
				{
					initialized = false;
				}
				else if (!Orders.ContainsKey(zdo.m_uid))
				{
					Orders[zdo.m_uid] = nextOrder++;
					Save();
				}
			}
		}

		private static void LoadCurrentWorld()
		{
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			long worldUID = ZNet.instance.GetWorldUID();
			if (initialized && loadedWorld == worldUID)
			{
				return;
			}
			loadedWorld = worldUID;
			nextOrder = 1L;
			initialized = false;
			Orders.Clear();
			try
			{
				string path = CurrentPath();
				if (!File.Exists(path))
				{
					return;
				}
				string[] array = File.ReadAllLines(path);
				for (int i = 0; i < array.Length; i++)
				{
					string[] array2 = array[i].Split(new char[1] { '\t' });
					if (array2.Length == 3 && long.TryParse(array2[0], NumberStyles.Integer, CultureInfo.InvariantCulture, out var result) && uint.TryParse(array2[1], NumberStyles.Integer, CultureInfo.InvariantCulture, out var result2) && long.TryParse(array2[2], NumberStyles.Integer, CultureInfo.InvariantCulture, out var result3) && result3 > 0)
					{
						Orders[new ZDOID(result, result2)] = result3;
						nextOrder = Math.Max(nextOrder, result3 + 1);
					}
				}
			}
			catch (Exception ex)
			{
				Plugin.LogDebug("Could not read portal creation-order ledger: " + ex.GetType().Name);
			}
		}

		private static string CurrentPath()
		{
			return Path.Combine(Paths.ConfigPath, $"BetterPortals.portal-order.{loadedWorld}.tsv");
		}

		private static void Save()
		{
			string text = CurrentPath();
			string text2 = text + ".tmp";
			try
			{
				File.WriteAllLines(text2, Orders.OrderBy((KeyValuePair<ZDOID, long> pair) => pair.Value).Select(delegate(KeyValuePair<ZDOID, long> pair)
				{
					//IL_000a: Unknown result type (might be due to invalid IL or missing references)
					//IL_000f: Unknown result type (might be due to invalid IL or missing references)
					//IL_0031: Unknown result type (might be due to invalid IL or missing references)
					//IL_0036: Unknown result type (might be due to invalid IL or missing references)
					string[] array = new string[5];
					ZDOID key = pair.Key;
					array[0] = ((ZDOID)(ref key)).UserID.ToString(CultureInfo.InvariantCulture);
					array[1] = "\t";
					key = pair.Key;
					array[2] = ((ZDOID)(ref key)).ID.ToString(CultureInfo.InvariantCulture);
					array[3] = "\t";
					array[4] = pair.Value.ToString(CultureInfo.InvariantCulture);
					return string.Concat(array);
				}));
				if (File.Exists(text))
				{
					try
					{
						File.Replace(text2, text, null);
						return;
					}
					catch (PlatformNotSupportedException)
					{
						File.Delete(text);
						File.Move(text2, text);
						return;
					}
				}
				File.Move(text2, text);
			}
			catch (Exception ex2)
			{
				Plugin.LogDebug("Could not save portal creation-order ledger: " + ex2.GetType().Name);
			}
			finally
			{
				try
				{
					if (File.Exists(text2))
					{
						File.Delete(text2);
					}
				}
				catch
				{
				}
			}
		}
	}
	[HarmonyPatch(typeof(ZDOMan), "Load")]
	internal static class PortalOrderLoadPatch
	{
		private static void Prefix()
		{
			PortalOrderLedger.BeginWorldLoad();
		}

		private static void Postfix(ZDOMan __instance)
		{
			PortalOrderLedger.EndWorldLoad(__instance);
		}

		private static Exception Finalizer(Exception __exception, ZDOMan __instance)
		{
			PortalOrderLedger.EndWorldLoad(__instance);
			return __exception;
		}
	}
	[HarmonyPatch(typeof(ZDOMan), "AddIfPortal")]
	internal static class PortalOrderObservationPatch
	{
		private static bool IsPortalPrefab(int prefabHash)
		{
			Game instance = Game.instance;
			if (Object.op_Implicit((Object)(object)instance) && instance.PortalPrefabHash != null)
			{
				return instance.PortalPrefabHash.Contains(prefabHash);
			}
			return false;
		}

		private static void Prefix(int __1, out bool __state)
		{
			__state = IsPortalPrefab(__1);
			if (__state)
			{
				PortalOrderLedger.PrepareObservation();
			}
		}

		private static void Postfix(ZDO __0, bool __state)
		{
			if (__state)
			{
				PortalOrderLedger.Observe(__0);
			}
		}
	}
	internal static class PortalRanges
	{
		internal const float MaximumServerDistance = 9.375f;

		internal static float TriggerMultiplier => PortalVisualSettings.TriggerMultiplier;

		internal static float ClientDistance(TeleportWorld portal)
		{
			if (!Object.op_Implicit((Object)(object)portal) || !(portal.m_activationRange > 0f))
			{
				return 9.375f;
			}
			return Mathf.Min(9.375f, portal.m_activationRange * TriggerMultiplier);
		}
	}
	[HarmonyPatch(typeof(TextInput), "RequestText")]
	internal static class PortalNameInputPatch
	{
		private static void Prefix(TextReceiver __0, ref int __2)
		{
			if (__0 is TeleportWorld)
			{
				__2 = 32;
			}
		}
	}
	[HarmonyPatch(typeof(TeleportWorld), "SetText")]
	internal static class PortalNameSendPatch
	{
		private static void Prefix(ref string __0)
		{
			__0 = PortalNames.Sanitize(__0);
		}
	}
	[HarmonyPatch(typeof(TeleportWorld), "RPC_SetTag")]
	internal static class PortalNameReceivePatch
	{
		private static void Prefix(ref string __1)
		{
			__1 = PortalNames.Sanitize(__1);
		}
	}
	[HarmonyPatch(typeof(TeleportWorld), "GetHoverText")]
	internal static class PortalHoverTextPatch
	{
		private static bool Prepare()
		{
			return !Application.isBatchMode;
		}

		private static void Postfix(ref string __result)
		{
			if (!string.IsNullOrEmpty(__result))
			{
				int num = __result.IndexOf('\n');
				string text = ((num >= 0) ? __result.Substring(0, num) : __result);
				int num2 = text.LastIndexOf(" [", StringComparison.Ordinal);
				if (num2 >= 0 && text.EndsWith("]", StringComparison.Ordinal))
				{
					__result = text.Substring(0, num2) + ((num >= 0) ? __result.Substring(num) : string.Empty);
				}
			}
		}
	}
	[HarmonyPatch(typeof(Game), "Start")]
	internal static class RpcRegistrationPatch
	{
		private static void Postfix()
		{
			PortalRpc.Register();
		}
	}
	[HarmonyPatch(typeof(TeleportWorld), "Teleport")]
	internal static class PortalTravelPatch
	{
		private static bool Prepare()
		{
			return !Application.isBatchMode;
		}

		private static bool Prefix(TeleportWorld __instance, Player __0)
		{
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			if (Application.isBatchMode || (Object)(object)__0 != (Object)(object)Player.m_localPlayer || PortalController.BypassOnce)
			{
				return true;
			}
			ZNetView component = ((Component)__instance).GetComponent<ZNetView>();
			if (!Object.op_Implicit((Object)(object)component) || !component.IsValid() || component.GetZDO() == null)
			{
				return true;
			}
			PortalController.Instance.Begin(__instance, component.GetZDO().m_uid);
			return false;
		}
	}
	[HarmonyPatch(typeof(GameCamera), "UpdateMouseCapture")]
	internal static class PortalCursorPatch
	{
		private static bool Prepare()
		{
			return !Application.isBatchMode;
		}

		private static bool Prefix()
		{
			if (Application.isBatchMode || !PortalController.CapturesInput)
			{
				return true;
			}
			if (!PortalController.WantsCursor)
			{
				return true;
			}
			PortalController.ApplySelectorCursor(center: false);
			return false;
		}
	}
	[HarmonyPatch(typeof(Hud), "UpdateCrosshair")]
	internal static class PortalCrosshairPatch
	{
		private static bool Prepare()
		{
			return !Application.isBatchMode;
		}

		private static bool Prefix(Hud __instance)
		{
			if (Application.isBatchMode || !PortalController.CapturesInput)
			{
				return true;
			}
			if (Object.op_Implicit((Object)(object)__instance.m_crosshair))
			{
				((Component)__instance.m_crosshair).gameObject.SetActive(false);
			}
			if (Object.op_Implicit((Object)(object)__instance.m_crosshairBow))
			{
				((Component)__instance.m_crosshairBow).gameObject.SetActive(false);
			}
			if (Object.op_Implicit((Object)(object)__instance.m_hoverName))
			{
				((TMP_Text)__instance.m_hoverName).text = string.Empty;
			}
			return false;
		}
	}
	[HarmonyPatch(typeof(PlayerController), "InInventoryEtc")]
	internal static class PortalPlayerInputPatch
	{
		private static bool Prepare()
		{
			return !Application.isBatchMode;
		}

		private static void Postfix(ref bool __result)
		{
			if (!Application.isBatchMode && PortalController.CapturesInput)
			{
				__result = true;
			}
		}
	}
	[HarmonyPatch(typeof(Player), "TakeInput")]
	internal static class PortalCharacterInputPatch
	{
		private static bool Prepare()
		{
			return !Application.isBatchMode;
		}

		private static void Postfix(Player __instance, ref bool __result)
		{
			if (!Application.isBatchMode && (Object)(object)__instance == (Object)(object)Player.m_localPlayer && PortalController.CapturesInput)
			{
				__result = false;
			}
		}
	}
	[HarmonyPatch(typeof(Menu), "Show")]
	internal static class PortalEscapeMenuPatch
	{
		private static bool Prepare()
		{
			return !Application.isBatchMode;
		}

		private static bool Prefix()
		{
			if (Application.isBatchMode || !PortalController.CapturesInput)
			{
				return true;
			}
			PortalController.Instance?.DismissFromMenuInput();
			return false;
		}
	}
	[HarmonyPatch(typeof(Chat), "Update")]
	internal static class PortalChatInputPatch
	{
		private static bool Prepare()
		{
			return !Application.isBatchMode;
		}

		private static bool Prefix()
		{
			if (!Application.isBatchMode)
			{
				return !PortalController.CapturesInput;
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(Chat), "InputText")]
	internal static class PortalChatOpenPatch
	{
		private static bool Prepare()
		{
			return !Application.isBatchMode;
		}

		private static bool Prefix()
		{
			if (!Application.isBatchMode)
			{
				return !PortalController.CapturesInput;
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(TeleportWorldTrigger), "Awake")]
	internal static class PortalExitWatcherPatch
	{
		private static bool Prepare()
		{
			return !Application.isBatchMode;
		}

		private static void Postfix(TeleportWorldTrigger __instance)
		{
			if (!Application.isBatchMode)
			{
				(((Component)__instance).GetComponent<PortalExitWatcher>() ?? ((Component)__instance).gameObject.AddComponent<PortalExitWatcher>()).Initialize(((Component)__instance).GetComponentInParent<TeleportWorld>(), __instance);
			}
		}
	}
	[HarmonyPatch(typeof(TeleportWorld), "UpdatePortal")]
	internal static class PortalGlowUpdateContextPatch
	{
		[ThreadStatic]
		private static TeleportWorld updating;

		private static bool Prepare()
		{
			return !Application.isBatchMode;
		}

		internal static bool IsUpdating(TeleportWorld portal)
		{
			return (Object)(object)updating == (Object)(object)portal;
		}

		private static void Prefix(TeleportWorld __instance)
		{
			if (!Application.isBatchMode)
			{
				updating = __instance;
			}
		}

		private static void Postfix()
		{
			updating = null;
		}

		private static Exception Finalizer(Exception __exception)
		{
			updating = null;
			return __exception;
		}
	}
	[HarmonyPatch(typeof(TeleportWorld), "TargetFound")]
	internal static class UnpairedPortalGlowPatch
	{
		private static bool Prepare()
		{
			return !Application.isBatchMode;
		}

		private static void Postfix(TeleportWorld __instance, ref bool __result)
		{
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			if (!(Application.isBatchMode | __result) && PortalGlowUpdateContextPatch.IsUpdating(__instance))
			{
				Player localPlayer = Player.m_localPlayer;
				ZNetView component = ((Component)__instance).GetComponent<ZNetView>();
				if (Object.op_Implicit((Object)(object)localPlayer) && Object.op_Implicit((Object)(object)component) && component.IsValid() && component.GetZDO() != null && Object.op_Implicit((Object)(object)__instance.m_proximityRoot) && !string.IsNullOrWhiteSpace(component.GetZDO().GetString("tag", "")) && !(Vector3.Distance(((Component)localPlayer).transform.position, __instance.m_proximityRoot.position) > __instance.m_activationRange) && ((Humanoid)localPlayer).IsTeleportable(__instance.m_allowAllItems))
				{
					__result = true;
				}
			}
		}
	}
	internal sealed class PortalExitWatcher : MonoBehaviour
	{
		private readonly HashSet<Collider> localColliders = new HashSet<Collider>();

		private TeleportWorld portal;

		private BoxCollider[] boxes = Array.Empty<BoxCollider>();

		private Vector3[] originalBoxSizes = Array.Empty<Vector3>();

		private SphereCollider[] spheres = Array.Empty<SphereCollider>();

		private float[] originalSphereRadii = Array.Empty<float>();

		private CapsuleCollider[] capsules = Array.Empty<CapsuleCollider>();

		private float[] originalCapsuleRadii = Array.Empty<float>();

		private float[] originalCapsuleHeights = Array.Empty<float>();

		private float appliedMultiplier = -1f;

		private bool rangesCaptured;

		internal void Initialize(TeleportWorld sourcePortal, TeleportWorldTrigger trigger)
		{
			portal = sourcePortal;
			if (!rangesCaptured && Object.op_Implicit((Object)(object)trigger))
			{
				boxes = ((Component)trigger).GetComponents<BoxCollider>();
				originalBoxSizes = boxes.Select((BoxCollider box) => box.size).ToArray();
				spheres = ((Component)trigger).GetComponents<SphereCollider>();
				originalSphereRadii = spheres.Select((SphereCollider sphere) => sphere.radius).ToArray();
				capsules = ((Component)trigger).GetComponents<CapsuleCollider>();
				originalCapsuleRadii = capsules.Select((CapsuleCollider capsule) => capsule.radius).ToArray();
				originalCapsuleHeights = capsules.Select((CapsuleCollider capsule) => capsule.height).ToArray();
				rangesCaptured = true;
			}
			ApplyTriggerMultiplier();
		}

		private void Update()
		{
			if (!Mathf.Approximately(appliedMultiplier, PortalRanges.TriggerMultiplier))
			{
				ApplyTriggerMultiplier();
			}
		}

		private void ApplyTriggerMultiplier()
		{
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			if (!rangesCaptured)
			{
				return;
			}
			float triggerMultiplier = PortalRanges.TriggerMultiplier;
			for (int i = 0; i < boxes.Length; i++)
			{
				if (Object.op_Implicit((Object)(object)boxes[i]))
				{
					boxes[i].size = originalBoxSizes[i] * triggerMultiplier;
				}
			}
			for (int j = 0; j < spheres.Length; j++)
			{
				if (Object.op_Implicit((Object)(object)spheres[j]))
				{
					spheres[j].radius = originalSphereRadii[j] * triggerMultiplier;
				}
			}
			for (int k = 0; k < capsules.Length; k++)
			{
				if (Object.op_Implicit((Object)(object)capsules[k]))
				{
					capsules[k].radius = originalCapsuleRadii[k] * triggerMultiplier;
					capsules[k].height = originalCapsuleHeights[k] * triggerMultiplier;
				}
			}
			appliedMultiplier = triggerMultiplier;
		}

		private void OnTriggerEnter(Collider other)
		{
			localColliders.RemoveWhere((Collider collider) => !Object.op_Implicit((Object)(object)collider));
			if (IsLocalPlayer(other))
			{
				localColliders.Add(other);
			}
		}

		private void OnTriggerExit(Collider other)
		{
			if (IsLocalPlayer(other))
			{
				localColliders.RemoveWhere((Collider collider) => !Object.op_Implicit((Object)(object)collider));
				localColliders.Remove(other);
				if (localColliders.Count == 0)
				{
					PortalController.Instance?.CloseIfSource(portal);
				}
			}
		}

		private void OnDestroy()
		{
			localColliders.Clear();
			PortalController.Instance?.CloseIfSource(portal);
		}

		private static bool IsLocalPlayer(Collider collider)
		{
			Player val = ((Component)collider).GetComponent<Player>() ?? ((Component)collider).GetComponentInParent<Player>();
			if (Object.op_Implicit((Object)(object)val))
			{
				return (Object)(object)val == (Object)(object)Player.m_localPlayer;
			}
			return false;
		}
	}
	internal static class PortalRpc
	{
		private readonly struct RequestWindow
		{
			internal readonly float Start;

			internal readonly int Count;

			internal RequestWindow(float start, int count)
			{
				Start = start;
				Count = count;
			}
		}

		private readonly struct ServerSession
		{
			internal readonly ZDOID Source;

			internal readonly long Nonce;

			internal readonly float Expires;

			internal readonly HashSet<ZDOID> Destinations;

			internal ServerSession(ZDOID source, long nonce, float expires, IEnumerable<ZDOID> destinations)
			{
				//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)
				Source = source;
				Nonce = nonce;
				Expires = expires;
				Destinations = new HashSet<ZDOID>(destinations);
			}
		}

		private const int ProtocolVersion = 2;

		private const string DirectoryRequest = "com.fraileywoodworks.portalselector.v2.directory.request";

		private const string DirectoryResponse = "com.fraileywoodworks.portalselector.v2.directory.response";

		private const string TravelRequest = "com.fraileywoodworks.portalselector.v2.travel.request";

		private const string TravelResponse = "com.fraileywoodworks.portalselector.v2.travel.response";

		private const float ServerSessionLifetime = 60f;

		private static readonly Dictionary<long, RequestWindow> Windows = new Dictionary<long, RequestWindow>();

		private static readonly Dictionary<long, ServerSession> Sessions = new Dictionary<long, ServerSession>();

		private static ZRoutedRpc registeredOn;

		internal static bool Register()
		{
			ZRoutedRpc instance = ZRoutedRpc.instance;
			if (instance == null)
			{
				return false;
			}
			if (registeredOn == instance)
			{
				return true;
			}
			instance.Register<ZPackage>("com.fraileywoodworks.portalselector.v2.directory.request", (Action<long, ZPackage>)OnDirectoryRequest);
			instance.Register<ZPackage>("com.fraileywoodworks.portalselector.v2.directory.response", (Action<long, ZPackage>)OnDirectoryResponse);
			instance.Register<ZPackage>("com.fraileywoodworks.portalselector.v2.travel.request", (Action<long, ZPackage>)OnTravelRequest);
			instance.Register<ZPackage>("com.fraileywoodworks.portalselector.v2.travel.response", (Action<long, ZPackage>)OnTravelResponse);
			registeredOn = instance;
			return true;
		}

		internal static bool AskDirectory(ZDOID source, ZDOID savedHome, long nonce)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Expected O, but got Unknown
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			if (!Register() || !TryServerId(out var server))
			{
				return false;
			}
			ZPackage val = new ZPackage();
			val.Write(2);
			val.Write(source);
			val.Write(savedHome != ZDOID.None);
			if (savedHome != ZDOID.None)
			{
				val.Write(savedHome);
			}
			val.Write(nonce);
			ZRoutedRpc.instance.InvokeRoutedRPC(server, "com.fraileywoodworks.portalselector.v2.directory.request", new object[1] { val });
			return true;
		}

		internal static bool AskTravel(ZDOID source, ZDOID destination, long nonce)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Expected O, but got Unknown
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			if (!Register() || !TryServerId(out var server))
			{
				return false;
			}
			ZPackage val = new ZPackage();
			val.Write(2);
			val.Write(source);
			val.Write(destination);
			val.Write(nonce);
			ZRoutedRpc.instance.InvokeRoutedRPC(server, "com.fraileywoodworks.portalselector.v2.travel.request", new object[1] { val });
			return true;
		}

		private static bool TryServerId(out long server)
		{
			server = 0L;
			if ((Object)(object)ZNet.instance == (Object)null)
			{
				return false;
			}
			if (ZNet.instance.IsServer())
			{
				server = ZNet.GetUID();
				return true;
			}
			ZNetPeer serverPeer = ZNet.instance.GetServerPeer();
			if (serverPeer == null)
			{
				return false;
			}
			server = serverPeer.m_uid;
			return true;
		}

		internal static bool TryPortal(ZDOID id, out ZDO portal)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			ZDOMan instance = ZDOMan.instance;
			portal = ((instance == null) ? null : instance.GetPortalList()?.FirstOrDefault((Func<ZDO, bool>)((ZDO z) => z != null && z.IsValid() && z.m_uid == id)));
			return portal != null;
		}

		private static bool NearSource(long sender, ZDO source)
		{
			//IL_0061: 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_0038: 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)
			ZNet instance = ZNet.instance;
			if ((Object)(object)instance == (Object)null || source == null)
			{
				return false;
			}
			if (instance.IsServer() && sender == ZNet.GetUID())
			{
				Player localPlayer = Player.m_localPlayer;
				if (Object.op_Implicit((Object)(object)localPlayer))
				{
					return Vector3.Distance(((Component)localPlayer).transform.position, source.GetPosition()) <= 9.375f;
				}
				return false;
			}
			ZNetPeer peer = instance.GetPeer(sender);
			if (peer != null)
			{
				return Vector3.Distance(peer.m_refPos, source.GetPosition()) <= 9.375f;
			}
			return false;
		}

		private static bool RateAllowed(long sender)
		{
			float realtimeSinceStartup = Time.realtimeSinceStartup;
			if (Windows.TryGetValue(sender, out var value) && realtimeSinceStartup - value.Start < 2f)
			{
				if (value.Count >= 4)
				{
					return false;
				}
				Windows[sender] = new RequestWindow(value.Start, value.Count + 1);
			}
			else
			{
				Windows[sender] = new RequestWindow(realtimeSinceStartup, 1);
			}
			return true;
		}

		private static void OnDirectoryRequest(long sender, ZPackage request)
		{
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e9: 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_031a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0321: Expected O, but got Unknown
			//IL_0360: Unknown result type (might be due to invalid IL or missing references)
			//IL_037c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0386: Expected I4, but got Unknown
			if ((Object)(object)ZNet.instance == (Object)null || !ZNet.instance.IsServer())
			{
				return;
			}
			try
			{
				if (request.ReadInt() != 2)
				{
					return;
				}
				ZDOID sourceId = request.ReadZDOID();
				ZDOID savedHome = (request.ReadBool() ? request.ReadZDOID() : ZDOID.None);
				long num = request.ReadLong();
				if (!RateAllowed(sender) || !TryPortal(sourceId, out var portal) || !NearSource(sender, portal))
				{
					return;
				}
				WorldGenerator generator = WorldGenerator.instance;
				List<ZDO> list = (from z in ZDOMan.instance.GetPortalList()
					where z != null && z.IsValid()
					select z).ToList();
				PortalOrderLedger.Ensure(list);
				List<PortalInfo> source = (from z in list
					where z.m_uid != sourceId
					select new PortalInfo(z.m_uid, PortalNames.Sanitize(z.GetString("tag", "")), (Biome)((generator != null) ? ((int)generator.GetBiome(z.GetPosition())) : 0), PortalOrderLedger.Get(z.m_uid)) into p
					where !string.IsNullOrWhiteSpace(p.Name)
					orderby PortalBiomes.Rank(p.Biome), p.CreationOrder
					select p).ThenBy(delegate(PortalInfo p)
				{
					//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)
					ZDOID id = p.Id;
					return (ulong)((ZDOID)(ref id)).UserID;
				}).ThenBy((PortalInfo p) => ((ZDOID)(ref p.Id)).ID).ToList();
				bool flag = savedHome != ZDOID.None && list.Any((ZDO zdo) => zdo.m_uid == savedHome && !string.IsNullOrWhiteSpace(PortalNames.Sanitize(zdo.GetString("tag", ""))));
				List<PortalInfo> list2 = source.Take(512).ToList();
				if (flag && savedHome != sourceId && !list2.Any((PortalInfo portalInfo) => portalInfo.Id == savedHome))
				{
					list2[list2.Count - 1] = source.First((PortalInfo portalInfo) => portalInfo.Id == savedHome);
					list2 = (from p in list2
						orderby PortalBiomes.Rank(p.Biome), p.CreationOrder
						select p).ThenBy(delegate(PortalInfo p)
					{
						//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)
						ZDOID id = p.Id;
						return (ulong)((ZDOID)(ref id)).UserID;
					}).ThenBy((PortalInfo p) => ((ZDOID)(ref p.Id)).ID).ToList();
				}
				Sessions[sender] = new ServerSession(sourceId, num, Time.realtimeSinceStartup + 60f, list2.Select((PortalInfo portalInfo) => portalInfo.Id));
				ZPackage val = new ZPackage();
				val.Write(2);
				val.Write(num);
				val.Write(flag);
				val.Write(list2.Count);
				foreach (PortalInfo item in list2)
				{
					val.Write(item.Id);
					val.Write(item.Name);
					val.Write((int)item.Biome);
					val.Write(item.CreationOrder);
				}
				ZRoutedRpc.instance.InvokeRoutedRPC(sender, "com.fraileywoodworks.portalselector.v2.directory.response", new object[1] { val });
			}
			catch (Exception ex)
			{
				Plugin.LogDebug("Rejected malformed portal directory request: " + ex.GetType().Name);
			}
		}

		private static void OnDirectoryResponse(long sender, ZPackage package)
		{
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: 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)
			if (!TryServerId(out var server) || sender != server)
			{
				return;
			}
			try
			{
				if (package.ReadInt() != 2)
				{
					return;
				}
				long responseNonce = package.ReadLong();
				bool homeValid = package.ReadBool();
				int num = package.ReadInt();
				if (num < 0 || num > 512)
				{
					throw new InvalidDataException("Portal directory count was outside the protocol bounds.");
				}
				List<PortalInfo> list = new List<PortalInfo>(num);
				for (int i = 0; i < num; i++)
				{
					ZDOID val = package.ReadZDOID();
					string text = PortalNames.Sanitize(package.ReadString());
					Biome biome = PortalBiomes.Normalize(package.ReadInt());
					long num2 = package.ReadLong();
					if (val == ZDOID.None || string.IsNullOrWhiteSpace(text) || num2 <= 0)
					{
						throw new InvalidDataException("Portal directory record was invalid.");
					}
					list.Add(new PortalInfo(val, text, biome, num2));
				}
				PortalController.Instance?.Show(responseNonce, homeValid, list);
			}
			catch (Exception ex)
			{
				Plugin.LogDebug("Rejected malformed portal directory response: " + ex.GetType().Name);
			}
		}

		private static void OnTravelRequest(long sender, ZPackage request)
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: 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_00bb: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)ZNet.instance == (Object)null || !ZNet.instance.IsServer())
			{
				return;
			}
			try
			{
				if (request.ReadInt() == 2)
				{
					ZDOID val = request.ReadZDOID();
					ZDOID val2 = request.ReadZDOID();
					long num = request.ReadLong();
					ServerSession value;
					bool flag = Sessions.TryGetValue(sender, out value) && value.Source == val && value.Nonce == num && value.Expires >= Time.realtimeSinceStartup && value.Destinations.Contains(val2);
					Sessions.Remove(sender);
					if (!RateAllowed(sender) || !flag || !TryPortal(val, out var portal) || !NearSource(sender, portal) || !TryPortal(val2, out var portal2) || val2 == val || string.IsNullOrWhiteSpace(PortalNames.Sanitize(portal2.GetString("tag", ""))))
					{
						SendTravelResponse(sender, num, approved: false, null);
					}
					else
					{
						SendTravelResponse(sender, num, approved: true, portal2);
					}
				}
			}
			catch (Exception ex)
			{
				Plugin.LogDebug("Rejected malformed portal travel request: " + ex.GetType().Name);
			}
		}

		private static void OnTravelResponse(long sender, ZPackage package)
		{
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			if (!TryServerId(out var server) || sender != server)
			{
				return;
			}
			try
			{
				if (package.ReadInt() == 2)
				{
					long responseNonce = package.ReadLong();
					bool flag = package.ReadBool();
					PortalController.Instance?.Complete(responseNonce, flag, (Vector3)(flag ? package.ReadVector3() : default(Vector3)), (Quaternion)(flag ? package.ReadQuaternion() : default(Quaternion)));
				}
			}
			catch (Exception ex)
			{
				Plugin.LogDebug("Rejected malformed portal travel response: " + ex.GetType().Name);
			}
		}

		private static void SendTravelResponse(long sender, long nonce, bool approved, ZDO destination)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Expected O, but got Unknown
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			ZPackage val = new ZPackage();
			val.Write(2);
			val.Write(nonce);
			val.Write(approved);
			if (approved && destination != null)
			{
				val.Write(destination.GetPosition());
				val.Write(destination.GetRotation());
			}
			ZRoutedRpc.instance.InvokeRoutedRPC(sender, "com.fraileywoodworks.portalselector.v2.travel.response", new object[1] { val });
		}
	}
	internal readonly struct PortalInfo
	{
		internal readonly ZDOID Id;

		internal readonly string Name;

		internal readonly Biome Biome;

		internal readonly long CreationOrder;

		internal PortalInfo(ZDOID id, string name, Biome biome, long creationOrder)
		{
			//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_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Expected I4, but got Unknown
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			Id = id;
			Name = name;
			Biome = PortalBiomes.Normalize((int)biome);
			CreationOrder = Math.Max(1L, creationOrder);
		}
	}
	internal sealed class PortalController : MonoBehaviour
	{
		private const float DirectoryTimeout = 5f;

		private const float SessionLifetime = 60f;

		private const float TravelTimeout = 3f;

		private const float FirstEntryRetryWindow = 6f;

		private const float FirstEntryRetryInterval = 0.1f;

		private const float DirectoryResponseRetryInterval = 0.75f;

		internal static PortalController Instance;

		internal static bool BypassOnce;

		private ZDOID source;

		private TeleportWorld sourcePortal;

		private long nonce;

		private float requestStarted;

		private float sessionDeadline;

		private float nextOpenAllowed;

		private float travelDeadline;

		private GameObject panel;

		private CanvasGroup canvasGroup;

		private Transform content;

		private LayoutElement scrollLayout;

		private ScrollRect destinationScroll;

		private Button firstSelectable;

		private Button homeSelectable;

		private bool? previousMouseInput;

		private Vector3 openingMousePosition;

		private bool mouseChoiceArmed;

		private int cursorCenterFrames;

		private float fadeTarget;

		private bool resetAfterFade;

		private bool travelPending;

		private bool directoryReady;

		private bool pendingTeleport;

		private Vector3 pendingPosition;

		private Quaternion pendingRotation;

		private TeleportWorld deferredPortal;

		private ZDOID deferredSource;

		private float deferredStarted;

		private float deferredDeadline;

		private float nextDeferredAttempt;

		private RectTransform panelRect;

		private VerticalLayoutGroup panelLayout;

		private VerticalLayoutGroup contentLayout;

		private TMP_Text titleText;

		private TMP_Text hintText;

		private GameObject darkBackdrop;

		private CanvasGroup darkBackdropGroup;

		private GameObject menuOrnament;

		private Graphic[] menuOrnamentGraphics = Array.Empty<Graphic>();

		private float[] menuOrnamentBaseAlphas = Array.Empty<float>();

		private bool visualsDirty;

		private readonly List<GameObject> rows = new List<GameObject>();

		private readonly List<PortalEntryHover> portalRows = new List<PortalEntryHover>();

		private readonly List<PortalInfo> currentPortals = new List<PortalInfo>();

		private static TMP_FontAsset nativeFont;

		private static Material nativeFontMaterial;

		private static Sprite nativeHomeSprite;

		private static int nativeHomeSpriteSearchFrame = -1;

		private static bool cursorWarpPrepared;

		private static PropertyInfo inputMouseCurrentProperty;

		private static MethodInfo inputMouseWarpMethod;

		internal static bool CapturesInput
		{
			get
			{
				if ((Object)(object)Instance != (Object)null)
				{
					if (!Object.op_Implicit((Object)(object)Instance.panel) || !Instance.panel.activeSelf)
					{
						return Instance.travelPending;
					}
					return true;
				}
				return false;
			}
		}

		internal static bool WantsCursor
		{
			get
			{
				if ((Object)(object)Instance != (Object)null && Object.op_Implicit((Object)(object)Instance.panel) && Instance.panel.activeSelf && Instance.fadeTarget > 0f)
				{
					return !Instance.travelPending;
				}
				return false;
			}
		}

		private void Awake()
		{
			Instance = this;
			visualsDirty = true;
			PrepareCursorWarp();
		}

		internal void MarkVisualsDirty()
		{
			visualsDirty = true;
		}

		internal void Begin(TeleportWorld portal, ZDOID sourceId)
		{
			//IL_003a: 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_004c: 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_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			if (Object.op_Implicit((Object)(object)portal) && !CapturesInput && nonce == 0L && !Object.op_Implicit((Object)(object)deferredPortal) && !(Time.realtimeSinceStartup < nextOpenAllowed) && !AnotherModalIsVisible() && PortalCandidateIsUsable(portal, sourceId))
			{
				deferredPortal = portal;
				deferredSource = sourceId;
				deferredStarted = Time.realtimeSinceStartup;
				deferredDeadline = deferredStarted + 6f;
				nextDeferredAttempt = deferredStarted + 0.1f;
				if (!TryStartRequest(portal, sourceId))
				{
					Plugin.LogDebug($"Portal entry deferred for up to {6f:0.0}s while the world portal registry and routed RPC finish initializing.");
				}
				else if (deferredSource != ZDOID.None && !directoryReady)
				{
					nextDeferredAttempt = Time.realtimeSinceStartup + 0.75f;
					Plugin.LogDebug("Portal directory request sent; waiting for server acceptance.");
				}
			}
		}

		private bool TryStartRequest(TeleportWorld portal, ZDOID sourceId)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: 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_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			if (!PortalCandidateIsUsable(portal, sourceId) || !PortalRpc.Register() || !PortalRpc.TryPortal(sourceId, out var _))
			{
				return false;
			}
			sourcePortal = portal;
			source = sourceId;
			if (!SourceIsUsable())
			{
				sourcePortal = null;
				source = ZDOID.None;
				return false;
			}
			nonce = DateTime.UtcNow.Ticks;
			directoryReady = false;
			requestStarted = Time.realtimeSinceStartup;
			sessionDeadline = requestStarted + 60f - 2f;
			PortalHome.TryGet(out var id);
			if (!PortalRpc.AskDirectory(source, id, nonce))
			{
				sourcePortal = null;
				source = ZDOID.None;
				nonce = 0L;
				requestStarted = 0f;
				sessionDeadline = 0f;
				return false;
			}
			return true;
		}

		private static bool PortalCandidateIsUsable(TeleportWorld portal, ZDOID sourceId)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: 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_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			Player localPlayer = Player.m_localPlayer;
			if (!Object.op_Implicit((Object)(object)portal) || !Object.op_Implicit((Object)(object)localPlayer) || sourceId == ZDOID.None)
			{
				return false;
			}
			ZNetView component = ((Component)portal).GetComponent<ZNetView>();
			if (!Object.op_Implicit((Object)(object)component) || !component.IsValid() || component.GetZDO() == null || component.GetZDO().m_uid != sourceId)
			{
				return false;
			}
			Vector3 val = (Object.op_Implicit((Object)(object)portal.m_proximityRoot) ? portal.m_proximityRoot.position : component.GetZDO().GetPosition());
			return Vector3.Distance(((Component)localPlayer).transform.position, val) <= PortalRanges.ClientDistance(portal);
		}

		private void AdvanceDeferredBegin()
		{
			//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_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0110: Unknown result type (might be due to invalid IL or missing references)
			if (deferredSource == ZDOID.None)
			{
				return;
			}
			if (!Object.op_Implicit((Object)(object)deferredPortal))
			{
				ClearDeferredBegin();
				return;
			}
			float realtimeSinceStartup = Time.realtimeSinceStartup;
			if (realtimeSinceStartup >= deferredDeadline)
			{
				Plugin.LogDebug($"Deferred portal entry timed out after {Mathf.Max(0f, realtimeSinceStartup - deferredStarted):0.00}s; leave and re-enter the portal to retry.");
				ResetSession(0f);
			}
			else if (realtimeSinceStartup < nextOpenAllowed || AnotherModalIsVisible() || !PortalCandidateIsUsable(deferredPortal, deferredSource))
			{
				Plugin.LogDebug("Deferred portal entry canceled because the player left range, opened another interface, or entered the post-travel cooldown.");
				ResetSession(0f);
			}
			else
			{
				if (realtimeSinceStartup < nextDeferredAttempt)
				{
					return;
				}
				if (nonce == 0L)
				{
					nextDeferredAttempt = realtimeSinceStartup + 0.1f;
					if (TryStartRequest(deferredPortal, deferredSource))
					{
						nextDeferredAttempt = realtimeSinceStartup + 0.75f;
						Plugin.LogDebug("Deferred portal directory request sent; waiting for server acceptance.");
					}
				}
				else if (!directoryReady)
				{
					nextDeferredAttempt = realtimeSinceStartup + 0.75f;
					PortalHome.TryGet(out var id);
					if (!PortalRpc.AskDirectory(source, id, nonce))
					{
						nextDeferredAttempt = realtimeSinceStartup + 0.1f;
					}
				}
			}
		}

		private void ClearDeferredBegin()
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			deferredPortal = null;
			deferredSource = ZDOID.None;
			deferredStarted = 0f;
			deferredDeadline = 0f;
			nextDeferredAttempt = 0f;
		}

		internal void Show(long responseNonce, bool homeValid, List<PortalInfo> portals)
		{
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_0251: Unknown result type (might be due to invalid IL or missing references)
			//IL_0256: Unknown result type (might be due to invalid IL or missing references)
			//IL_021f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0225: 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_0312: Unknown result type (might be due to invalid IL or missing references)
			//IL_0333: Unknown result type (might be due to invalid IL or missing references)
			//IL_033f: Unknown result type (might be due to invalid IL or missing references)
			//IL_042c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0436: Expected O, but got Unknown
			//IL_03bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0367: Unknown result type (might be due to invalid IL or missing references)
			//IL_0373: Unknown result type (might be due to invalid IL or missing references)
			if (responseNonce != nonce || travelPending || directoryReady)
			{
				return;
			}
			if (!SourceIsUsable())
			{
				ResetSession(0f);
				return;
			}
			directoryReady = true;
			if (deferredSource != ZDOID.None)
			{
				float num = Mathf.Max(0f, Time.realtimeSinceStartup - deferredStarted);
				Plugin.LogDebug($"Deferred portal entry started successfully after {num:0.00}s and server acceptance.");
				ClearDeferredBegin();
			}
			EnsureUi();
			foreach (GameObject row in rows)
			{
				Object.Destroy((Object)(object)row);
			}
			rows.Clear();
			portalRows.Clear();
			currentPortals.Clear();
			firstSelectable = null;
			homeSelectable = null;
			currentPortals.AddRange((from p in portals
				orderby PortalBiomes.Rank(p.Biome), p.CreationOrder
				select p).ThenBy(delegate(PortalInfo p)
			{
				//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)
				ZDOID id = p.Id;
				return (ulong)((ZDOID)(ref id)).UserID;
			}).ThenBy((PortalInfo p) => ((ZDOID)(ref p.Id)).ID));
			Dictionary<string, int> dictionary = currentPortals.GroupBy<PortalInfo, string>((PortalInfo p) => p.Name, StringComparer.OrdinalIgnoreCase).ToDictionary<IGrouping<string, PortalInfo>, string, int>((IGrouping<string, PortalInfo> g) => g.Key, (IGrouping<string, PortalInfo> g) => g.Count(), StringComparer.OrdinalIgnoreCase);
			Dictionary<string, int> dictionary2 = new Dictionary<string, int>(StringComparer.OrdinalIgnoreCase);
			if (PortalHome.TryGet(out var home) && (!homeValid || (home != source && !currentPortals.Any((PortalInfo portal) => portal.Id == home))))
			{
				PortalHome.Clear();
				home = ZDOID.None;
				ShowStatus("Home portal unavailable — choose a new Home");
			}
			foreach (PortalInfo currentPortal in currentPortals)
			{
				dictionary2.TryGetValue(currentPortal.Name, out var value);
				value = (dictionary2[currentPortal.Name] = value + 1);
				string label = ((dictionary[currentPortal.Name] > 1) ? $"{currentPortal.Name}  ({value}/{dictionary[currentPortal.Name]})" : currentPortal.Name);
				PortalInfo destination = currentPortal;
				Button val = AddRow(label, PortalBiomes.DisplayName(currentPortal.Biome), currentPortal.Id, delegate
				{
					//IL_0011: Unknown result type (might be due to invalid IL or missing references)
					ActivateDestination(destination.Id);
				}, delegate
				{
					ToggleHome(destination);
				}, currentPortal.Id == home);
				if (!Object.op_Implicit((Object)(object)firstSelectable))
				{
					firstSelectable = val;
				}
				if (currentPortal.Id == home)
				{
					homeSelectable = val;
				}
			}
			if (currentPortals.Count == 0)
			{
				AddRow("No named destinations found", string.Empty, ZDOID.None, null, null, isHome: false);
			}
			ConfigureRowNavigation();
			UpdateHintText();
			ApplyVisualSettings();
			canvasGroup.alpha = 0f;
			canvasGroup.interactable = true;
			canvasGroup.blocksRaycasts = true;
			fadeTarget = 1f;
			resetAfterFade = false;
			panel.SetActive(true);
			LayoutRebuilder.ForceRebuildLayoutImmediate((RectTransform)panel.transform);
			previousMouseInput = null;
			mouseChoiceArmed = false;
			SynchronizeInputSelection(centerMouse: true);
			if (Object.op_Implicit((Object)(object)homeSelectable) && PortalVisualSettings.PreferHomeOnOpen)
			{
				ScrollIntoView(((Component)homeSelectable).gameObject);
			}
		}

		internal void Complete(long responseNonce, bool approved, Vector3 position, Quaternion rotation)
		{
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			if (responseNonce != nonce)
			{
				return;
			}
			travelPending = false;
			if (!approved || (Object)(object)Player.m_localPlayer == (Object)null)
			{
				RequestClose(invalidateRequest: true);
				return;
			}
			pendingTeleport = true;
			pendingPosition = position;
			pendingRotation = rotation;
			BeginFadeOut(resetWhenHidden: false);
			if (!Object.op_Implicit((Object)(object)panel) || !panel.activeSelf)
			{
				PerformPendingTeleport();
			}
		}

		internal void CloseIfSource(TeleportWorld portal)
		{
			if (Object.op_Implicit((Object)(object)portal) && (Object)(object)portal == (Object)(object)deferredPortal)
			{
				Plugin.LogDebug("Deferred portal entry canceled when the player left the source trigger.");
				ClearDeferredBegin();
			}
			if (Object.op_Implicit((Object)(object)portal) && (Object)(object)portal == (Object)(object)sourcePortal && nonce != 0L)
			{
				RequestClose(invalidateRequest: true);
			}
		}

		internal void DismissFromMenuInput()
		{
			RequestClose(invalidateRequest: true);
		}

		private void Update()
		{
			//IL_008e: 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_014a: Unknown result type (might be due to invalid IL or missing references)
			//IL_014f: Unknown result type (might be due to invalid IL or missing references)
			if (!Object.op_Implicit((Object)(object)panel) && Object.op_Implicit((Object)(object)Menu.instance) && Object.op_Implicit((Object)(object)Menu.instance.m_continueButton))
			{
				EnsureUi();
			}
			AdvanceDeferredBegin();
			if (visualsDirty)
			{
				ApplyVisualSettings();
			}
			if (nonce != 0L && !SourceIsUsable())
			{
				RequestClose(invalidateRequest: true);
			}
			if (Object.op_Implicit((Object)(object)panel) && panel.activeSelf)
			{
				SynchronizeInputSelection();
				AdvanceCursorCentering();
				ArmMouseChoiceAfterMovement();
				KeyboardShortcut setHomeKeyboardShortcut = PortalVisualSettings.SetHomeKeyboardShortcut;
				if (((KeyboardShortcut)(ref setHomeKeyboardShortcut)).IsDown() || ZInput.GetButtonDown("JoyButtonX"))
				{
					ToggleSelectedHome();
				}
				else if (Input.GetKeyDown((KeyCode)13) || Input.GetKeyDown((KeyCode)271) || ZInput.GetButtonDown("JoyButtonA"))
				{
					ConfirmSelected();
				}
				else if (Input.GetKeyDown((KeyCode)27) || ZInput.GetButtonDown("JoyButtonB") || AnotherModalIsVisible())
				{
					RequestClose(invalidateRequest: true);
				}
				KeepControllerSelectionVisible();
				AdvanceFade();
			}
			if (nonce != 0L && Time.realtimeSinceStartup >= sessionDeadline)
			{
				RequestClose(invalidateRequest: true);
			}
			if (travelPending && Time.realtimeSinceStartup >= travelDeadline)
			{
				RequestClose(invalidateRequest: true);
			}
			if (nonce != 0L && deferredSource == ZDOID.None && !travelPending && (!Object.op_Implicit((Object)(object)panel) || !panel.activeSelf) && Time.realtimeSinceStartup - requestStarted >= 5f)
			{
				ResetSession(0f);
			}
			if (pendingTeleport && (!Object.op_Implicit((Object)(object)panel) || !panel.activeSelf))
			{
				PerformPendingTeleport();
			}
		}

		private void EnsureUi()
		{
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Expected O, but got Unknown
			//IL_007c: 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_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0135: Unknown result type (might be due to invalid IL or missing references)
			//IL_013f: Expected O, but got Unknown
			//IL_0162: Unknown result type (might be due to invalid IL or missing references)
			//IL_016c: Expected O, but got Unknown
			//IL_0189: Unknown result type (might be due to invalid IL or missing references)
			//IL_0190: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01eb: Expected O, but got Unknown
			//IL_0318: Unknown result type (might be due to invalid IL or missing references)
			//IL_033e: Unknown result type (might be due to invalid IL or missing references)
			//IL_037f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0385: Expected O, but got Unknown
			//IL_03dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e4: Expected O, but got Unknown
			//IL_03fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0408: Expected O, but got Unknown
			//IL_042d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0434: Expected O, but got Unknown
			//IL_045b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0462: Expected O, but got Unknown
			//IL_046e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0484: Unknown result type (might be due to invalid IL or missing references)
			//IL_049a: Unknown result type (might be due to invalid IL or missing references)
			//IL_04a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_04b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_053b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0545: Expected O, but got Unknown
			if (Object.op_Implicit((Object)(object)panel))
			{
				return;
			}
			GameObject val = new GameObject("BetterPortals Canvas", new Type[3]
			{
				typeof(Canvas),
				typeof(CanvasScaler),
				typeof(GraphicRaycaster)
			});
			val.transform.SetParent(((Component)this).transform, false);
			Canvas component = val.GetComponent<Canvas>();
			component.renderMode = (RenderMode)0;
			component.overrideSorting = true;
			RectTransform component2 = val.GetComponent<RectTransform>();
			if (Object.op_Implicit((Object)(object)component2))
			{
				component2.anchorMin = Vector2.zero;
				component2.anchorMax = Vector2.one;
				component2.pivot = new Vector2(0.5f, 0.5f);
				component2.anchoredPosition = Vector2.zero;
				component2.sizeDelta = Vector2.zero;
			}
			Menu instance = Menu.instance;
			Canvas val2 = ((instance != null) ? ((Component)instance).GetComponentInParent<Canvas>() : null);
			component.sortingOrder = (Object.op_Implicit((Object)(object)val2) ? (val2.sortingOrder + 1) : 1701);
			ConfigureScaler(val.GetComponent<CanvasScaler>());
			panel = new GameObject("Floating Portal Menu", new Type[4]
			{
				typeof(RectTransform),
				typeof(CanvasGroup),
				typeof(VerticalLayoutGroup),
				typeof(ContentSizeFitter)
			});
			panel.transform.SetParent(val.transform, false);
			panelRect = (RectTransform)panel.transform;
			RectTransform obj = panelRect;
			RectTransform obj2 = panelRect;
			Vector2 val3 = default(Vector2);
			((Vector2)(ref val3))..ctor(0.5f, 0.5f);
			obj2.anchorMax = val3;
			obj.anchorMin = val3;
			panelRect.pivot = new Vector2(0.5f, 0.5f);
			canvasGroup = panel.GetComponent<CanvasGroup>();
			panelLayout = panel.GetComponent<VerticalLayoutGroup>();
			((LayoutGroup)panelLayout).padding = new RectOffset(16, 16, 12, 12);
			((HorizontalOrVerticalLayoutGroup)panelLayout).spacing = 4f;
			((LayoutGroup)panelLayout).childAlignment = (TextAnchor)4;
			((HorizontalOrVerticalLayoutGroup)panelLayout).childControlHeight = true;
			((HorizontalOrVerticalLayoutGroup)panelLayout).childControlWidth = true;
			((HorizontalOrVerticalLayoutGroup)panelLayout).childForceExpandHeight = false;
			((HorizontalOrVerticalLayoutGroup)panelLayout).childForceExpandWidth = true;
			panel.GetComponent<ContentSizeFitter>().verticalFit = (FitMode)2;
			darkBackdrop = CloneNativeDecoration("darken", panel.transform, 0);
			if (Object.op_Implicit((Object)(object)darkBackdrop))
			{
				darkBackdropGroup = darkBackdrop.GetComponent<CanvasGroup>() ?? darkBackdrop.AddComponent<CanvasGroup>();
			}
			menuOrnament = CloneNativeDecoration("ornament", panel.transform, 1);
			if (Object.op_Implicit((Object)(object)menuOrnament))
			{
				menuOrnamentGraphics = menuOrnament.GetComponentsInChildren<Graphic>(true);
				menuOrnamentBaseAlphas = menuOrnamentGraphics.Select((Graphic graphic) => graphic.color.a).ToArray();
			}
			titleText = (TMP_Text)(object)AddText(panel.transform, "CHOOSE DESTINATION", PortalVisualSettings.TitleFontSize, (FontStyles)0, PortalVisualSettings.TitleColor);
			hintText = (TMP_Text)(object)AddText(panel.transform, "Walk away or press Escape to close", PortalVisualSettings.HintFontSize, (FontStyles)0, PortalVisualSettings.HintColor);
			GameObject val4 = new GameObject("Destinations", new Type[3]
			{
				typeof(RectTransform),
				typeof(ScrollRect),
				typeof(LayoutElement)
			});
			val4.transform.SetParent(panel.transform, false);
			scrollLayout = val4.GetComponent<LayoutElement>();
			scrollLayout.preferredHeight = 320f;
			GameObject val5 = new GameObject("Viewport", new Type[2]
			{
				typeof(RectTransform),
				typeof(RectMask2D)
			});
			val5.transform.SetParent(val4.transform, false);
			Stretch((RectTransform)val5.transform);
			GameObject val6 = new GameObject("Content", new Type[2]
			{
				typeof(VerticalLayoutGroup),
				typeof(ContentSizeFitter)
			});
			val6.transform.SetParent(val5.transform, false);
			content = val6.transform;
			RectTransform val7 = (RectTransform)content;
			val7.anchorMin = new Vector2(0f, 1f);
			val7.anchorMax = new Vector2(1f, 1f);
			val7.pivot = new Vector2(0.5f, 1f);
			val7.anchoredPosition = Vector2.zero;
			val7.sizeDelta = Vector2.zero;
			contentLayout = val6.GetComponent<VerticalLayoutGroup>();
			((HorizontalOrVerticalLayoutGroup)contentLayout).spacing = 2f;
			((LayoutGroup)contentLayout).childAlignment = (TextAnchor)1;
			((HorizontalOrVerticalLayoutGroup)contentLayout).childControlHeight = true;
			((HorizontalOrVerticalLayoutGroup)contentLayout).childControlWidth = true;
			((HorizontalOrVerticalLayoutGroup)contentLayout).childForceExpandHeight = false;
			((HorizontalOrVerticalLayoutGroup)contentLayout).childForceExpandWidth = true;
			val6.GetComponent<ContentSizeFitter>().verticalFit = (FitMode)2;
			destinationScroll = val4.GetComponent<ScrollRect>();
			destinationScroll.viewport = (RectTransform)val5.transform;
			destinationScroll.content = val7;
			destinationScroll.horizontal = false;
			destinationScroll.vertical = true;
			destinationScroll.movementType = (MovementType)2;
			destinationScroll.scrollSensitivity = 32f;
			panel.SetActive(false);
			ApplyVisualSettings();
		}

		private static GameObject CloneNativeDecoration(string name, Transform parent, int siblingIndex)
		{
			Menu instance = Menu.instance;
			object obj;
			if (instance == null)
			{
				obj = null;
			}
			else
			{
				Transform menuDialog = instance.m_menuDialog;
				obj = ((menuDialog != null) ? menuDialog.Find(name) : null);
			}
			Transform val = (Transform)obj;
			if (!Object.op_Implicit((Object)(object)val))
			{
				return null;
			}
			GameObject val2 = Object.Instantiate<GameObject>(((Component)val).gameObject, parent, false);
			((Object)val2).name = "Portal " + name;
			val2.SetActive(true);
			(val2.GetComponent<LayoutElement>() ?? val2.AddComponent<LayoutElement>()).ignoreLayout = true;
			Graphic[] componentsInChildren = val2.GetComponentsInChildren<Graphic>(true);
			for (int i = 0; i < componentsInChildren.Length; i++)
			{
				componentsInChildren[i].raycastTarget = false;
			}
			val2.transform.SetSiblingIndex(Mathf.Clamp(siblingIndex, 0, parent.childCount - 1));
			return val2;
		}

		private void ApplyVisualSettings()
		{
			//IL_0025: 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_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0169: Unknown result type (might be due to invalid IL or missing references)
			//IL_016e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0188: Unknown result type (might be due to invalid IL or missing references)
			//IL_018e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0194: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a9: Unknown result type (might be due to invalid IL or missing references)
			visualsDirty = false;
			if (!Object.op_Implicit((Object)(object)panel))
			{
				return;
			}
			panelRect.anchoredPosition = new Vector2(0f, PortalVisualSettings.PanelYOffset);
			panelRect.sizeDelta = new Vector2(PortalVisualSettings.PanelWidth, 0f);
			if (Object.op_Implicit((Object)(object)contentLayout))
			{
				((HorizontalOrVerticalLayoutGroup)contentLayout).spacing = PortalVisualSettings.RowSpacing;
			}
			if (Object.op_Implicit((Object)(object)destinationScroll))
			{
				destinationScroll.scrollSensitivity = Mathf.Max(16f, PortalVisualSettings.RowHeight * 0.7f);
			}
			ApplyTextAppearance(titleText, PortalVisualSettings.TitleFontSize, PortalVisualSettings.TitleColor);
			ApplyTextAppearance(hintText, PortalVisualSettings.HintFontSize, PortalVisualSettings.HintColor);
			foreach (GameObject row in rows)
			{
				if (Object.op_Implicit((Object)(object)row))
				{
					row.GetComponent<PortalEntryHover>()?.ApplyVisualSettings();
				}
			}
			UpdateHintText();
			if (Object.op_Implicit((Object)(object)darkBackdrop))
			{
				darkBackdrop.SetActive(PortalVisualSettings.BackdropOpacity > 0.001f);
				if (Object.op_Implicit((Object)(object)darkBackdropGroup))
				{
					darkBackdropGroup.alpha = PortalVisualSettings.BackdropOpacity;
				}
			}
			if (Object.op_Implicit((Object)(object)menuOrnament))
			{
				menuOrnament.SetActive(PortalVisualSettings.ShowMenuOrnament);
				Color ornamentColor = PortalVisualSettings.OrnamentColor;
				for (int i = 0; i < menuOrnamentGraphics.Length; i++)
				{
					Graphic val = menuOrnamentGraphics[i];
					if (Object.op_Implicit((Object)(object)val))
					{
						val.color = new Color(ornamentColor.r, ornamentColor.g, ornamentColor.b, menuOrnamentBaseAlphas[i] * ornamentColor.a);
					}
				}
			}
			UpdateListHeight();
			if (panel.activeSelf)
			{
				LayoutRebuilder.ForceRebuildLayoutImmediate(panelRect);
			}
		}

		private void UpdateListHeight()
		{
			if (Object.op_Implicit((Object)(object)scrollLayout))
			{
				List<GameObject> list = rows.Where((GameObject row) => Object.op_Implicit((Object)(object)row) && row.activeSelf).ToList();
				int num = Mathf.Max(1, list.Count);
				float num2 = list.Sum(delegate(GameObject row)
				{
					LayoutElement component = row.GetComponent<LayoutElement>();
					return (component == null) ? PortalVisualSettings.RowHeight : component.preferredHeight;
				}) + (float)Mathf.Max(0, num - 1) * PortalVisualSettings.RowSpacing;
				float num3 = Mathf.Min(PortalVisualSettings.MaxListHeight, Mathf.Max(54f, PortalVisualSettings.RowHeight));
				scrollLayout.preferredHeight = Mathf.Clamp(num2, num3, PortalVisualSettings.MaxListHeight);
			}
		}

		internal static void ApplyTextAppearance(TMP_Text text, float size, Color color)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			if (Object.op_Implicit((Object)(object)text))
			{
				text.fontSize = size;
				((Graphic)text).color = color;
				text.outlineColor = Color32.op_Implicit(PortalVisualSettings.OutlineColor);
				text.outlineWidth = PortalVisualSettings.OutlineWidth;
			}
		}

		private void ConfigureRowNavigation()
		{
			//IL_005f: 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_00a9: Unknown result type (might be due to invalid IL or missing references)
			List<Button> list = (from row in rows
				select (!Object.op_Implicit((Object)(object)row)) ? null : row.GetComponent<Button>() into button
				where Object.op_Implicit((Object)(object)button) && ((Selectable)button).interactable
				select button).ToList();
			for (int num = 0; num < list.Count; num++)
			{
				Navigation navigation = ((Selectable)list[num]).navigation;
				((Navigation)(ref navigation)).mode = (Mode)4;
				((Navigation)(ref navigation)).selectOnUp = (Selectable)(object)list[(num + list.Count - 1) % list.Count];
				((Navigation)(ref navigation)).selectOnDown = (Selectable)(object)list[(num + 1) % list.Count];
				((Selectable)list[num]).navigation = navigation;
			}
		}

		private void SynchronizeInputSelection(bool centerMouse = false)
		{
			//IL_009a: 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)
			EventSystem current = EventSystem.current;
			if (!Object.op_Implicit((Object)(object)current))
			{
				return;
			}
			bool flag = ZInput.IsMouseActive();
			if (previousMouseInput.HasValue && previousMouseInput.Value == flag)
			{
				return;
			}
			bool flag2 = previousMouseInput.HasValue && !previousMouseInput.Value && flag;
			previousMouseInput = flag;
			GameObject currentSelectedGameObject = current.currentSelectedGameObject;
			if (flag)
			{
				ApplySelectorCursor(centerMouse || flag2);
				if (centerMouse || flag2)
				{
					cursorCenterFrames = 1;
					openingMousePosition = new Vector3((float)Screen.width * 0.5f, (float)Screen.height * 0.5f, 0f);
					mouseChoiceArmed = false;
				}
				if (Object.op_Implicit((Object)(object)currentSelectedGameObject) && Object.op_Implicit((Object)(object)panel) && currentSelectedGameObject.transform.IsChildOf(panel.transform))
				{
					current.SetSelectedGameObject((GameObject)null);
				}
			}
			else if (Object.op_Implicit((Object)(object)firstSelectable))
			{
				ApplySelectorCursor(center: false);
				Button val = ((PortalVisualSettings.PreferHomeOnOpen && Object.op_Implicit((Object)(object)homeSelectable)) ? homeSelectable : firstSelectable);
				current.SetSelectedGameObject(((Component)val).gameObject);
				ScrollIntoView(((Component)val).gameObject);
			}
			UpdateHintText();
		}

		private void AdvanceCursorCentering()
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			if (cursorCenterFrames > 0 && ZInput.IsMouseActive())
			{
				ApplySelectorCursor(center: true);
				cursorCenterFrames--;
				if (cursorCenterFrames == 0)
				{
					openingMousePosition = Input.mousePosition;
				}
			}
		}

		private void ArmMouseChoiceAfterMovement()
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: 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)
			if (!mouseChoiceArmed && cursorCenterFrames <= 0 && ZInput.IsMouseActive())
			{
				Vector3 val = Input.mousePosition - openingMousePosition;
				if (((Vector3)(ref val)).sqrMagnitude > 9f)
				{
					mouseChoiceArmed = true;
				}
			}
		}

		private void KeepControllerSelectionVisible()
		{
			if (!ZInput.IsMouseActive() && Object.op_Implicit((Object)(object)destinationScroll) && Object.op_Implicit((Object)(object)destinationScroll.viewport) && Object.op_Implicit((Object)(object)destinationScroll.content))
			{
				EventSystem current = EventSystem.current;
				GameObject selected = ((current != null) ? current.currentSelectedGameObject : null);
				ScrollIntoView(selected);
			}
		}

		private void ScrollIntoView(GameObject selected)
		{
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: 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_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			if (Object.op_Implicit((Object)(object)selected) && Object.op_Implicit((Object)(object)destinationScroll) && Object.op_Implicit((Object)(object)destinationScroll.viewport) && Object.op_Implicit((Object)(object)destinationScroll.content) && selected.transform.IsChildOf(content))
			{
				Canvas.ForceUpdateCanvases();
				Bounds val = RectTransformUtility.CalculateRelativeRectTransformBounds((Transform)(object)destinationScroll.viewport, selected.transform);
				Rect rect = destinationScroll.viewport.rect;
				float num = 0f;
				if (((Bounds)(ref val)).min.y < ((Rect)(ref rect)).yMin)
				{
					num = ((Rect)(ref rect)).yMin - ((Bounds)(ref val)).min.y;
				}
				else if (((Bounds)(ref val)).max.y > ((Rect)(ref rect)).yMax)
				{
					num = ((Rect)(ref rect)).yMax - ((Bounds)(ref val)).max.y;
				}
				if (!Mathf.Approximately(num, 0f))
				{
					Vector2 anchoredPosition = destinationScroll.content.anchoredPosition;
					anchoredPosition.y += num;
					destinationScroll.content.anchoredPosition = anchoredPosition;
				}
			}
		}

		private void ToggleHome(PortalInfo portal)
		{
			//IL_0016: 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_0034: 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_0071: Unknown result type (might be due to invalid IL or missing references)
			ZDOID id;
			bool flag = PortalHome.TryGet(out id) && id == portal.Id;
			if (!(flag ? PortalHome.Clear() : PortalHome.Set(portal.Id)))
			{
				return;
			}
			foreach (PortalEntryHover portalRow in portalRows)
			{
				portalRow.SetHome(!flag && portalRow.PortalId == portal.Id);
			}
			object obj;
			if (!flag)
			{
				PortalEntryHover? portalEntryHover = portalRows.FirstOrDefault((PortalEntryHover row) => row.PortalId == portal.Id);
				obj = ((portalEntryHover != null) ? ((Component)portalEntryHover).GetComponent<Button>() : null);
			}
			else
			{
				obj = null;
			}
			homeSelectable = (Button)obj;
			UpdateHintText();
			Plugin.LogDebug(flag ? "Home portal cleared." : ("Home portal set to " + portal.Name + "."));
		}

		private PortalEntryHover SelectedPortalRow()
		{
			EventSystem current = EventSystem.current;
			GameObject obj = ((current != null) ? current.currentSelectedGameObject : null);
			object obj2 = ((obj != null) ? obj.GetComponent<PortalEntryHover>() : null);
			if (obj2 == null)
			{
				obj2 = portalRows.FirstOrDefault((PortalEntryHover row) => row.PointerInside);
				if (obj2 == null)
				{
					if (!PortalVisualSettings.PreferHomeOnOpen || !Object.op_Implicit((Object)(object)homeSelectable))
					{
						Button obj3 = firstSelectable;
						if (obj3 == null)
						{
							return null;
						}
						return ((Component)obj3).GetComponent<PortalEntryHover>();
					}
					obj2 = ((Component)homeSelectable).GetComponent<PortalEntryHover>();
				}
			}
			return (PortalEntryHover)obj2;
		}

		private void ToggleSelectedHome()
		{
			SelectedPortalRow()?.SetAsHome();
		}

		private void ConfirmSelected()
		{
			if (!travelPending)
			{
				((ZInput.IsMouseActive() && !mouseChoiceArmed && Object.op_Implicit((Object)(object)homeSelectable)) ? ((Component)homeSelectable).GetComponent<PortalEntryHover>() : SelectedPortalRow())?.Activate();
			}
		}

		private void ActivateDestination(ZDOID destination)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			SelectDestination(destination);
		}

		private void UpdateHintText()
		{
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			if (Object.op_Implicit((Object)(object)hintText))
			{
				((Component)hintText).gameObject.SetActive(PortalVisualSettings.ShowControlHints);
				if (PortalVisualSettings.ShowControlHints)
				{
					hintText.text = (ZInput.IsMouseActive() ? $"Enter Travel     {PortalVisualSettings.SetHomeKeyboardShortcut} Set Home     Esc Close" : "A Travel     X Set Home     B Close");
				}
			}
		}

		private static void ShowStatus(string message)
		{
			MessageHud instance = MessageHud.instance;
			if (Object.op_Implicit((Object)(object)instance))
			{
				instance.ShowMessage((MessageType)1, message, 0, ResolveHomeSprite(), false, false);
			}
		}

		internal static void ApplySelectorCursor(bool center)
		{
			if (Application.isBatchMode)
			{
				return;
			}
			if (!ZInput.IsMouseActive())
			{
				if (ZCursor.IsVisible)
				{
					ZCursor.Hide();
				}
				ZCursor.LockState = (CursorLockMode)1;
				return;
			}
			ZCursor.LockState = (CursorLockMode)0;
			if (!ZCursor.IsVisible)
			{
				ZCursor.Show();
			}
			if (center)
			{
				CenterPointer();
			}
		}

		private static void PrepareCursorWarp()
		{
			if (cursorWarpPrepared)
			{
				return;
			}
			cursorWarpPrepared = true;
			try
			{
				Type type = AccessTools.TypeByName("UnityEngine.InputSystem.Mouse");
				if (!(type == null))
				{
					inputMouseCurrentProperty = AccessTools.Property(type, "current");
					inputMouseWarpMethod = AccessTools.Method(type, "WarpCursorPosition", new Type[1] { typeof(Vector2) }, (Type[])null);
				}
			}
			catch (Exception ex)
			{
				Plugin.LogDebug("Input-system cursor warp preparation failed: " + ex.GetType().Name);
			}
		}

		private static void CenterPointer()
		{
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			Vector2 val = default(Vector2);
			((Vector2)(ref val))..ctor((float)Screen.width * 0.5f, (float)Screen.height * 0.5f);
			try
			{
				PrepareCursorWarp();
				object obj = inputMouseCurrentProperty?.GetValue(null, null);
				if (obj != null && inputMouseWarpMethod != null)
				{
					inputMouseWarpMethod.Invoke(obj, new object[1] { val });
					return;
				}
			}
			catch (Exception ex)
			{
				Plugin.LogDebug("Input-system cursor centering fell back to lock/unlock: " + ex.GetType().Name);
			}
			ZCursor.LockState = (CursorLockMode)1;
			ZCursor.LockState = (CursorLockMode)0;
			if (!ZCursor.IsVisible)
			{
				ZCursor.Show();
			}
		}

		private static void ReleaseSelectorCursor()
		{
			if (!Application.isBatchMode)
			{
				if (ZCursor.IsVisible)
				{
					ZCursor.Hide();
				}
				ZCursor.LockState = (CursorLockMode)1;
				GameCamera instance = GameCamera.instance;
				if (instance != null)
				{
					instance.UpdateMouseCapture();
				}
			}
		}

		internal static Sprite ResolveHomeSprite()
		{
			if (Object.op_Implicit((Object)(object)nativeHomeSprite))
			{
				return nativeHomeSprite;
			}
			if (nativeHomeSpriteSearchFrame == Time.frameCount)
			{
				return null;
			}
			nativeHomeSpriteSearchFrame = Time.frameCount;
			BuildUiPieceButton[] array = Resources.FindObjectsOfTypeAll<BuildUiPieceButton>();
			foreach (BuildUiPieceButton val in array)
			{
				if (Object.op_Implicit((Object)(object)val))
				{
					Image value = Traverse.Create((object)val).Field<Image>("m_favoriteStar").Value;
					if (Object.op_Implicit((Object)(object)value) && Object.op_Implicit((Object)(object)value.sprite))
					{
						nativeHomeSprite = value.sprite;
						return nativeHomeSprite;
					}
				}
			}
			return null;
		}

		private Button AddRow(string label, string biome, ZDOID portalId, Action action, Action setHome, bool isHome)
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Expected O, but got Unknown
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Expected O, but got Unknown
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_015a: Unknown result type (might be due to invalid IL or missing references)
			//IL_01eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_020a: Unknown result type (might be due to invalid IL or missing references)
			//IL_020b: Unknown result type (might be due to invalid IL or missing references)
			Button val = Menu.instance?.m_continueButton;
			if (!Object.op_Implicit((Object)(object)val))
			{
				return AddFallbackRow(label, biome, portalId, action, setHome, isHome);
			}
			GameObject val2 = Object.Instantiate<GameObject>(((Component)val).gameObject, content, false);
			((Object)val2).name = label;
			val2.SetActive(false);
			NormalizeRowRect(val2);
			Animator component = val2.GetComponent<Animator>();
			if (Object.op_Implicit((Object)(object)component))
			{
				((Behaviour)component).enabled = false;
			}
			Button component2 = val2.GetComponent<Button>();
			component2.onClick = new ButtonClickedEvent();
			((Selectable)component2).transition = (Transition)0;
			((Selectable)component2).interactable = action != null;
			if (action != null)
			{
				((UnityEvent)component2.onClick).AddListener((UnityAction)delegate
				{
					action();
				});
			}
			Image background = val2.GetComponent<Image>() ?? val2.AddComponent<Image>();
			((Graphic)background).color = Color.clear;
			((Graphic)background).raycastTarget = true;
			((Selectable)component2).targetGraphic = (Graphic)(object)background;
			LayoutElement obj = val2.GetComponent<LayoutElement>() ?? val2.AddComponent<LayoutElement>();
			obj.preferredHeight = PortalVisualSettings.RowHeight;
			obj.minWidth = 0f;
			obj.preferredWidth = -1f;
			obj.flexibleWidth = 1f;
			TMP_Text componentInChildren = val2.GetComponentInChildren<TMP_Text>(true);
			if (!Object.op_Implicit((Object)(object)componentInChildren))
			{
				Object.Destroy((Object)(object)val2);
				return AddFallbackRow(label, biome, portalId, action, setHome, isHome);
			}
			((Component)componentInChildren).gameObject.SetActive(false);
			TMP_Text nameText;
			TMP_Text biomeText;
			Image[] homeIcons;
			TMP_Text[] homeFallbacks;
			Transform rowVisualRoot = AddLabelGroup(val2.transform, label, biome, out nameText, out biomeText, out homeIcons, out homeFallbacks);
			Image[] nativeKnots = (from image in val2.GetComponentsInChildren<Image>(true)
				where Object.op_Implicit((Object)(object)image) && (Object)(object)image != (Object)(object)background && !homeIcons.Contains(image) && ((Object)image).name.IndexOf("Knot", StringComparison.OrdinalIgnoreCase) >= 0
				select image).ToArray();
			Image[] rowKnots = CreateNormalizedRowKnots(val2.transform, nativeKnots);
			PortalEntryHover portalEntryHover = val2.GetComponent<PortalEntryHover>() ?? val2.AddComponent<PortalEntryHover>();
			portalEntryHover.Initialize(nameText, biomeText, rowVisualRoot, background, rowKnots, homeIcons, homeFallbacks, portalId, action != null, setHome, isHome);
			rows.Add(val2);
			if (portalId != ZDOID.None)
			{
				portalRows.Add(portalEntryHover);
			}
			val2.SetActive(true);
			return component2;
		}

		private Button AddFallbackRow(string label, string biome, ZDOID portalId, Action action, Action setHome, bool isHome)
		{
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Expected O, but got Unknown
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_012d: Unknown result type (might be due to invalid IL or missing references)
			//IL_014c: Unknown result type (might be due to invalid IL or missing references)
			//IL_014d: 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_0114: Expected O, but got Unknown
			GameObject val = new GameObject(label, new Type[5]
			{
				typeof(RectTransform),
				typeof(Image),
				typeof(Button),
				typeof(LayoutElement),
				typeof(PortalEntryHover)
			});
			val.transform.SetParent(content, false);
			NormalizeRowRect(val);
			LayoutElement component = val.GetComponent<LayoutElement>();
			component.preferredHeight = PortalVisualSettings.RowHeight;
			component.minWidth = 0f;
			component.preferredWidth = -1f;
			component.flexibleWidth = 1f;
			Image component2 = val.GetComponent<Image>();
			((Graphic)component2).color = Color.clear;
			((Graphic)component2).raycastTarget = true;
			TMP_Text nameText;
			TMP_Text biomeText;
			Image[] homeIcons;
			TMP_Text[] homeFallbacks;
			Transform rowVisualRoot = AddLabelGroup(val.transform, label, biome, out nameText, out biomeText, out homeIcons, out homeFallbacks);
			Button component3 = val.GetComponent<Button>();
			((Selectable)component3).transition = (Transition)0;
			((Selectable)component3).interactable = action != null;
			if (action != null)
			{
				((UnityEvent)component3.onClick).AddListener((UnityAction)delegate
				{
					action();
				});
			}
			PortalEntryHover component4 = val.GetComponent<PortalEntryHover>();
			component4.Initialize(nameText, biomeText, rowVisualRoot, component2, Array.Empty<Image>(), homeIcons, homeFallbacks, portalId, action != null, setHome, isHome);
			rows.Add(val);
			if (portalId != ZDOID.None)
			{
				portalRows.Add(component4);
			}
			return component3;
		}

		private static Transform AddLabelGroup(Transform parent, string label, string biome, out TMP_Text nameText, out TMP_Text biomeText, out Image[] homeIcons, out TMP_Text[] homeFallbacks)
		{
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Expected O, but got Unknown
			//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_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: 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_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_0165: Unknown result type (might be due to invalid IL or missing references)
			//IL_016b: Expected O, but got Unknown
			//IL_01d1: 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_0237: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("BetterPortals Label Group", new Type[4]
			{
				typeof(RectTransform),
				typeof(HorizontalLayoutGroup),
				typeof(ContentSizeFitter),
				typeof(LayoutElement)
			});
			val.transform.SetParent(parent, false);
			val.GetComponent<LayoutElement>().ignoreLayout = true;
			RectTransform val2 = (RectTransform)val.transform;
			Vector2 val3 = default(Vector2);
			((Vector2)(ref val3))..ctor(0.5f, 0.5f);
			val2.anchorMax = val3;
			val2.anchorMin = val3;
			val2.pivot = new Vector2(0.5f, 0.5f);
			val2.anchoredPosition = Vector2.zero;
			HorizontalLayoutGroup component = val.GetComponent<HorizontalLayoutGroup>();
			((HorizontalOrVerticalLayoutGroup)component).spacing = 8f;
			((LayoutGroup)component).childAlignment = (TextAnchor)4;
			((HorizontalOrVerticalLayoutGroup)component).childControlWidth = true;
			((HorizontalOrVerticalLayoutGroup)component).childControlHeight = true;
			((HorizontalOrVerticalLayoutGroup)component).childForceExpandWidth = false;
			((HorizontalOrVerticalLayoutGroup)component).childForceExpandHeight = false;
			ContentSizeFitter component2 = val.GetComponent<ContentSizeFitter>();
			component2.horizontalFit = (FitMode)2;
			component2.verticalFit = (FitMode)2;
			Image val4 = AddHomeIcon(val.transform, "Left");
			TextMeshProUGUI val5 = AddText(val.transform, "★", PortalVisualSettings.HomeIconSize, (FontStyles)0, PortalVisualSettings.EntryColor);
			((Object)val5).name = "Left Home Favorite Star Fallback";
			((Component)val5).gameObject.SetActive(false);
			GameObject val6 = new GameObject("Portal Name and Biome", new Type[3]
			{
				typeof(RectTransform),
				typeof(VerticalLayoutGroup),
				typeof(ContentSizeFitter)
			});
			val6.transform.SetParent(val.transform, false);
			VerticalLayoutGroup component3 = val6.GetComponent<VerticalLayoutGroup>();
			((HorizontalOrVerticalLayoutGroup)component3).spacing = 0f;
			((LayoutGroup)component3).childAlignment = (TextAnchor)4;
			((HorizontalOrVerticalLayoutGroup)component3).childControlWidth = true;
			((HorizontalOrVerticalLayoutGroup)component3).childControlHeight = true;
			((HorizontalOrVerticalLayoutGroup)component3).childForceExpandWidth = false;
			((HorizontalOrVerticalLayoutGroup)component3).childForceExpandHeight = false;
			ContentSizeFitter component4 = val6.GetComponent<ContentSizeFitter>();
			component4.horizontalFit = (FitMode)2;
			component4.verticalFit = (FitMode)2;
			nameText = (TMP_Text)(object)AddText(val6.transform, label, PortalVisualSettings.EntryFontSize, (FontStyles)0, PortalVisualSettings.EntryColor);
			biomeText = (TMP_Text)(object)AddText(val6.transform, string.IsNullOrWhiteSpace(biome) ? string.Empty : ("(" + biome + ")"), PortalVisualSettings.BiomeFontSize, (FontStyles)0, PortalVisualSettings.BiomeColor);
			Image val7 = AddHomeIcon(val.transform, "Right");
			TextMeshProUGUI val8 = AddText(val.transform, "★", PortalVisualSettings.HomeIconSize, (FontStyles)0, PortalVisualSettings.EntryColor);
			((Object)val8).name = "Right Home Favorite Star Fallback";
			((Component)val8).gameObject.SetActive(false);
			homeIcons = (Image[])(object)new Image[2] { val4, val7 };
			TMP_Text[] array = (TMP_Text[])(object)new TextMeshProUGUI[2] { val5, val8 };
			homeFallbacks = array;
			return val.transform;
		}

		private static Image AddHomeIcon(Transform parent, string side)
		{
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject(side + " Home Favorite Star", new Type[3]
			{
				typeof(RectTransform),
				typeof(Image),
				typeof(LayoutElement)
			});
			val.transform.SetParent(parent, false);
			Image component = val.GetComponent<Image>();
			component.sprite = ResolveHomeSprite();
			component.preserveAspect = true;
			((Graphic)component).raycastTarget = false;
			((Graphic)component).color = Color.white;
			return component;
		}

		private static void NormalizeRowRect(GameObject row)
		{
			//IL_003a: 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_0040: 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_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: 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)
			LayoutGroup[] components = row.GetComponents<LayoutGroup>();
			for (int i = 0; i < components.Length; i++)
			{
				((Behaviour)components[i]).enabled = false;
			}
			AspectRatioFitter component = row.GetComponent<AspectRatioFitter>();
			if (Object.op_Implicit((Object)(object)component))
			{
				((Behaviour)component).enabled = false;
			}
			RectTransform val = (RectTransform)row.transform;
			Vector2 val2 = default(Vector2);
			((Vector2)(ref val2))..ctor(0.5f, 1f);
			val.anchorMax = val2;
			val.anchorMin = val2;
			val.pivot = new Vector2(0.5f, 0.5f);
			val.anchoredPosition = Vector2.zero;
			val.sizeDelta = new Vector2(0f, PortalVisualSettings.RowHeight);
			((Transform)val).localScale = Vector3.one;
			((Transform)val).localRotation = Quaternion.identity;
			ContentSizeFitter component2 = row.GetComponent<ContentSizeFitter>();
			if (Object.op_Implicit((Object)(object)component2))
			{
				((Behaviour)component2).enabled = false;
			}
		}

		private static Image[] CreateNormalizedRowKnots(Transform row, Image[] nativeKnots)
		{
			Image[] array = (nativeKnots ?? Array.Empty<Image>()).Where((Image image) => Object.op_Implicit((Object)(object)image) && Object.op_Implicit((Object)(object)image.sprite)).ToArray();
			if (array.Length == 0)
			{
				return Array.Empty<Image>();
			}
			Image[] array2 = array.OrderBy((Image image) => row.InverseTransformPoint(((Transform)((Graphic)image).rectTransform).position).x).ToArray();
			Image left = ((IEnumerable<Image>)array).FirstOrDefault((Func<Image, bool>)((Image image) => ((Object)image).name.IndexOf("left", StringComparison.OrdinalIgnoreCase) >= 0)) ?? array2.First();
			Image val = ((IEnumerable<Image>)array).FirstOrDefault((Func<Image, bool>)((Image image) => (Object)(object)image != (Object)(object)left && ((Object)image).name.IndexOf("right", StringComparison.OrdinalIgnoreCase) >= 0)) ?? ((IEnumerable<Image>)array2).LastOrDefault((Func<Image, bool>)((Image image) => (Object)(object)image != (Object)(object)left)) ?? left;
			foreach (Image val2 in nativeKnots)
			{
				if (Object.op_Implicit((Object)(object)val2))
				{
					((Behaviour)val2).enabled = false;
					((Graphic)val2).raycastTarget = false;
					((Component)val2).gameObject.SetActive(false);
				}
			}
			return (Image[])(object)new Image[2]
			{
				CreateRowKnot(row, "BetterPortals Left Knot", left.sprite),
				CreateRowKnot(row, "BetterPortals Right Knot", val.sprite)
			};
		}

		private static Image CreateRowKnot(Transform parent, string name, Sprite sprite)
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject(name, new Type[3]
			{
				typeof(RectTransform),
				typeof(Image),
				typeof(LayoutElement)
			});
			val.transform.SetParent(parent, false);
			val.GetComponent<LayoutElement>().ignoreLayout = true;
			Image component = val.GetComponent<Image>();
			component.sprite = sprite;
			component.type = (Type)0;
			component.preserveAspect = true;
			((Graphic)component).raycastTarget = false;
			Color ornamentColor = PortalVisualSettings.OrnamentColor;
			((Graphic)component).color = new Color(ornamentColor.r, ornamentColor.g, ornamentColor.b, 0f);
			return component;
		}

		private static TextMeshProUGUI AddText(Transform parent, string value, float size, FontStyles style, Color color)
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Expected O, but got Unknown
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			if (!TryResolveNativeTextStyle(out var font, out var material))
			{
				throw new InvalidOperationException("No loaded Valheim TextMesh Pro font and material were available for the portal selector.");
			}
			GameObject val = new GameObject("Label", new Type[1] { typeof(RectTransform) });
			val.SetActive(false);
			val.transform.SetParent(parent, false);
			TextMeshProUGUI obj = val.AddComponent<TextMeshProUGUI>();
			((TMP_Text)obj).font = font;
			((TMP_Text)obj).fontSharedMaterial = material;
			((TMP_Text)obj).text = value;
			((TMP_Text)obj).fontSize = size;
			((TMP_Text)obj).fontStyle = style;
			((TMP_Text)obj).alignment = (TextAlignmentOptions)514;
			((TMP_Text)obj).richText = false;
			((Graphic)obj).color = color;
			((Graphic)obj).raycastTarget = false;
			((TMP_Text)obj).overflowMode = (TextOverflowModes)1;
			((TMP_Text)obj).textWrappingMode = (TextWrappingModes)0;
			((TMP_Text)obj).outlineColor = Color32.op_Implicit(PortalVisualSettings.OutlineColor);
			((TMP_Text)obj).outlineWidth = PortalVisualSettings.OutlineWidth;
			val.SetActive(true);
			return obj;
		}

		private static bool TryResolveNativeTextStyle(out TMP_FontAsset font, out Material material)
		{
			if (Object.op_Implicit((Object)(object)nativeFont) && Object.op_Implicit((Object)(object)nativeFontMaterial))
			{
				font = nativeFont;
				material = nativeFontMaterial;
				return true;
			}
			TMP_Text[] array = new TMP_Text[6];
			Menu instance = Menu.instance;
			object obj;
			if (instance == null)
			{
				obj = null;
			}
			else
			{
				Button continueButton = instance.m_continueButton;
				obj = ((continueButton != null) ? ((Component)continueButton).GetComponentInChildren<TMP_Text>(true) : null);
			}
			array[0] = (TMP_Text)obj;
			array[1] = Menu.instance?.lastSaveText;
			array[2] = (TMP_Text)(Hud.instance?.m_hoverName);
			array[3] = Hud.instance?.m_buildSelection;
			array[4] = MessageHud.instance?.m_messageText;
			array[5] = TextInput.instance?.m_topic;
			TMP_Text val = ((IEnumerable<TMP_Text>)(object)array).FirstOrDefault((Func<TMP_Text, bool>)IsUsableTextTemplate) ?? ((IEnumerable<TMP_Text>)Resources.FindObjectsOfTypeAll<TMP_Text>()).FirstOrDefault((Func<TMP_Text, bool>)IsUsableTextTemplate);
			if (Object.op_Implicit((Object)(object)val))
			{
				nativeFont = val.font;
				nativeFontMaterial = (Object.op_Implicit((Object)(object)val.fontSharedMaterial) ? val.fontSharedMaterial : ((TMP_Asset)val.font).material);
			}
			if (!Object.op_Implicit((Object)(object)nativeFont) || !Object.op_Implicit((Object)(object)nativeFontMaterial))
			{
				TMP_FontAsset val2 = ((IEnumerable<TMP_FontAsset>)Resources.FindObjectsOfTypeAll<TMP_FontAsset>()).FirstOrDefault((Func<TMP_FontAsset, bool>)((TMP_FontAsset candidate) => Object.op_Implicit((Object)(object)candidate) && Object.op_Implicit((Object)(object)((TMP_Asset)candidate).material)));
				if (Object.op_Implicit((Object)(object)val2))
				{
					nativeFont = val2;
					nativeFontMaterial = ((TMP_Asset)val2).material;
				}
			}
			font = nativeFont;
			material = nativeFontMaterial;
			if (Object.op_Implicit((Object)(object)font))
			{
				return Object.op_Implicit((Object)(object)material);
			}
			return false;
		}

		private static bool IsUsableTextTemplate(TMP_Text candidate)
		{
			if (Object.op_Implicit((Object)(object)candidate) && Object.op_Implicit((Object)(object)candidate.font))
			{
				if (!Object.op_Implicit((Object)(object)candidate.fontSharedMaterial))
				{
					return Object.op_Implicit((Object)(object)((TMP_Asset)candidate.font).material);
				}
				return true;
			}
			return false;
		}

		private static void AddSeparator(Transform parent)
		{
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("Amber Divider", new Type[3]
			{
				typeof(RectTransform),
				typeof(Image),
				typeof(LayoutElement)
			});
			val.transform.SetParent(parent, false);
			Image component = val.GetComponent<Image>();
			((Graphic)component).color = new Color(1f, 0.48f, 0.12f, 0.72f);
			((Graphic)component).raycastTarget = false;
			val.GetComponent<LayoutElement>().preferredHeight = 2f;
		}

		private static void ConfigureScaler(CanvasScaler scaler)
		{
			//IL_001c: 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_0034: Unknown result type (might be due to invalid IL or missing references)
			Menu instance = Menu.instance;
			CanvasScaler val = ((instance != null) ? ((Component)instance).GetComponentInParent<CanvasScaler>() : null);
			if (Object.op_Implicit((Object)(object)val))
			{
				scaler.uiScaleMode = val.uiScaleMode;
				scaler.referenceResolution = val.referenceResolution;
				scaler.screenMatchMode = val.screenMatchMode;
				scaler.matchWidthOrHeight = val.matchWidthOrHeight;
				scaler.referencePixelsPerUnit = val.referencePixelsPerUnit;
				scaler.dynamicPixelsPerUnit = val.dynamicPixelsPerUnit;
			}
			scaler.uiScaleMode = (ScaleMode)0;
			if (!Object.op_Implicit((Object)(object)((Component)scaler).GetComponent<GuiScaler>()))
			{
				((Component)scaler).gameObject.AddComponent<GuiScaler>();
			}
		}

		private void SelectDestination(ZDOID destination)
		{
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			if (!travelPending && nonce != 0L && SourceIsUsable())
			{
				travelPending = true;
				travelDeadline = Time.realtimeSinceStartup + 3f;
				if (Object.op_Implicit((Object)(object)canvasGroup))
				{
					canvasGroup.interactable = false;
					canvasGroup.blocksRaycasts = false;
				}
				if (!PortalRpc.AskTravel(source, destination, nonce))
				{
					RequestClose(invalidateRequest: true);
				}
				else
				{
					BeginFadeOut(resetWhenHidden: false);
				}
			}
		}

		private bool SourceIsUsable()
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)Player.m_localPlayer == (Object)null || source == ZDOID.None || !PortalRpc.TryPortal(source, out var portal))
			{
				return false;
			}
			Vector3 position = portal.GetPosition();
			float num = 9.375f;
			if (Object.op_Implicit((Object)(object)sourcePortal))
			{
				ZNetView component = ((Component)sourcePortal).GetComponent<ZNetView>();
				if (!Object.op_Implicit((Object)(object)component) || !component.IsValid() || component.GetZDO() == null || component.GetZDO().m_uid != source)
				{
					return false;
				}
				if (Object.op_Implicit((Object)(object)sourcePortal.m_proximityRoot))
				{
					position = sourcePortal.m_proximityRoot.position;
				}
				num = PortalRanges.ClientDistance(sourcePortal);
			}
			return Vector3.Distance(((Component)Player.m_localPlayer).transform.position, position) <= num;
		}

		private static bool AnotherModalIsVisible()
		{
			if (!Menu.IsVisible() && !TextInput.IsVisible() && !InventoryGui.IsVisible() && !StoreGui.IsVisible() && !Minimap.IsOpen())
			{
				return Console.IsVisible();
			}
			return true;
		}

		private void RequestClose(bool invalidateRequest)
		{
			if (invalidateRequest)
			{
				nonce = 0L;
				travelPending = false;
				pendingTeleport = false;
				resetAfterFade = true;
			}
			BeginFadeOut(invalidateRequest);
		}

		private void BeginFadeOut(bool resetWhenHidden)
		{
			resetAfterFade |= resetWhenHidden;
			if (!Object.op_Implicit((Object)(object)panel) || !panel.activeSelf)
			{
				if (pendingTeleport)
				{
					PerformPendingTeleport();
				}
				else if (resetAfterFade)
				{
					ResetSession(0f);
				}
				return;
			}
			if (Object.op_Implicit((Object)(object)canvasGroup))
			{
				canvasGroup.interactable = false;
				canvasGroup.blocksRaycasts = false;
			}
			fadeTarget = 0f;
			cursorCenterFrames = 0;
			ReleaseSelectorCursor();
		}

		private void AdvanceFade()
		{
			if (Object.op_Implicit((Object)(object)canvasGroup))
			{
				float num = ((fadeTarget > canvasGroup.alpha) ? PortalVisualSettings.FadeInSeconds : PortalVisualSettings.FadeOutSeconds);
				canvasGroup.alpha = Mathf.MoveTowards(canvasGroup.alpha, fadeTarget, Time.unscaledDeltaTime / num);
				if (fadeTarget <= 0f && Mathf.Approximately(canvasGroup.alpha, 0f))
				{
					FinishHidden();
				}
			}
		}

		private void FinishHidden()
		{
			if (Object.op_Implicit((Object)(object)panel))
			{
				EventSystem current = EventSystem.current;
				GameObject val = ((current != null) ? current.currentSelectedGameObject : null);
				if (Object.op_Implicit((Object)(object)val) && val.transform.IsChildOf(panel.transform))
				{
					EventSystem.current.SetSelectedGameObject((GameObject)null);
				}
				panel.SetActive(false);
				previousMouseInput = null;
				mouseChoiceArmed = false;
				ReleaseSelectorCursor();
				if (pendingTeleport)
				{
					PerformPendingTeleport();
				}
				else if (resetAfterFade)
				{
					ResetSession(0f);
				}
			}
		}

		private void PerformPendingTeleport()
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_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)
			if (!pendingTeleport)
			{
				return;
			}
			Player localPlayer = Player.m_localPlayer;
			Vector3 val = pendingPosition;
			Quaternion val2 = pendingRotation;
			ResetSession(1.5f);
			GameCamera instance = GameCamera.instance;
			if (instance != null)
			{
				instance.UpdateMouseCapture();
			}
			if (!Object.op_Implicit((Object)(object)localPlayer))
			{
				return;
			}
			BypassOnce = true;
			try
			{
				((Character)localPlayer).TeleportTo(val + val2 * Vector3.forward * 2f, val2, true);
			}
			finally
			{
				BypassOnce = false;
			}
		}

		private void ResetSession(float cooldown)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			ClearDeferredBegin();
			source = ZDOID.None;
			sourcePortal = null;
			nonce = 0L;
			requestStarted = 0f;
			sessionDeadline = 0f;
			travelDeadline = 0f;
			travelPending = false;
			directoryReady = false;
			pendingTeleport = false;
			resetAfterFade = false;
			nextOpenAllowed = Time.realtimeSinceStartup + cooldown;
			if (!Object.op_Implicit((Object)(object)panel) || !panel.activeSelf)
			{
				GameCamera instance = GameCamera.instance;
				if (instance != null)
				{
					instance.UpdateMouseCapture();
				}
			}
		}

		private static void Stretch(RectTransform rect)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			rect.anchorMin = Vector2.zero;
			rect.anchorMax = Vector2.one;
			Vector2 offsetMin = (rect.offsetMax = Vector2.zero);
			rect.offsetMin = offsetMin;
		}
	}
	internal sealed class PortalEntryHover : MonoBehaviour, IPointerEnterHandler, IEventSystemHandler, IPointerExitHandler, IPointerClickHandler, ISelectHandler, IDeselectHandler
	{
		private TMP_Text label;

		private TMP_Text biomeLabel;

		private Transform visualRoot;

		private Image background;

		private Image[] knots = Array.Empty<Image>();

		private float[] knotSides = Array.Empty<float>();

		private Image[] homeIcons = Array.Empty<Image>();

		private TMP_Text[] homeFallbacks = Array.Empty<TMP_Text>();

		private LayoutElement[] homeIconLayouts = Array.Empty<LayoutElement>();

		private LayoutElement rowLayout;

		private Color normalColor;

		private Action setHomeAction;

		private bool isHome;

		private bool interactive;

		private bool selected;

		private bool pointerInside;

		private bool animating;

		private bool knotsVisible;

		private float currentScale = 1f;

		private float startScale = 1f;

		private float targetScale = 1f;

		private float transitionStarted;

		private float transitionDuration;

		private readonly Vector3[] rectCorners = (Vector3[])(object)new Vector3[4];

		internal ZDOID PortalId { get; private set; }

		internal bool PointerInside => pointerInside;

		internal void Initialize(TMP_Text rowLabel, TMP_Text rowBiomeLabel, Transform rowVisualRoot, Image rowBackground, Image[] rowKnots, Image[] rowHomeIcons, TMP_Text[] rowHomeFallbacks, ZDOID portalId, bool canInteract, Action onSetHome, bool home)
		{
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			label = rowLabel;
			biomeLabel = rowBiomeLabel;
			visualRoot = rowVisualRoot;
			background = rowBackground;
			knots = rowKnots ?? Array.Empty<Image>();
			PrepareKnots();
			homeIcons = rowHomeIcons ?? Array.Empty<Image>();
			homeFallbacks = rowHomeFallbacks ?? Array.Empty<TMP_Text>();
			homeIconLayouts = homeIcons.Select((Image icon) => (!Object.op_Implicit((Object)(object)icon)) ? null : ((Component)icon).GetComponent<LayoutElement>()).ToArray();
			rowLayout = ((Component)this).GetComponent<LayoutElement>();
			PortalId = portalId;
			setHomeAction = onSetHome;
			isHome = home;
			interactive = canInteract;
			currentScale = (startScale = (targetScale = 1f));
			ApplyScale(1f);
			ApplyVisualSettings();
		}

		internal void ApplyVisualSettings()
		{
			//IL_003f: 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_0044: 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_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_01dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a4: Unknown result type (might be due to invalid IL or missing references)
			if (!Object.op_Implicit((Object)(object)label) || !Object.op_Implicit((Object)(object)background))
			{
				return;
			}
			normalColor = (Color)(interactive ? PortalVisualSettings.EntryColor : new Color(0.55f, 0.55f, 0.53f, 1f));
			PortalController.ApplyTextAppearance(label, PortalVisualSettings.EntryFontSize, normalColor);
			if (Object.op_Implicit((Object)(object)biomeLabel))
			{
				PortalController.ApplyTextAppearance(biomeLabel, PortalVisualSettings.BiomeFontSize, PortalVisualSettings.BiomeColor);
				((Component)biomeLabel).gameObject.SetActive(interactive && PortalVisualSettings.ShowBiomeSubtitle && !string.IsNullOrWhiteSpace(biomeLabel.text));
			}
			Sprite sprite = PortalController.ResolveHomeSprite();
			for (int i = 0; i < homeIcons.Length; i++)
			{
				Image val = homeIcons[i];
				if (Object.op_Implicit((Object)(object)val))
				{
					if (!Object.op_Implicit((Object)(object)val.sprite))
					{
						val.sprite = sprite;
					}
					float homeIconSize = PortalVisualSettings.HomeIconSize;
					LayoutElement val2 = ((i < homeIconLayouts.Length) ? homeIconLayouts[i] : null);
					if (Object.op_Implicit((Object)(object)val2))
					{
						val2.preferredWidth = homeIconSize;
						val2.preferredHeight = homeIconSize;
					}
					((Component)val).gameObject.SetActive(isHome && Object.op_Implicit((Object)(object)val.sprite));
				}
			}
			bool flag = homeIcons.Any((Image icon) => Object.op_Implicit((Object)(object)icon) && Object.op_Implicit((Object)(object)icon.sprite));
			TMP_Text[] array = homeFallbacks;
			foreach (TMP_Text val3 in array)
			{
				if (Object.op_Implicit((Object)(object)val3))
				{
					PortalController.ApplyTextAppearance(val3, PortalVisualSettings.HomeIconSize, PortalVisualSettings.EntryColor);
					((Component)val3).gameObject.SetActive(isHome && !flag);
				}
			}
			((Graphic)background).color = Color.clear;
			if (Object.op_Implicit((Object)(object)rowLayout))
			{
				float num2 = ((Object.op_Implicit((Object)(object)biomeLabel) && ((Component)biomeLabel).gameObject.activeSelf) ? (PortalVisualSettings.EntryFontSize + PortalVisualSettings.BiomeFontSize + 6f) : (PortalVisualSettings.EntryFontSize + 10f));
				rowLayout.preferredHeight = Mathf.Max(PortalVisualSettings.RowHeight, num2);
			}
			SetHighlighted(pointerInside || selected);
		}

		public void OnPointerEnter(PointerEventData eventData)
		{
			if (interactive)
			{
				pointerInside = true;
				SetHighlighted(pointerInside || selected);
			}
		}

		public void OnPointerExit(PointerEventData eventData)
		{
			if (interactive)
			{
				pointerInside = false;
				SetHighlighted(pointerInside || selected);
			}
		}

		public void OnPointerClick(PointerEventData eventData)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Invalid comparison between Unknown and I4
			if (interactive && setHomeAction != null && (int)eventData.button == 1)
			{
				setHomeAction();
				((AbstractEventData)eventData).Use();
			}
		}

		internal void SetAsHome()
		{
			if (interactive)
			{
				setHomeAction?.Invoke();
			}
		}

		internal void Activate()
		{
			if (interactive)
			{
				Button component = ((Component)this).GetComponent<Button>();
				if (component != null)
				{
					((UnityEvent)component.onClick).Invoke();
				}
			}
		}

		internal void SetHome(bool home)
		{
			if (isHome != home)
			{
				isHome = home;
				ApplyVisualSettings();
			}
		}

		public void OnSelect(BaseEventData eventData)
		{
			selected = interactive;
			SetHighlighted(pointerInside || selected);
		}

		public void OnDeselect(BaseEventData eventData)
		{
			selected = false;
			SetHighlighted(pointerInside || selected);
		}

		private void Update()
		{
			if (animating && Object.op_Implicit((Object)(object)visualRoot))
			{
				float num = Mathf.Clamp01((Time.unscaledTime - transitionStarted) / Mathf.Max(0.001f, transitionDuration));
				float num2 = Mathf.SmoothStep(0f, 1f, num);
				currentScale = Mathf.Lerp(startScale, targetScale, num2);
				ApplyScale(currentScale);
				if (num >= 1f)
				{
					animating = false;
				}
			}
		}

		private void LateUpdate()
		{
			if (knotsVisible)
			{
				PositionKnots();
			}
		}

		private void OnDisable()
		{
			pointerInside = false;
			selected = false;
			animating = false;
			currentScale = (startScale = (targetScale = 1f));
			ApplyScale(1f);
			ApplyKnots(highlighted: false);
		}

		private void SetHighlighted(bool highlighted)
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			if (Object.op_Implicit((Object)(object)label) && Object.op_Implicit((Object)(object)background))
			{
				((Graphic)label).color = normalColor;
				((Graphic)background).color = Color.clear;
				float num = ((highlighted && interactive) ? PortalVisualSettings.HoverScale : 1f);
				if (!Mathf.Approximately(num, targetScale) || (!animating && !Mathf.Approximately(currentScale, num)))
				{
					startScale = currentScale;
					targetScale = num;
					transitionStarted = Time.unscaledTime;
					transitionDuration = ((num > currentScale) ? PortalVisualSettings.HoverExpandSeconds : PortalVisualSettings.HoverContractSeconds);
					animating = true;
				}
				ApplyKnots(highlighted && interactive);
			}
		}

		private void ApplyScale(float scale)
		{
			//IL_0013: 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)
			if (Object.op_Implicit((Object)(object)visualRoot))
			{
				visualRoot.localScale = Vector3.one * scale;
			}
			if (knotsVisible)
			{
				PositionKnots();
			}
		}

		private void PrepareKnots()
		{
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: 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_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_0102: Unknown result type (might be due to invalid IL or missing references)
			//IL_0117: Unknown result type (might be due to invalid IL or missing references)
			//IL_011e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0145: Unknown result type (might be due to invalid IL or missing references)
			//IL_017c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0187: Unknown result type (might be due to invalid IL or missing references)
			knotSides = new float[knots.Length];
			Vector2 val2 = default(Vector2);
			for (int i = 0; i < knots.Length; i++)
			{
				Image val = knots[i];
				if (Object.op_Implicit((Object)(object)val))
				{
					RectTransform rectTransform = ((Graphic)val).rectTransform;
					string text = ((Object)val).name ?? string.Empty;
					float num = ((text.IndexOf("left", StringComparison.OrdinalIgnoreCase) >= 0) ? (-1f) : ((text.IndexOf("right", StringComparison.OrdinalIgnoreCase) >= 0) ? 1f : ((i % 2 == 0) ? (-1f) : 1f)));
					knotSides[i] = num;
					((Transform)rectTransform).SetParent(((Component)this).transform, false);
					((Vector2)(ref val2))..ctor(0.5f, 0.5f);
					rectTransform.anchorMax = val2;
					rectTransform.anchorMin = val2;
					rectTransform.pivot = new Vector2(0.5f, 0.5f);
					? val3;
					if (!Object.op_Implicit((Object)(object)val.sprite))
					{
						val3 = new Vector2(36f, 18f);
					}
					else
					{
						Rect rect = val.sprite.rect;
						val3 = ((Rect)(ref rect)).size;
					}
					Vector2 val4 = (Vector2)val3;
					float num2 = ((val4.y > 0.01f) ? (val4.x / val4.y) : 2f);
					rectTransform.sizeDelta = new Vector2(Mathf.Clamp(18f * num2, 18f, 64f), 18f);
					val.type = (Type)0;
					val.preserveAspect = true;
					((Transform)rectTransform).localScale = new Vector3((num < 0f) ? 1f : (-1f), 1f, 1f);
					((Transform)rectTransform).localRotation = Quaternion.identity;
					((Transform)rectTransform).SetAsLastSibling();
				}
			}
		}

		private void PositionKnots()
		{
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			if (knots.Length == 0 || !Object.op_Implicit((Object)(object)visualRoot) || !TryGetRenderedTitleBounds(out var left, out var right, out var centerY))
			{
				return;
			}
			for (int i = 0; i < knots.Length; i++)
			{
				Image val = knots[i];
				if (Object.op_Implicit((Object)(object)val))
				{
					RectTransform rectTransform = ((Graphic)val).rectTransform;
					float num = ((i < knotSides.Length && knotSides[i] < 0f) ? (-1f) : 1f);
					Rect rect = rectTransform.rect;
					float num2 = Mathf.Abs(((Rect)(ref rect)).width) * 0.5f;
					float num3 = ((num < 0f) ? (left - PortalVisualSettings.RowKnotGap - num2) : (right + PortalVisualSettings.RowKnotGap + num2));
					rectTransform.anchoredPosition = new Vector2(num3, centerY);
				}
			}
		}

		private bool TryGetRenderedTitleBounds(out float left, out float right, out float centerY)
		{
			left = float.PositiveInfinity;
			right = float.NegativeInfinity;
			float bottom = float.PositiveInfinity;
			float top = float.NegativeInfinity;
			Image[] array = homeIcons;
			foreach (Image val in array)
			{
				if (Object.op_Implicit((Object)(object)val) && ((Component)val).gameObject.activeSelf)
				{
					IncludeRectBounds(((Graphic)val).rectTransform, ref left, ref right, ref bottom, ref top);
				}
			}
			TMP_Text[] array2 = homeFallbacks;
			foreach (TMP_Text val2 in array2)
			{
				if (Object.op_Implicit((Object)(object)val2) && ((Component)val2).gameObject.activeSelf)
				{
					IncludeTextBounds(val2, ref left, ref right, ref bottom, ref top);
				}
			}
			if (Object.op_Implicit((Object)(object)label) && ((Component)label).gameObject.activeSelf)
			{
				IncludeTextBounds(label, ref left, ref right, ref bottom, ref top);
			}
			centerY = ((float.IsInfinity(bottom) || float.IsInfinity(top)) ? 0f : ((bottom + top) * 0.5f));
			if (!float.IsInfinity(left) && !float.IsInfinity(right))
			{
				return right > left;
			}
			return false;
		}

		private void IncludeTextBounds(TMP_Text text, ref float left, ref float right, ref float bottom, ref float top)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: 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)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			text.ForceMeshUpdate(false, false);
			Bounds textBounds = text.textBounds;
			if (((Bounds)(ref textBounds)).size.x <= 0.01f || ((Bounds)(ref textBounds)).size.y <= 0.01f)
			{
				IncludeRectBounds(text.rectTransform, ref left, ref right, ref bottom, ref top);
				return;
			}
			IncludePoint(text.transform.TransformPoint(new Vector3(((Bounds)(ref textBounds)).min.x, ((Bounds)(ref textBounds)).min.y, 0f)), ref left, ref right, ref bottom, ref top);
			IncludePoint(text.transform.TransformPoint(new Vector3(((Bounds)(ref textBounds)).max.x, ((Bounds)(ref textBounds)).max.y, 0f)), ref left, ref right, ref bottom, ref top);
		}

		private void IncludeRectBounds(RectTransform rect, ref float left, ref float right, ref float bottom, ref float top)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			rect.GetWorldCorners(rectCorners);
			for (int i = 0; i < rectCorners.Length; i++)
			{
				IncludePoint(rectCorners[i], ref left, ref right, ref bottom, ref top);
			}
		}

		private void IncludePoint(Vector3 worldPoint, ref float left, ref float right, ref float bottom, ref float top)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: 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)
			Vector3 val = ((Component)this).transform.InverseTransformPoint(worldPoint);
			left = Mathf.Min(left, val.x);
			right = Mathf.Max(right, val.x);
			bottom = Mathf.Min(bottom, val.y);
			top = Mathf.Max(top, val.y);
		}

		private void ApplyKnots(bool highlighted)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: 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_0064: Unknown result type (might be due to invalid IL or missing references)
			Color ornamentColor = PortalVisualSettings.OrnamentColor;
			bool showRowKnots = PortalVisualSettings.ShowRowKnots;
			knotsVisible = showRowKnots && highlighted;
			Image[] array = knots;
			foreach (Image val in array)
			{
				if (Object.op_Implicit((Object)(object)val))
				{
					((Component)val).gameObject.SetActive(showRowKnots);
					((Graphic)val).color = new Color(ornamentColor.r, ornamentColor.g, ornamentColor.b, knotsVisible ? ornamentColor.a : 0f);
				}
			}
			if (knotsVisible)
			{
				PositionKnots();
			}
		}
	}
}