using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Text;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using JoeyBadManners.Wayfinder.Core;
using JoeyBadManners.Wayfinder.Discovery;
using JoeyBadManners.Wayfinder.HUD;
using JoeyBadManners.Wayfinder.Icons;
using JoeyBadManners.Wayfinder.Management;
using JoeyBadManners.Wayfinder.Map;
using JoeyBadManners.Wayfinder.Patches;
using JoeyBadManners.Wayfinder.Pins;
using JoeyBadManners.Wayfinder.Tracking;
using TMPro;
using UnityEngine;
using UnityEngine.SceneManagement;
using UnityEngine.UI;

[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: CompilationRelaxations(8)]
[assembly: AssemblyVersion("0.0.0.0")]
namespace JoeyBadManners.Wayfinder
{
	[BepInPlugin("com.joeybadmanners.wayfinder", "Joey's Wayfinder", "1.0.0")]
	public sealed class WayfinderPlugin : BaseUnityPlugin
	{
		public const string PluginGuid = "com.joeybadmanners.wayfinder";

		public const string PluginName = "Joey's Wayfinder";

		public const string PluginVersion = "1.0.0";

		private const float DiscoverySliceSpacing = 0.005f;

		private const double SlowDiscoveryWarningMs = 4.0;

		private long _loadedWorldUid = long.MinValue;

		private float _nextBootstrapCheck;

		private float _nextDiscoverySliceTime;

		private int _discoverySlicePhase;

		internal static WayfinderPlugin Instance { get; private set; }

		internal static Harmony Harmony { get; private set; }

		internal static WayfinderConfig Settings { get; private set; }

		internal static RuntimeIconRegistry Icons { get; private set; }

		internal static WayfinderPinDatabase Pins { get; private set; }

		internal static WayfinderPinManagementService PinManager { get; private set; }

		internal static WayfinderPinManagerUI PinManagerUI { get; private set; }

		internal static WayfinderMapController Map { get; private set; }

		internal static ResourceDiscovery Discovery { get; private set; }

		internal static AreaScanner Scanner { get; private set; }

		internal static StructureDiscovery Structures { get; private set; }

		internal static TraderDiscovery Traders { get; private set; }

		internal static SpawnerDiscovery Spawners { get; private set; }

		internal static RunestoneDiscovery Runestones { get; private set; }

		internal static PortalDiscovery Portals { get; private set; }

		internal static VehicleDiscovery Vehicles { get; private set; }

		internal static EnemySightingDiscovery Sightings { get; private set; }

		internal static OreDiagnosticScanner OreDiagnostics { get; private set; }

		internal static DiscoveryArtConsistency ArtConsistency { get; private set; }

		internal static TrackedBeaconController TrackingBeacons { get; private set; }

		internal static WayfinderCompassHUD CompassHUD { get; private set; }

		internal static GravestoneIntegration Gravestones { get; private set; }

		private void Awake()
		{
			//IL_0221: Unknown result type (might be due to invalid IL or missing references)
			//IL_022b: Expected O, but got Unknown
			Instance = this;
			Settings = new WayfinderConfig(((BaseUnityPlugin)this).Config);
			Icons = new RuntimeIconRegistry(((BaseUnityPlugin)this).Logger, Settings);
			Pins = new WayfinderPinDatabase(((BaseUnityPlugin)this).Logger, Settings);
			PinManager = new WayfinderPinManagementService(Settings, Pins);
			Map = new WayfinderMapController(((BaseUnityPlugin)this).Logger, Settings, Icons, Pins, PinManager);
			PinManagerUI = new WayfinderPinManagerUI(((BaseUnityPlugin)this).Logger, Settings, PinManager, Icons);
			Discovery = new ResourceDiscovery(((BaseUnityPlugin)this).Logger, Settings, Icons, Pins);
			Scanner = new AreaScanner(((BaseUnityPlugin)this).Logger, Settings, Discovery);
			Structures = new StructureDiscovery(((BaseUnityPlugin)this).Logger, Settings, Pins, Icons);
			Traders = new TraderDiscovery(((BaseUnityPlugin)this).Logger, Settings, Pins);
			Spawners = new SpawnerDiscovery(((BaseUnityPlugin)this).Logger, Settings, Pins, Icons);
			Runestones = new RunestoneDiscovery(((BaseUnityPlugin)this).Logger, Settings, Pins);
			Portals = new PortalDiscovery(((BaseUnityPlugin)this).Logger, Settings, Pins);
			Vehicles = new VehicleDiscovery(((BaseUnityPlugin)this).Logger, Settings, Pins);
			Sightings = new EnemySightingDiscovery(((BaseUnityPlugin)this).Logger, Settings, Icons, Pins);
			OreDiagnostics = new OreDiagnosticScanner(((BaseUnityPlugin)this).Logger, Settings);
			ArtConsistency = new DiscoveryArtConsistency(((BaseUnityPlugin)this).Logger, Settings, Icons, Pins);
			TrackingBeacons = new TrackedBeaconController(((BaseUnityPlugin)this).Logger, Settings, PinManager);
			CompassHUD = new WayfinderCompassHUD(((BaseUnityPlugin)this).Logger, Settings, PinManager, Icons);
			Gravestones = new GravestoneIntegration(((BaseUnityPlugin)this).Logger, Settings, Icons);
			Harmony = new Harmony("com.joeybadmanners.wayfinder");
			Harmony.PatchAll(typeof(WayfinderPlugin).Assembly);
			int num = WayfinderGameplayInputCaptureInstaller.Install(Harmony);
			((BaseUnityPlugin)this).Logger.LogInfo((object)"Joey's Wayfinder 1.0.0 loaded.");
			((BaseUnityPlugin)this).Logger.LogInfo((object)("Client-side Wayfinder systems initialized. No server installation is required. Runtime-safe input hooks installed: " + num + "."));
		}

		private void Update()
		{
			if (PinManagerUI != null)
			{
				PinManagerUI.TickInput();
			}
			if (TrackingBeacons != null)
			{
				TrackingBeacons.Tick();
			}
			if (Vehicles != null)
			{
				Vehicles.Tick();
			}
			if (Gravestones != null)
			{
				Gravestones.Tick();
			}
			if (Map != null)
			{
				Map.RefreshDynamicVehiclePositions();
				Map.Tick();
			}
			TickDiscoveryWorkSlice();
			if (Time.unscaledTime < _nextBootstrapCheck)
			{
				return;
			}
			_nextBootstrapCheck = Time.unscaledTime + 1f;
			try
			{
				BootstrapWorldState();
				BootstrapIconRegistry();
				Discovery.RepairKnownResourceIcons();
				Discovery.ApplyLiveFilterCleanup();
				if (ArtConsistency != null)
				{
					ArtConsistency.Tick();
				}
				Portals.Tick();
				OreDiagnostics.Tick();
				Pins.Tick();
			}
			catch (Exception ex)
			{
				if (Settings.DebugLogging.Value)
				{
					((BaseUnityPlugin)this).Logger.LogWarning((object)("Bootstrap check failed: " + ex));
				}
			}
		}

		private void TickDiscoveryWorkSlice()
		{
			if (Time.unscaledTime < _nextDiscoverySliceTime)
			{
				return;
			}
			_nextDiscoverySliceTime = Time.unscaledTime + 0.005f;
			double previousFrameMs = (double)Time.unscaledDeltaTime * 1000.0;
			double adaptiveDiscoveryBudgetMs = GetAdaptiveDiscoveryBudgetMs(previousFrameMs);
			if (adaptiveDiscoveryBudgetMs <= 0.0)
			{
				return;
			}
			string text = string.Empty;
			bool flag = false;
			long timestamp = Stopwatch.GetTimestamp();
			try
			{
				switch (_discoverySlicePhase)
				{
				case 0:
					text = "AreaScanner";
					if (Scanner != null)
					{
						flag = Scanner.TickBudgeted(adaptiveDiscoveryBudgetMs);
					}
					break;
				case 1:
					text = "EnemySightings";
					if (Sightings != null)
					{
						flag = Sightings.TickBudgeted(adaptiveDiscoveryBudgetMs);
					}
					break;
				case 2:
					text = "Structures";
					if (Structures != null)
					{
						flag = Structures.TickBudgeted(adaptiveDiscoveryBudgetMs);
					}
					break;
				case 3:
					text = "Spawners";
					if (Spawners != null)
					{
						flag = Spawners.TickBudgeted(adaptiveDiscoveryBudgetMs);
					}
					break;
				case 4:
					text = "Runestones";
					if (Runestones != null)
					{
						flag = Runestones.TickBudgeted(adaptiveDiscoveryBudgetMs);
					}
					break;
				default:
					text = "Traders";
					if (Traders != null)
					{
						flag = Traders.TickBudgeted(adaptiveDiscoveryBudgetMs);
					}
					break;
				}
			}
			catch (Exception ex)
			{
				if (Settings != null && Settings.DebugLogging.Value)
				{
					((BaseUnityPlugin)this).Logger.LogWarning((object)("Discovery slice " + text + " failed: " + ex));
				}
			}
			finally
			{
				_discoverySlicePhase = (_discoverySlicePhase + 1) % 6;
			}
			if (Settings == null || !Settings.DebugLogging.Value)
			{
				return;
			}
			double num = (double)(Stopwatch.GetTimestamp() - timestamp) * 1000.0 / (double)Stopwatch.Frequency;
			if (num >= 4.0)
			{
				string text2 = string.Empty;
				if (text == "AreaScanner" && Scanner != null)
				{
					text2 = Scanner.GetPerfDetail();
				}
				((BaseUnityPlugin)this).Logger.LogWarning((object)("JW PERF: " + text + " slice took " + num.ToString("0.00") + " ms (budget=" + adaptiveDiscoveryBudgetMs.ToString("0.00") + "ms, pending=" + flag + ", prevFrame=" + previousFrameMs.ToString("0.00") + "ms)." + text2));
			}
		}

		private static double GetAdaptiveDiscoveryBudgetMs(double previousFrameMs)
		{
			if (previousFrameMs >= 40.0)
			{
				return 0.0;
			}
			if (previousFrameMs >= 25.0)
			{
				return 0.75;
			}
			if (previousFrameMs >= 18.0)
			{
				return 1.0;
			}
			if (previousFrameMs >= 14.0)
			{
				return 1.4;
			}
			if (previousFrameMs >= 10.0)
			{
				return 2.0;
			}
			return 2.75;
		}

		private void BootstrapWorldState()
		{
			if ((Object)(object)ZNet.instance == (Object)null)
			{
				CloseWorldSessionIfNeeded();
				return;
			}
			long num = 0L;
			try
			{
				num = ZNet.instance.GetWorldUID();
			}
			catch
			{
				CloseWorldSessionIfNeeded();
				return;
			}
			if (num == 0)
			{
				CloseWorldSessionIfNeeded();
			}
			else if ((num != _loadedWorldUid || Pins.WorldUid != num) && Pins.LoadWorld(num, ZNet.instance.GetWorldName()))
			{
				_loadedWorldUid = num;
				LiveDiscoveryRegistry.ResetForWorld(num);
				PhysicalSpawnerIndex.Reset();
				LiveDiscoveryRegistry.SyncFromLoadedLocations();
				if (Vehicles != null)
				{
					Vehicles.ResetSession();
				}
				if (Portals != null)
				{
					Portals.ResetSession();
				}
				if (Traders != null)
				{
					Traders.ResetSession();
				}
				if (ArtConsistency != null)
				{
					ArtConsistency.ResetSession();
				}
				if (Gravestones != null)
				{
					Gravestones.ResetSession();
				}
				Map.ForceRefresh();
			}
		}

		private void CloseWorldSessionIfNeeded()
		{
			if ((_loadedWorldUid != long.MinValue || Pins.WorldUid != 0) && Pins.UnloadWorld())
			{
				if (TrackingBeacons != null)
				{
					TrackingBeacons.Clear();
				}
				if (Vehicles != null)
				{
					Vehicles.ClearSession();
				}
				if (Portals != null)
				{
					Portals.ClearSession();
				}
				if (Traders != null)
				{
					Traders.ResetSession();
				}
				if (ArtConsistency != null)
				{
					ArtConsistency.ResetSession();
				}
				if (Gravestones != null)
				{
					Gravestones.ClearSession();
				}
				LiveDiscoveryRegistry.ResetForWorld(0L);
				PhysicalSpawnerIndex.Reset();
				_loadedWorldUid = long.MinValue;
				Map.ForceRefresh();
			}
		}

		private void BootstrapIconRegistry()
		{
			if (!((Object)(object)ObjectDB.instance == (Object)null) && ObjectDB.instance.m_items != null && ObjectDB.instance.m_items.Count != 0 && (!Icons.IsBuilt || Icons.IsDirty))
			{
				Icons.Build(ObjectDB.instance);
				Discovery.RepairKnownResourceIcons(force: true);
				Map.ForceRefresh();
			}
		}

		private void LateUpdate()
		{
			if (Map != null && (Object)(object)Minimap.instance != (Object)null)
			{
				Map.EnforceNativeShipMarkerVisibility(Minimap.instance);
				Map.EnforceVanillaPersistentPinUiVisibility(Minimap.instance);
			}
		}

		private void OnGUI()
		{
			if (Map != null)
			{
				Map.DrawLargeMapNameLabels();
			}
			if (CompassHUD != null)
			{
				CompassHUD.Draw();
			}
			if (PinManagerUI != null)
			{
				PinManagerUI.DrawMapButton();
				PinManagerUI.Draw();
			}
		}

		private void OnDestroy()
		{
			try
			{
				if (TrackingBeacons != null)
				{
					TrackingBeacons.Clear();
				}
				if (Pins != null)
				{
					Pins.Save();
				}
				if (Harmony != null)
				{
					Harmony.UnpatchSelf();
				}
			}
			catch
			{
			}
		}
	}
}
namespace JoeyBadManners.Wayfinder.Core
{
	internal sealed class WayfinderConfig
	{
		internal readonly ConfigEntry<bool> Enabled;

		internal readonly ConfigEntry<bool> DebugLogging;

		internal readonly ConfigEntry<bool> VerboseRuntimeLogging;

		internal readonly ConfigEntry<bool> SupersedeVanillaPinVisuals;

		internal readonly ConfigEntry<float> BossPinScale;

		internal readonly ConfigEntry<bool> RightClickRemovesWayfinderPins;

		internal readonly ConfigEntry<bool> SuppressRemovedAutoPins;

		internal readonly ConfigEntry<string> HiddenCategories;

		internal readonly ConfigEntry<KeyboardShortcut> PinManagerToggleKey;

		internal readonly ConfigEntry<bool> ShowPinManagerMapButton;

		internal readonly ConfigEntry<bool> ReplaceVanillaPersistentPinControls;

		internal readonly ConfigEntry<float> NearbyDiscoveryListRadius;

		internal readonly ConfigEntry<bool> OverrideVanillaBossNames;

		internal readonly ConfigEntry<string> BossNameOverrides;

		internal readonly ConfigEntry<bool> ResourceClustering;

		internal readonly ConfigEntry<float> ResourceClusterLinkDistance;

		internal readonly ConfigEntry<bool> ShowClusterCounts;

		internal readonly ConfigEntry<bool> InteractionDiscovery;

		internal readonly ConfigEntry<bool> AreaScanning;

		internal readonly ConfigEntry<float> AreaScanRadius;

		internal readonly ConfigEntry<bool> MatchAreaScanToMapRevealRadius;

		internal readonly ConfigEntry<bool> ScanUnexploredAreas;

		internal readonly ConfigEntry<bool> EnemySightings;

		internal readonly ConfigEntry<float> EnemySightingRadius;

		internal readonly ConfigEntry<float> EnemySightingClusterDistance;

		internal readonly ConfigEntry<bool> ScanDungeonContents;

		internal readonly ConfigEntry<bool> AutoPinStone;

		internal readonly ConfigEntry<bool> AutoPinBranches;

		internal readonly ConfigEntry<bool> AutoPinFlint;

		internal readonly ConfigEntry<bool> AutoPinDandelions;

		internal readonly ConfigEntry<bool> RememberGeneratedStructures;

		internal readonly ConfigEntry<float> StructureDiscoveryRadius;

		internal readonly ConfigEntry<bool> RememberPhysicalSpawners;

		internal readonly ConfigEntry<bool> AutoPinSurtlingSpawners;

		internal readonly ConfigEntry<float> SpawnerDiscoveryRadius;

		internal readonly ConfigEntry<bool> SuppressSightingsInsideSpawnerRadius;

		internal readonly ConfigEntry<float> SpawnerSightingSuppressionPadding;

		internal readonly ConfigEntry<float> SpawnerSightingExclusionRadius;

		internal readonly ConfigEntry<bool> RememberPortals;

		internal readonly ConfigEntry<float> PortalDiscoveryRadius;

		internal readonly ConfigEntry<float> PortalSyncInterval;

		internal readonly ConfigEntry<bool> PortalNameFromTag;

		internal readonly ConfigEntry<bool> ShowPortalNamesOnLargeMap;

		internal readonly ConfigEntry<bool> RemoveDestroyedPortals;

		internal readonly ConfigEntry<bool> CompassEnabled;

		internal readonly ConfigEntry<bool> CompassShowDistance;

		internal readonly ConfigEntry<bool> CompassShowNames;

		internal readonly ConfigEntry<bool> CompassShowCardinals;

		internal readonly ConfigEntry<bool> CompassClampOffscreenTracked;

		internal readonly ConfigEntry<float> CompassMaxDistance;

		internal readonly ConfigEntry<float> CompassWidth;

		internal readonly ConfigEntry<float> CompassTopOffset;

		internal readonly ConfigEntry<float> CompassArcDegrees;

		internal readonly ConfigEntry<float> CompassOpacity;

		internal readonly ConfigEntry<int> MaxTrackedPins;

		internal readonly ConfigEntry<bool> WaypointEnabled;

		internal readonly ConfigEntry<bool> WaypointShowVerticalDifference;

		internal readonly ConfigEntry<bool> BeaconEnabled;

		internal readonly ConfigEntry<float> BeaconOpacity;

		internal readonly ConfigEntry<float> BeaconHeight;

		internal readonly ConfigEntry<float> BeaconWidth;

		internal readonly ConfigEntry<bool> TrackBoats;

		internal readonly ConfigEntry<bool> TrackCarts;

		internal readonly ConfigEntry<bool> KeepLastKnownVehiclePosition;

		internal readonly ConfigEntry<bool> RemoveDestroyedVehicles;

		internal readonly ConfigEntry<float> VehicleDiscoveryRadius;

		internal readonly ConfigEntry<float> VehicleUpdateInterval;

		internal readonly ConfigEntry<float> LastKnownVehicleOpacity;

		internal readonly ConfigEntry<bool> ShowLastKnownVehicleBadge;

		internal readonly ConfigEntry<bool> ShowVehicleNamesOnLargeMap;

		internal readonly ConfigEntry<bool> ExpandedExploration;

		internal readonly ConfigEntry<float> WalkingExploreMultiplier;

		internal readonly ConfigEntry<float> SailingExploreMultiplier;

		internal readonly ConfigEntry<float> AreaScanInterval;

		internal readonly ConfigEntry<float> EnemySightingInterval;

		internal readonly ConfigEntry<float> StaticDiscoveryInterval;

		internal readonly ConfigEntry<float> SpawnerIndexCacheSeconds;

		internal readonly ConfigEntry<float> PersistenceFlushInterval;

		internal readonly ConfigEntry<float> MapVisualRefreshInterval;

		internal WayfinderConfig(ConfigFile config)
		{
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			Enabled = config.Bind<bool>("00 - General", "Enabled", true, "Enable Joey's Wayfinder.");
			DebugLogging = config.Bind<bool>("00 - General", "DebugLogging", false, "Write additional diagnostic information to the BepInEx log.");
			VerboseRuntimeLogging = config.Bind<bool>("00 - General", "VerboseRuntimeLogging", false, "With DebugLogging enabled, also write high-frequency scan/sync/save/input diagnostics. Off by default to keep normal debug logs readable.");
			SupersedeVanillaPinVisuals = config.Bind<bool>("10 - Map", "SupersedeVanillaPinVisuals", true, "Keep vanilla pin data intact but let Wayfinder replace supported pin visuals.");
			BossPinScale = config.Bind<float>("10 - Map", "BossPinScale", 1.35f, "Visual scale used for Vegvisir-discovered boss pins when Wayfinder trophy styling is active.");
			RightClickRemovesWayfinderPins = config.Bind<bool>("10 - Map", "RightClickRemovesWayfinderPins", true, "Allow normal map right-click removal to delete Wayfinder pins too. Managed portal pins are protected from accidental map removal; delete them deliberately from the Pins panel instead.");
			SuppressRemovedAutoPins = config.Bind<bool>("10 - Map", "SuppressRemovedAutoPins", true, "When you manually remove an automatically discovered Wayfinder pin, remember that choice so the same scanned objects do not immediately reappear.");
			HiddenCategories = config.Bind<string>("11 - Pin Manager", "HiddenCategories", string.Empty, "Comma-separated Wayfinder categories hidden from map rendering. The in-map pin manager edits this automatically.");
			PinManagerToggleKey = config.Bind<KeyboardShortcut>("11 - Pin Manager", "ToggleKey", new KeyboardShortcut((KeyCode)288, (KeyCode[])(object)new KeyCode[0]), "Fallback shortcut for opening or closing the Wayfinder Pin Manager while the large map is open.");
			ShowPinManagerMapButton = config.Bind<bool>("11 - Pin Manager", "ShowMapButton", true, "Show Joey's Wayfinder compact controls on the large map.");
			ReplaceVanillaPersistentPinControls = config.Bind<bool>("11 - Pin Manager", "ReplaceVanillaPersistentPinControls", true, "Hide Valheim's old persistent pin-type strip and old Add/Cross-off/Remove pin hints while the large map is open. Wayfinder's compact controls replace that workflow. Vanilla middle-mouse ping and Visible to other players are intentionally preserved.");
			NearbyDiscoveryListRadius = config.Bind<float>("11 - Pin Manager", "NearbyDiscoveryListRadius", 100f, "In the compact Pins view, automatically discovered Resources/Sightings/Habitats farther than this are hidden from the LIST only when search is empty. Their map markers remain visible. Searching by name shows matching results at any remembered distance.");
			OverrideVanillaBossNames = config.Bind<bool>("11 - Pin Manager", "OverrideVanillaBossNames", true, "Let Wayfinder control the visible labels of native/Vegvisir boss pins without changing the underlying vanilla pin data.");
			BossNameOverrides = config.Bind<string>("11 - Pin Manager", "BossNameOverrides", "Eikthyr=Eikthyr;TheElder=The Elder;Bonemass=Bonemass;Moder=Moder;Yagluth=Yagluth;Queen=The Queen;Fader=Fader", "Wayfinder display names for native boss pins. The in-map manager edits this automatically.");
			ResourceClustering = config.Bind<bool>("20 - Discovery", "ResourceClustering", true, "Merge nearby observations of the SAME resource into connected clusters.");
			ResourceClusterLinkDistance = config.Bind<float>("20 - Discovery", "ResourceClusterLinkDistance", 6f, "A resource joins a cluster when it is within this many meters of ANY member of that same-resource cluster. Chained members stay one cluster.");
			ShowClusterCounts = config.Bind<bool>("20 - Discovery", "ShowClusterCounts", true, "Show counts such as Raspberries x5 or Copper x2.");
			InteractionDiscovery = config.Bind<bool>("20 - Discovery", "InteractionDiscovery", true, "Remember resources/locations after legitimate interaction or discovery.");
			AreaScanning = config.Bind<bool>("20 - Discovery", "AreaScanning", false, "Optionally scan the surrounding area for configured map targets. Off by default. Buried Silver is always interaction-only and is never revealed by area scanning.");
			AreaScanRadius = config.Bind<float>("20 - Discovery", "AreaScanRadius", 100f, "Manual area scan radius in meters. Used only when MatchAreaScanToMapRevealRadius is disabled.");
			MatchAreaScanToMapRevealRadius = config.Bind<bool>("20 - Discovery", "MatchAreaScanToMapRevealRadius", true, "Match Wayfinder's area scan radius to the player's current map reveal/exploration radius. On by default so Wayfinder only remembers visible things within the same area the map is revealing.");
			ScanUnexploredAreas = config.Bind<bool>("20 - Discovery", "ScanUnexploredAreas", false, "Allow automatic discovery to create pins in unexplored map fog. Off by default.");
			EnemySightings = config.Bind<bool>("20 - Discovery", "EnemySightings", false, "Track ordinary enemy sightings/hotspots. Off by default to avoid clutter.");
			EnemySightingRadius = config.Bind<float>("20 - Discovery", "EnemySightingRadius", 80f, "Maximum range in meters for optional enemy sighting discovery.");
			EnemySightingClusterDistance = config.Bind<float>("20 - Discovery", "EnemySightingClusterDistance", 20f, "Same-enemy sightings within this connected distance merge into one activity hotspot.");
			ScanDungeonContents = config.Bind<bool>("20 - Discovery", "ScanDungeonContents", false, "Allow resource discovery/pinning inside generated dungeon interiors. Off by default because the dungeon entrance pin is usually enough.");
			AutoPinStone = config.Bind<bool>("21 - Resource Filters", "Stone", false, "Automatically pin loose Stone sources. Off by default to avoid map clutter.");
			AutoPinBranches = config.Bind<bool>("21 - Resource Filters", "Branches", false, "Automatically pin branch/basic Wood pickups. Off by default to avoid map clutter.");
			AutoPinFlint = config.Bind<bool>("21 - Resource Filters", "Flint", false, "Automatically pin Flint pickups. Off by default to avoid map clutter.");
			AutoPinDandelions = config.Bind<bool>("21 - Resource Filters", "Dandelions", false, "Automatically pin Dandelions. Off by default to avoid map clutter.");
			RememberGeneratedStructures = config.Bind<bool>("22 - Structures", "RememberGeneratedStructures", true, "Remember generated overworld structures/locations as Wayfinder POIs after they are actually loaded/discovered.");
			StructureDiscoveryRadius = config.Bind<float>("22 - Structures", "DiscoveryRadius", 80f, "Maximum distance in meters for remembering loaded generated structures around the player.");
			RememberPhysicalSpawners = config.Bind<bool>("23 - Spawners", "RememberPhysicalSpawners", true, "Remember persistent physical world spawners after they are legitimately loaded/discovered, using the dedicated Wayfinder spawner icon.");
			AutoPinSurtlingSpawners = config.Bind<bool>("23 - Spawners", "SurtlingSpawners", true, "Automatically remember Surtling fire geyser/spawner locations using the dedicated Wayfinder spawner marker.");
			SpawnerDiscoveryRadius = config.Bind<float>("23 - Spawners", "DiscoveryRadius", 80f, "Maximum distance in meters for remembering loaded physical spawners around the player.");
			SuppressSightingsInsideSpawnerRadius = config.Bind<bool>("23 - Spawners", "SuppressSightingsInsideSpawnerRadius", true, "Suppress ordinary enemy-sighting/hotspot pins for creatures currently inside the radius of a physical spawner that can actually spawn that creature.");
			SpawnerSightingSuppressionPadding = config.Bind<float>("23 - Spawners", "SightingSuppressionPadding", 0f, "Optional extra meters added to the physical spawner radius when suppressing matching spawned-enemy sightings.");
			SpawnerSightingExclusionRadius = config.Bind<float>("23 - Spawners", "SightingExclusionRadius", 25f, "Blanket no-sighting bubble around every known physical spawner. Any enemy sighting inside this many meters is suppressed so the spawner marker remains readable.");
			RememberPortals = config.Bind<bool>("24 - Portals", "RememberPortals", true, "Remember loaded player/world portals as dedicated Wayfinder Portal pins.");
			PortalDiscoveryRadius = config.Bind<float>("24 - Portals", "DiscoveryRadius", 120f, "Maximum distance in meters for remembering and live-syncing loaded portals around the player.");
			PortalSyncInterval = config.Bind<float>("24 - Portals", "SyncInterval", 1f, "Seconds between portal tag/connection-state sync passes. Portal renames normally update within this interval.");
			PortalNameFromTag = config.Bind<bool>("24 - Portals", "NamePinsFromTag", true, "Automatically keep discovered portal pin names synchronized to the portal's actual in-game tag. Untagged portals are named Portal unless that individual portal has a manual Wayfinder name override.");
			ShowPortalNamesOnLargeMap = config.Bind<bool>("24 - Portals", "ShowNamesOnLargeMap", true, "Show remembered portal names/tags beside their Wayfinder icons on the large map. Small minimap labels stay hidden to avoid clutter.");
			RemoveDestroyedPortals = config.Bind<bool>("24 - Portals", "RemoveDestroyedPortals", true, "Remove the remembered Wayfinder portal record when the client actually observes that portal being destroyed.");
			CompassEnabled = config.Bind<bool>("30 - Compass", "Enabled", true, "Enable the Wayfinder horizontal compass HUD.");
			CompassShowDistance = config.Bind<bool>("30 - Compass", "ShowDistance", true, "Show live meter distance beside tracked compass markers.");
			CompassShowNames = config.Bind<bool>("30 - Compass", "ShowNames", false, "Show tracked pin names on the compass. Off by default to keep the HUD compact.");
			CompassShowCardinals = config.Bind<bool>("30 - Compass", "ShowCardinals", true, "Show N/E/S/W and bearing ticks on the compass band.");
			CompassClampOffscreenTracked = config.Bind<bool>("30 - Compass", "ClampOffscreenTracked", true, "Keep tracked targets outside the visible compass arc pinned to the left/right edge so you still know which way to turn.");
			CompassMaxDistance = config.Bind<float>("30 - Compass", "MaxDistance", 0f, "Legacy compatibility setting. Explicitly tracked Wayfinder targets are always shown at any practical world distance; this value no longer culls tracked compass markers.");
			CompassWidth = config.Bind<float>("30 - Compass", "Width", 720f, "Compass width in screen pixels.");
			CompassTopOffset = config.Bind<float>("30 - Compass", "TopOffset", 18f, "Distance in screen pixels from the top edge.");
			CompassArcDegrees = config.Bind<float>("30 - Compass", "VisibleArcDegrees", 180f, "Horizontal bearing arc represented across the compass width.");
			CompassOpacity = config.Bind<float>("30 - Compass", "Opacity", 0.72f, "Opacity of the compass background/band. Marker colors remain more vivid.");
			MaxTrackedPins = config.Bind<int>("30 - Compass", "MaxTrackedPins", 5, "Maximum number of Wayfinder pins that may be explicitly tracked at once. Tracking is separate from deletion and vanilla map pings.");
			WaypointEnabled = config.Bind<bool>("40 - Waypoint", "Enabled", true, "Enable Wayfinder tracked-target navigation features.");
			WaypointShowVerticalDifference = config.Bind<bool>("40 - Waypoint", "ShowVerticalDifference", true, "Show target elevation difference for tracked targets when supported by the HUD.");
			BeaconEnabled = config.Bind<bool>("40 - Waypoint", "BeaconEnabled", true, "Show subtle vertical beams for explicitly tracked Wayfinder pins.");
			BeaconOpacity = config.Bind<float>("40 - Waypoint", "BeaconOpacity", 1f, "Opacity of tracked-target beacon beams.");
			BeaconHeight = config.Bind<float>("40 - Waypoint", "BeaconHeight", 100f, "Height in meters of each tracked-target beacon beam.");
			BeaconWidth = config.Bind<float>("40 - Waypoint", "BeaconWidth", 1f, "Width in meters of each tracked-target beacon beam.");
			TrackBoats = config.Bind<bool>("50 - Vehicles", "TrackBoats", true, "Remember legitimately encountered loaded boats as dynamic Wayfinder vehicle markers. They can then be explicitly tracked as T1-T5 targets.");
			TrackCarts = config.Bind<bool>("50 - Vehicles", "TrackCarts", true, "Remember legitimately encountered loaded carts as dynamic Wayfinder vehicle markers. They can then be explicitly tracked as T1-T5 targets.");
			KeepLastKnownVehiclePosition = config.Bind<bool>("50 - Vehicles", "KeepLastKnownPosition", true, "Keep the most recently known map position when a remembered boat/cart leaves loaded range.");
			RemoveDestroyedVehicles = config.Bind<bool>("50 - Vehicles", "RemoveDestroyedVehicles", true, "Remove a remembered dynamic vehicle marker when Wayfinder observes that boat/cart being actually destroyed.");
			VehicleDiscoveryRadius = config.Bind<float>("50 - Vehicles", "DiscoveryRadius", 160f, "Maximum horizontal distance in meters for first remembering a loaded boat/cart. Once a specific vehicle is remembered, Wayfinder keeps updating it anywhere that same stable vehicle remains loaded.");
			VehicleUpdateInterval = config.Bind<float>("50 - Vehicles", "UpdateInterval", 0.5f, "Seconds between dynamic boat/cart position updates. Lower values are smoother but scan more often.");
			LastKnownVehicleOpacity = config.Bind<float>("50 - Vehicles", "LastKnownOpacity", 0.58f, "Opacity multiplier for remembered boat/cart markers that are no longer currently observed. Also dims their tracked compass icon/beam so last-known positions are not mistaken for live positions.");
			ShowLastKnownVehicleBadge = config.Bind<bool>("50 - Vehicles", "ShowLastKnownBadge", true, "Show a small amber clock-ring badge on map markers that represent a boat/cart's last known position rather than a currently observed live vehicle.");
			ShowVehicleNamesOnLargeMap = config.Bind<bool>("50 - Vehicles", "ShowNamesOnLargeMap", true, "Show remembered boat/cart names beside their Wayfinder icons on the large map. Small minimap labels stay hidden to avoid clutter.");
			ExpandedExploration = config.Bind<bool>("60 - Exploration", "Enabled", false, "Enable custom map exploration radii. Off by default.");
			WalkingExploreMultiplier = config.Bind<float>("60 - Exploration", "WalkingMultiplier", 1f, "Map exploration multiplier while travelling on land.");
			SailingExploreMultiplier = config.Bind<float>("60 - Exploration", "SailingMultiplier", 1f, "Map exploration multiplier while sailing.");
			AreaScanInterval = config.Bind<float>("90 - Performance", "AreaScanInterval", 4f, "Seconds between optional area scans. Higher values reduce scan spikes while preserving discovery behavior.");
			EnemySightingInterval = config.Bind<float>("90 - Performance", "EnemySightingInterval", 4f, "Seconds between optional enemy-sighting scans. Higher values reduce CPU cost.");
			StaticDiscoveryInterval = config.Bind<float>("90 - Performance", "StaticDiscoveryInterval", 5f, "Seconds between structure/spawner discovery passes.");
			SpawnerIndexCacheSeconds = config.Bind<float>("90 - Performance", "SpawnerIndexCacheSeconds", 10f, "How long physical-spawner footprint data is cached before being rebuilt.");
			PersistenceFlushInterval = config.Bind<float>("90 - Performance", "PersistenceFlushInterval", 4f, "Batch automatic Wayfinder disk writes for this many seconds. Logout/quit still forces an immediate save.");
			MapVisualRefreshInterval = config.Bind<float>("90 - Performance", "MapVisualRefreshInterval", 0.25f, "Minimum seconds between full Wayfinder map-visual refresh passes.");
		}
	}
	internal static class WayfinderDiscoveryRadius
	{
		internal static float GetEffectiveAreaScanRadius(WayfinderConfig config)
		{
			if (config == null)
			{
				return 100f;
			}
			if (!config.MatchAreaScanToMapRevealRadius.Value)
			{
				return Mathf.Max(1f, config.AreaScanRadius.Value);
			}
			Minimap instance = Minimap.instance;
			float num = (((Object)(object)instance != (Object)null) ? instance.m_exploreRadius : config.AreaScanRadius.Value);
			if (config.ExpandedExploration.Value && (Object)(object)Player.m_localPlayer != (Object)null)
			{
				float num2 = (((Character)Player.m_localPlayer).IsAttachedToShip() ? config.SailingExploreMultiplier.Value : config.WalkingExploreMultiplier.Value);
				num *= Mathf.Max(0f, num2);
			}
			return Mathf.Max(1f, num);
		}
	}
}
namespace JoeyBadManners.Wayfinder.Discovery
{
	internal sealed class AreaScanner
	{
		private sealed class ResourceComponentCacheEntry
		{
			internal Collider Collider;

			internal Pickable Pickable;

			internal MineRock MineRock;

			internal MineRock5 MineRock5;

			internal DropOnDestroyed DropOnDestroyed;

			internal float ExpiresAt;
		}

		private sealed class VisualOreCacheEntry
		{
			internal Collider Collider;

			internal GameObject Source;

			internal string ResourcePrefab;

			internal float ExpiresAt;
		}

		private static readonly MethodInfo IsExploredMethod = AccessTools.Method(typeof(Minimap), "IsExplored", new Type[1] { typeof(Vector3) }, (Type[])null);

		private readonly ManualLogSource _log;

		private readonly WayfinderConfig _config;

		private readonly ResourceDiscovery _resources;

		private float _nextScanTime;

		private float _nextColliderCachePrune;

		private readonly Collider[] _colliderBuffer = (Collider[])(object)new Collider[4096];

		private readonly HashSet<string> _visualOreObjects = new HashSet<string>();

		private readonly HashSet<int> _scanPickables = new HashSet<int>();

		private readonly HashSet<int> _scanMineRocks = new HashSet<int>();

		private readonly HashSet<int> _scanMineRocks5 = new HashSet<int>();

		private readonly HashSet<int> _scanDestroyedDrops = new HashSet<int>();

		private readonly Dictionary<int, ResourceComponentCacheEntry> _resourceColliderCache = new Dictionary<int, ResourceComponentCacheEntry>();

		private readonly Dictionary<int, VisualOreCacheEntry> _visualOreCache = new Dictionary<int, VisualOreCacheEntry>();

		private bool _scanInProgress;

		private int _scanCursor;

		private int _nearbyColliderCount;

		private Vector3 _scanCenter;

		private float _scanRadius;

		private float _scanRadiusSq;

		private int _scanObserved;

		private int _scanPickableCount;

		private int _scanMineRockCount;

		private int _scanMineRock5Count;

		private int _scanDestroyedDropCount;

		private int _scanVisualOreCount;

		private int _lastProcessedThisSlice;

		private double _lastQueryMs;

		internal AreaScanner(ManualLogSource log, WayfinderConfig config, ResourceDiscovery resources)
		{
			_log = log;
			_config = config;
			_resources = resources;
		}

		internal void Tick()
		{
			TickBudgeted(1000.0);
		}

		internal bool TickBudgeted(double budgetMs)
		{
			if (!_config.Enabled.Value || !_config.AreaScanning.Value || (Object)(object)Player.m_localPlayer == (Object)null)
			{
				ResetActiveScan();
				return false;
			}
			if (!_config.ScanDungeonContents.Value && ((Character)Player.m_localPlayer).InInterior())
			{
				ResetActiveScan();
				return false;
			}
			long startTimestamp = DiscoveryWorkBudget.Start();
			if (!_scanInProgress)
			{
				if (Time.unscaledTime < _nextScanTime)
				{
					return false;
				}
				BeginScan();
				if (DiscoveryWorkBudget.Expired(startTimestamp, budgetMs))
				{
					return true;
				}
			}
			_lastProcessedThisSlice = 0;
			while (_scanCursor < _nearbyColliderCount)
			{
				Collider collider = _colliderBuffer[_scanCursor++];
				_lastProcessedThisSlice++;
				ProcessCollider(collider);
				if (DiscoveryWorkBudget.Expired(startTimestamp, budgetMs))
				{
					return true;
				}
			}
			if (DiscoveryWorkBudget.Expired(startTimestamp, budgetMs))
			{
				return true;
			}
			FinishScan();
			return false;
		}

		internal string GetPerfDetail()
		{
			if (_scanInProgress)
			{
				return " query=" + _lastQueryMs.ToString("0.00") + "ms processed=" + _scanCursor + "/" + _nearbyColliderCount + " yielded=true";
			}
			return " query=" + _lastQueryMs.ToString("0.00") + "ms processed=" + _nearbyColliderCount + "/" + _nearbyColliderCount + " yielded=false";
		}

		private void BeginScan()
		{
			//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_00c8: Unknown result type (might be due to invalid IL or missing references)
			_nextScanTime = Time.unscaledTime + Mathf.Max(1f, _config.AreaScanInterval.Value);
			_scanCenter = ((Component)Player.m_localPlayer).transform.position;
			_scanRadius = WayfinderDiscoveryRadius.GetEffectiveAreaScanRadius(_config);
			_scanRadiusSq = _scanRadius * _scanRadius;
			_scanObserved = 0;
			_scanPickableCount = 0;
			_scanMineRockCount = 0;
			_scanMineRock5Count = 0;
			_scanDestroyedDropCount = 0;
			_scanVisualOreCount = 0;
			_scanPickables.Clear();
			_scanMineRocks.Clear();
			_scanMineRocks5.Clear();
			_scanDestroyedDrops.Clear();
			_visualOreObjects.Clear();
			long startTimestamp = DiscoveryWorkBudget.Start();
			_nearbyColliderCount = Physics.OverlapSphereNonAlloc(_scanCenter, _scanRadius, _colliderBuffer, -1, (QueryTriggerInteraction)2);
			_lastQueryMs = DiscoveryWorkBudget.ElapsedMilliseconds(startTimestamp);
			_scanCursor = 0;
			_scanInProgress = true;
		}

		private void ProcessCollider(Collider collider)
		{
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_013b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0140: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: 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_01bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0152: Unknown result type (might be due to invalid IL or missing references)
			//IL_0157: 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_0277: Unknown result type (might be due to invalid IL or missing references)
			//IL_027c: Unknown result type (might be due to invalid IL or missing references)
			//IL_027f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0284: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0167: Unknown result type (might be due to invalid IL or missing references)
			//IL_0294: 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)
			if ((Object)(object)collider == (Object)null)
			{
				return;
			}
			ResourceComponentCacheEntry cachedResourceComponents = GetCachedResourceComponents(collider);
			bool flag = false;
			if (cachedResourceComponents != null)
			{
				Pickable pickable = cachedResourceComponents.Pickable;
				if ((Object)(object)pickable != (Object)null)
				{
					flag = true;
					int instanceID = ((Object)pickable).GetInstanceID();
					Vector3 position = ((Component)pickable).transform.position;
					if (_scanPickables.Add(instanceID) && WithinHorizontalRadius(_scanCenter, position, _scanRadiusSq) && MayReveal(position))
					{
						_resources.ObservePickableFromScan(pickable);
						_scanObserved++;
						_scanPickableCount++;
					}
				}
				MineRock mineRock = cachedResourceComponents.MineRock;
				if ((Object)(object)mineRock != (Object)null)
				{
					flag = true;
					int instanceID2 = ((Object)mineRock).GetInstanceID();
					Vector3 position2 = ((Component)mineRock).transform.position;
					if (_scanMineRocks.Add(instanceID2) && WithinHorizontalRadius(_scanCenter, position2, _scanRadiusSq) && MayReveal(position2))
					{
						_resources.ObserveMineRockFromScan(mineRock);
						_scanObserved++;
						_scanMineRockCount++;
					}
				}
				MineRock5 mineRock2 = cachedResourceComponents.MineRock5;
				if ((Object)(object)mineRock2 != (Object)null)
				{
					flag = true;
					int instanceID3 = ((Object)mineRock2).GetInstanceID();
					Vector3 position3 = ((Component)mineRock2).transform.position;
					if (_scanMineRocks5.Add(instanceID3) && WithinHorizontalRadius(_scanCenter, position3, _scanRadiusSq) && MayReveal(position3))
					{
						_resources.ObserveMineRock5FromScan(mineRock2);
						_scanObserved++;
						_scanMineRock5Count++;
					}
				}
				DropOnDestroyed dropOnDestroyed = cachedResourceComponents.DropOnDestroyed;
				if ((Object)(object)dropOnDestroyed != (Object)null)
				{
					flag = true;
					int instanceID4 = ((Object)dropOnDestroyed).GetInstanceID();
					Vector3 position4 = ((Component)dropOnDestroyed).transform.position;
					if (_scanDestroyedDrops.Add(instanceID4) && WithinHorizontalRadius(_scanCenter, position4, _scanRadiusSq) && MayReveal(position4) && _resources.ObserveDropOnDestroyedFromScan(dropOnDestroyed))
					{
						_scanObserved++;
						_scanDestroyedDropCount++;
					}
				}
			}
			if (flag || !TryGetCachedVisibleMineable(collider, out var source, out var resourcePrefab) || (Object)(object)source == (Object)null || string.IsNullOrEmpty(resourcePrefab))
			{
				return;
			}
			string item = ((Object)source).GetInstanceID() + ":" + resourcePrefab;
			if (_visualOreObjects.Add(item))
			{
				Vector3 position5 = source.transform.position;
				if (WithinHorizontalRadius(_scanCenter, position5, _scanRadiusSq) && MayReveal(position5) && _resources.ObserveVisibleMineableFromScan(source, resourcePrefab))
				{
					_scanObserved++;
					_scanVisualOreCount++;
				}
			}
		}

		private void FinishScan()
		{
			_scanInProgress = false;
			if (Time.unscaledTime >= _nextColliderCachePrune)
			{
				_nextColliderCachePrune = Time.unscaledTime + 60f;
				PruneColliderCaches();
			}
			if (_config.DebugLogging.Value && _config.VerboseRuntimeLogging.Value)
			{
				_log.LogInfo((object)("Area scan checked " + _scanObserved + " nearby resource sources inside " + _scanRadius.ToString("0") + "m" + (_config.MatchAreaScanToMapRevealRadius.Value ? " [map-matched]" : " [manual]") + " (Pickable=" + _scanPickableCount + ", MineRock=" + _scanMineRockCount + ", MineRock5=" + _scanMineRock5Count + ", VisualOre=" + _scanVisualOreCount + ", DropOnDestroyed=" + _scanDestroyedDropCount + "; local collider scan)."));
				if (_nearbyColliderCount >= _colliderBuffer.Length)
				{
					_log.LogWarning((object)("Area scan collider buffer filled (" + _colliderBuffer.Length + "). Nearby discovery may be incomplete in this unusually dense area."));
				}
			}
		}

		private void ResetActiveScan()
		{
			_scanInProgress = false;
			_scanCursor = 0;
			_nearbyColliderCount = 0;
		}

		private ResourceComponentCacheEntry GetCachedResourceComponents(Collider collider)
		{
			if ((Object)(object)collider == (Object)null)
			{
				return null;
			}
			int instanceID = ((Object)collider).GetInstanceID();
			if (_resourceColliderCache.TryGetValue(instanceID, out var value) && value != null && object.ReferenceEquals(value.Collider, collider) && Time.unscaledTime < value.ExpiresAt)
			{
				return value;
			}
			value = new ResourceComponentCacheEntry();
			value.Collider = collider;
			value.ExpiresAt = Time.unscaledTime + 45f;
			try
			{
				value.Pickable = ((Component)collider).GetComponentInParent<Pickable>();
				if ((Object)(object)value.Pickable == (Object)null)
				{
					value.MineRock5 = ((Component)collider).GetComponentInParent<MineRock5>();
					if ((Object)(object)value.MineRock5 == (Object)null)
					{
						value.MineRock = ((Component)collider).GetComponentInParent<MineRock>();
						if ((Object)(object)value.MineRock == (Object)null)
						{
							value.DropOnDestroyed = ((Component)collider).GetComponentInParent<DropOnDestroyed>();
						}
					}
				}
			}
			catch
			{
			}
			_resourceColliderCache[instanceID] = value;
			return value;
		}

		private void PruneColliderCaches()
		{
			List<int> list = new List<int>();
			float unscaledTime = Time.unscaledTime;
			foreach (KeyValuePair<int, ResourceComponentCacheEntry> item in _resourceColliderCache)
			{
				ResourceComponentCacheEntry value = item.Value;
				if (value == null || (Object)(object)value.Collider == (Object)null || unscaledTime >= value.ExpiresAt)
				{
					list.Add(item.Key);
				}
			}
			for (int i = 0; i < list.Count; i++)
			{
				_resourceColliderCache.Remove(list[i]);
			}
			list.Clear();
			foreach (KeyValuePair<int, VisualOreCacheEntry> item2 in _visualOreCache)
			{
				VisualOreCacheEntry value2 = item2.Value;
				if (value2 == null || (Object)(object)value2.Collider == (Object)null || unscaledTime >= value2.ExpiresAt)
				{
					list.Add(item2.Key);
				}
			}
			for (int j = 0; j < list.Count; j++)
			{
				_visualOreCache.Remove(list[j]);
			}
		}

		private bool TryGetCachedVisibleMineable(Collider collider, out GameObject source, out string resourcePrefab)
		{
			source = null;
			resourcePrefab = string.Empty;
			if ((Object)(object)collider == (Object)null)
			{
				return false;
			}
			int instanceID = ((Object)collider).GetInstanceID();
			if (_visualOreCache.TryGetValue(instanceID, out var value) && value != null && object.ReferenceEquals(value.Collider, collider) && Time.unscaledTime < value.ExpiresAt)
			{
				source = value.Source;
				resourcePrefab = value.ResourcePrefab ?? string.Empty;
				if ((Object)(object)source != (Object)null)
				{
					return !string.IsNullOrEmpty(resourcePrefab);
				}
				return false;
			}
			GameObject source2;
			string resourcePrefab2;
			bool flag = TryFindVisibleMineable(collider, out source2, out resourcePrefab2);
			VisualOreCacheEntry visualOreCacheEntry = new VisualOreCacheEntry();
			visualOreCacheEntry.Collider = collider;
			visualOreCacheEntry.Source = (flag ? source2 : null);
			visualOreCacheEntry.ResourcePrefab = (flag ? resourcePrefab2 : string.Empty);
			visualOreCacheEntry.ExpiresAt = Time.unscaledTime + (flag ? 60f : 30f);
			value = visualOreCacheEntry;
			_visualOreCache[instanceID] = value;
			source = value.Source;
			resourcePrefab = value.ResourcePrefab;
			if (flag && (Object)(object)source != (Object)null)
			{
				return !string.IsNullOrEmpty(resourcePrefab);
			}
			return false;
		}

		private static bool TryFindVisibleMineable(Collider collider, out GameObject source, out string resourcePrefab)
		{
			//IL_003f: 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)
			source = null;
			resourcePrefab = string.Empty;
			if ((Object)(object)collider == (Object)null)
			{
				return false;
			}
			Transform val = ((Component)collider).transform;
			GameObject val2 = null;
			string text = string.Empty;
			int num = 0;
			while ((Object)(object)val != (Object)null && num < 7)
			{
				GameObject gameObject = ((Component)val).gameObject;
				if (!((Object)(object)gameObject == (Object)null))
				{
					Scene scene = gameObject.scene;
					if (((Scene)(ref scene)).IsValid())
					{
						if (IdentifyVisibleSurfaceMineable(gameObject, out var resourcePrefab2))
						{
							if (IsHiddenWishboneResource(resourcePrefab2, ((Object)gameObject).name))
							{
								return false;
							}
							source = gameObject;
							resourcePrefab = resourcePrefab2;
							return true;
						}
						if (TryIdentifyMineableFromMaterials(gameObject, out var resourcePrefab3))
						{
							if (IsHiddenWishboneResource(resourcePrefab3, ((Object)gameObject).name))
							{
								return false;
							}
							if ((Object)(object)val2 == (Object)null)
							{
								val2 = gameObject;
								text = resourcePrefab3;
							}
						}
					}
				}
				num++;
				val = val.parent;
			}
			if ((Object)(object)val2 != (Object)null && !string.IsNullOrEmpty(text))
			{
				source = val2;
				resourcePrefab = text;
				return true;
			}
			return false;
		}

		private static bool IdentifyVisibleSurfaceMineable(GameObject go, out string resourcePrefab)
		{
			resourcePrefab = string.Empty;
			if ((Object)(object)go == (Object)null)
			{
				return false;
			}
			string text = NormalizeOreText(((Object)go).name ?? string.Empty);
			if (ContainsIronIdentity(text) || text.Contains("silver"))
			{
				return false;
			}
			MineRock5 component = go.GetComponent<MineRock5>();
			if ((Object)(object)component != (Object)null)
			{
				text += NormalizeOreText(SafeMineRock5Name(component));
			}
			MineRock component2 = go.GetComponent<MineRock>();
			if ((Object)(object)component2 != (Object)null)
			{
				text += NormalizeOreText(SafeMineRockName(component2));
			}
			DropOnDestroyed component3 = go.GetComponent<DropOnDestroyed>();
			bool flag = (Object)(object)component != (Object)null || (Object)(object)component2 != (Object)null || (Object)(object)component3 != (Object)null;
			if (text.Contains("copper") && (flag || LooksLikeDepositName(text)))
			{
				resourcePrefab = "CopperOre";
				return true;
			}
			if (text.Contains("tin") && (flag || LooksLikeDepositName(text)))
			{
				resourcePrefab = "TinOre";
				return true;
			}
			if (text.Contains("obsidian") && (flag || LooksLikeDepositName(text)))
			{
				resourcePrefab = "Obsidian";
				return true;
			}
			if (text.Contains("flametal") && (flag || LooksLikeDepositName(text) || text.Contains("meteor")))
			{
				resourcePrefab = "FlametalOreNew";
				return true;
			}
			if (text.Contains("blackmarble") && flag)
			{
				resourcePrefab = "BlackMarble";
				return true;
			}
			if (text.Contains("softtissue") && flag)
			{
				resourcePrefab = "SoftTissue";
				return true;
			}
			if (text.Contains("crystal") && flag)
			{
				resourcePrefab = "Crystal";
				return true;
			}
			return false;
		}

		private static bool TryIdentifyMineableFromMaterials(GameObject go, out string resourcePrefab)
		{
			resourcePrefab = string.Empty;
			if ((Object)(object)go == (Object)null)
			{
				return false;
			}
			Renderer[] componentsInChildren;
			try
			{
				componentsInChildren = go.GetComponentsInChildren<Renderer>(true);
			}
			catch
			{
				return false;
			}
			foreach (Renderer val in componentsInChildren)
			{
				if ((Object)(object)val == (Object)null || val.sharedMaterials == null)
				{
					continue;
				}
				Material[] sharedMaterials = val.sharedMaterials;
				foreach (Material val2 in sharedMaterials)
				{
					if ((Object)(object)val2 == (Object)null)
					{
						continue;
					}
					string text = NormalizeOreText(((Object)val2).name ?? string.Empty);
					if (!text.Contains("silver") && !ContainsIronIdentity(text))
					{
						bool flag = text.Contains("rock") || text.Contains("ore") || text.Contains("deposit") || text.Contains("vein") || text.Contains("meteor");
						if (text.Contains("copper") && flag)
						{
							resourcePrefab = "CopperOre";
							return true;
						}
						if (text.Contains("tin") && flag)
						{
							resourcePrefab = "TinOre";
							return true;
						}
						if (text.Contains("obsidian") && flag)
						{
							resourcePrefab = "Obsidian";
							return true;
						}
						if (text.Contains("flametal") && flag)
						{
							resourcePrefab = "FlametalOreNew";
							return true;
						}
						if (text.Contains("blackmarble") && flag)
						{
							resourcePrefab = "BlackMarble";
							return true;
						}
						if (text.Contains("softtissue") && (flag || text.Contains("tissue")))
						{
							resourcePrefab = "SoftTissue";
							return true;
						}
						if (text.Contains("crystal") && flag)
						{
							resourcePrefab = "Crystal";
							return true;
						}
					}
				}
			}
			return false;
		}

		private static bool LooksLikeDepositName(string normalizedName)
		{
			if (!normalizedName.Contains("minerock") && !normalizedName.Contains("deposit") && !normalizedName.Contains("ore") && !normalizedName.Contains("vein") && !normalizedName.Contains("meteor"))
			{
				return normalizedName.Contains("rock");
			}
			return true;
		}

		private static bool IsHiddenWishboneResource(string resourcePrefab, string objectName)
		{
			string text = NormalizeOreText((resourcePrefab ?? string.Empty) + " " + (objectName ?? string.Empty));
			if (!text.Contains("silver"))
			{
				return ContainsIronIdentity(text);
			}
			return true;
		}

		private static bool ContainsIronIdentity(string normalized)
		{
			if (string.IsNullOrEmpty(normalized))
			{
				return false;
			}
			if (!normalized.Contains("ironscrap") && !normalized.Contains("scrapiron") && !normalized.Contains("muddyscrap") && !normalized.Contains("muddypile") && !normalized.Contains("muddy"))
			{
				return normalized.Contains("buriediron");
			}
			return true;
		}

		private static string SafeMineRock5Name(MineRock5 rock)
		{
			if ((Object)(object)rock == (Object)null)
			{
				return string.Empty;
			}
			try
			{
				return rock.m_name ?? string.Empty;
			}
			catch
			{
				return string.Empty;
			}
		}

		private static string SafeMineRockName(MineRock rock)
		{
			if ((Object)(object)rock == (Object)null)
			{
				return string.Empty;
			}
			try
			{
				return rock.m_name ?? string.Empty;
			}
			catch
			{
				return string.Empty;
			}
		}

		private static string NormalizeOreText(string value)
		{
			if (string.IsNullOrEmpty(value))
			{
				return string.Empty;
			}
			char[] array = new char[value.Length];
			int length = 0;
			for (int i = 0; i < value.Length; i++)
			{
				char c = char.ToLowerInvariant(value[i]);
				if (char.IsLetterOrDigit(c))
				{
					array[length++] = c;
				}
			}
			return new string(array, 0, length);
		}

		private static bool IsLiveSceneObject(Component component)
		{
			//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)
			if ((Object)(object)component == (Object)null || (Object)(object)component.gameObject == (Object)null)
			{
				return false;
			}
			try
			{
				Scene scene = component.gameObject.scene;
				return ((Scene)(ref scene)).IsValid();
			}
			catch
			{
				return false;
			}
		}

		private bool MayReveal(Vector3 position)
		{
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			if (_config.ScanUnexploredAreas.Value)
			{
				return true;
			}
			Minimap instance = Minimap.instance;
			if ((Object)(object)instance == (Object)null || IsExploredMethod == null)
			{
				return false;
			}
			try
			{
				object obj = IsExploredMethod.Invoke(instance, new object[1] { position });
				return obj is bool && (bool)obj;
			}
			catch
			{
				return false;
			}
		}

		private static bool WithinHorizontalRadius(Vector3 a, Vector3 b, float radiusSq)
		{
			float num = a.x - b.x;
			float num2 = a.z - b.z;
			return num * num + num2 * num2 <= radiusSq;
		}
	}
	internal sealed class DiscoveryArtConsistency
	{
		private readonly ManualLogSource _log;

		private readonly WayfinderConfig _config;

		private readonly RuntimeIconRegistry _icons;

		private readonly WayfinderPinDatabase _database;

		private long _processedWorldUid = long.MinValue;

		internal DiscoveryArtConsistency(ManualLogSource log, WayfinderConfig config, RuntimeIconRegistry icons, WayfinderPinDatabase database)
		{
			_log = log;
			_config = config;
			_icons = icons;
			_database = database;
		}

		internal void ResetSession()
		{
			_processedWorldUid = long.MinValue;
		}

		internal void Tick()
		{
			if (!_config.Enabled.Value || _database.WorldUid == 0 || _processedWorldUid == _database.WorldUid || _icons == null || !_icons.IsBuilt)
			{
				return;
			}
			_processedWorldUid = _database.WorldUid;
			IReadOnlyList<WayfinderPinRecord> records = _database.Records;
			if (records == null || records.Count == 0)
			{
				return;
			}
			List<WayfinderPinRecord> list = new List<WayfinderPinRecord>();
			List<string> list2 = new List<string>();
			int num = 0;
			int num2 = 0;
			int num3 = 0;
			for (int i = 0; i < records.Count; i++)
			{
				WayfinderPinRecord wayfinderPinRecord = records[i];
				if (wayfinderPinRecord == null || wayfinderPinRecord.source == WayfinderPinSource.Manual || wayfinderPinRecord.source == WayfinderPinSource.Imported || wayfinderPinRecord.source == WayfinderPinSource.Vanilla)
				{
					continue;
				}
				string name = (wayfinderPinRecord.subtype ?? string.Empty) + " " + (wayfinderPinRecord.displayName ?? string.Empty);
				if (wayfinderPinRecord.category != WayfinderPinCategory.Boss && WayfinderIconPolicy.IsBossGuidanceRunestoneName(name))
				{
					if (!string.IsNullOrEmpty(wayfinderPinRecord.id))
					{
						list2.Add(wayfinderPinRecord.id);
					}
					continue;
				}
				bool flag = false;
				if (wayfinderPinRecord.category == WayfinderPinCategory.Sighting && (wayfinderPinRecord.iconOverride || string.IsNullOrEmpty(wayfinderPinRecord.iconKey) || string.Equals(wayfinderPinRecord.iconKey, "wayfinder:sighting", StringComparison.OrdinalIgnoreCase)))
				{
					WayfinderIconEntry wayfinderIconEntry = _icons.FindBestTrophy(wayfinderPinRecord.subtype);
					if (wayfinderIconEntry == null)
					{
						wayfinderIconEntry = _icons.FindBestTrophy(wayfinderPinRecord.displayName);
					}
					if (wayfinderIconEntry != null && !string.IsNullOrEmpty(wayfinderIconEntry.Key) && !string.Equals(wayfinderPinRecord.iconKey, wayfinderIconEntry.Key, StringComparison.OrdinalIgnoreCase))
					{
						wayfinderPinRecord.iconKey = wayfinderIconEntry.Key;
						flag = true;
						num2++;
					}
				}
				if (WayfinderIconPolicy.IsRunestoneName(name) && !string.Equals(wayfinderPinRecord.iconKey, "wayfinder:runestone", StringComparison.OrdinalIgnoreCase))
				{
					wayfinderPinRecord.iconKey = "wayfinder:runestone";
					flag = true;
					num++;
				}
				string defaultIconKey = WayfinderIconPolicy.GetDefaultIconKey(wayfinderPinRecord);
				if (!string.IsNullOrEmpty(defaultIconKey) && !string.Equals(wayfinderPinRecord.iconKey, defaultIconKey, StringComparison.OrdinalIgnoreCase))
				{
					wayfinderPinRecord.iconKey = defaultIconKey;
					flag = true;
					num3++;
				}
				if (flag)
				{
					list.Add(wayfinderPinRecord);
				}
			}
			for (int j = 0; j < list2.Count; j++)
			{
				_database.Remove(list2[j], suppressAutoRediscovery: false);
			}
			for (int k = 0; k < list.Count; k++)
			{
				_database.AddOrUpdate(list[k]);
			}
			if (_config.DebugLogging.Value)
			{
				_log.LogInfo((object)("Art/discovery consistency pass: removed " + list2.Count + " obsolete boss-guidance marker(s), normalized " + num + " runestone icon record(s), restored " + num2 + " enemy sighting trophy icon(s), repaired " + num3 + " other automatic semantic icon key(s). Manual/imported/vanilla records were untouched."));
			}
		}
	}
	internal static class DiscoveryWorkBudget
	{
		internal static long Start()
		{
			return Stopwatch.GetTimestamp();
		}

		internal static bool Expired(long startTimestamp, double budgetMs)
		{
			if (budgetMs <= 0.0)
			{
				return true;
			}
			return ElapsedMilliseconds(startTimestamp) >= budgetMs;
		}

		internal static double ElapsedMilliseconds(long startTimestamp)
		{
			return (double)(Stopwatch.GetTimestamp() - startTimestamp) * 1000.0 / (double)Stopwatch.Frequency;
		}
	}
	internal sealed class EnemySightingDiscovery
	{
		private const float DungeonInteriorY = 3000f;

		private static readonly MethodInfo IsPlayerMethod = AccessTools.Method(typeof(Character), "IsPlayer", Type.EmptyTypes, (Type[])null);

		private static readonly MethodInfo IsTamedMethod = AccessTools.Method(typeof(Character), "IsTamed", Type.EmptyTypes, (Type[])null);

		private static readonly MethodInfo IsBossMethod = AccessTools.Method(typeof(Character), "IsBoss", Type.EmptyTypes, (Type[])null);

		private static readonly MethodInfo GetHoverNameMethod = AccessTools.Method(typeof(Character), "GetHoverName", Type.EmptyTypes, (Type[])null);

		private static readonly MethodInfo IsEnemyMethod = FindIsEnemyMethod();

		private static readonly MethodInfo IsExploredMethod = AccessTools.Method(typeof(Minimap), "IsExplored", new Type[1] { typeof(Vector3) }, (Type[])null);

		private readonly ManualLogSource _log;

		private readonly WayfinderConfig _config;

		private readonly RuntimeIconRegistry _icons;

		private readonly WayfinderPinDatabase _database;

		private float _nextScanTime;

		private long _seenWorldUid = long.MinValue;

		private readonly HashSet<int> _seenLiveInstances = new HashSet<int>();

		private float _lastSpawnerCleanupTime;

		private bool _scanInProgress;

		private List<Character> _scanCharacters = new List<Character>();

		private int _scanCursor;

		private Player _scanPlayer;

		private Vector3 _scanCenter;

		private float _scanRadiusSq;

		private List<PhysicalSpawnerFootprint> _scanSpawnerFootprints;

		private int _scanRemembered;

		private bool _cleanupAfterScan;

		internal EnemySightingDiscovery(ManualLogSource log, WayfinderConfig config, RuntimeIconRegistry icons, WayfinderPinDatabase database)
		{
			_log = log;
			_config = config;
			_icons = icons;
			_database = database;
		}

		internal void Tick()
		{
			TickBudgeted(1000.0);
		}

		internal bool TickBudgeted(double budgetMs)
		{
			if (!_config.Enabled.Value || !_config.EnemySightings.Value || _database.WorldUid == 0 || (Object)(object)Player.m_localPlayer == (Object)null)
			{
				ResetActiveScan();
				return false;
			}
			if (_seenWorldUid != _database.WorldUid)
			{
				_seenWorldUid = _database.WorldUid;
				_seenLiveInstances.Clear();
				_lastSpawnerCleanupTime = 0f;
				ResetActiveScan();
			}
			long startTimestamp = DiscoveryWorkBudget.Start();
			if (!_scanInProgress)
			{
				if (Time.unscaledTime < _nextScanTime)
				{
					return false;
				}
				BeginScan();
				if (DiscoveryWorkBudget.Expired(startTimestamp, budgetMs))
				{
					return true;
				}
			}
			int num = 0;
			while (_scanCursor < _scanCharacters.Count)
			{
				Character character = _scanCharacters[_scanCursor++];
				num++;
				ProcessCharacter(character);
				if (DiscoveryWorkBudget.Expired(startTimestamp, budgetMs))
				{
					return true;
				}
			}
			if (_cleanupAfterScan)
			{
				if (DiscoveryWorkBudget.Expired(startTimestamp, budgetMs))
				{
					return true;
				}
				RunSpawnerCleanup();
				_cleanupAfterScan = false;
			}
			if (_config.DebugLogging.Value && _config.VerboseRuntimeLogging.Value && _scanRemembered > 0)
			{
				_log.LogInfo((object)("Enemy sightings remembered/confirmed: " + _scanRemembered));
			}
			_scanInProgress = false;
			_scanCharacters.Clear();
			return false;
		}

		private void BeginScan()
		{
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			_nextScanTime = Time.unscaledTime + Mathf.Max(1f, _config.EnemySightingInterval.Value);
			_scanPlayer = Player.m_localPlayer;
			_scanCenter = ((Component)_scanPlayer).transform.position;
			float num = Mathf.Max(5f, _config.EnemySightingRadius.Value);
			_scanRadiusSq = num * num;
			_scanRemembered = 0;
			_scanCursor = 0;
			_scanSpawnerFootprints = null;
			if (_config.SuppressSightingsInsideSpawnerRadius.Value)
			{
				_scanSpawnerFootprints = PhysicalSpawnerIndex.GetCached(_config.SpawnerSightingSuppressionPadding.Value, _config.SpawnerIndexCacheSeconds.Value);
			}
			_cleanupAfterScan = _config.SuppressSightingsInsideSpawnerRadius.Value && Time.unscaledTime - _lastSpawnerCleanupTime >= Mathf.Max(2f, _config.SpawnerIndexCacheSeconds.Value);
			List<Character> allCharacters = Character.GetAllCharacters();
			_scanCharacters = ((allCharacters != null) ? new List<Character>(allCharacters) : new List<Character>());
			_scanInProgress = true;
		}

		private void ProcessCharacter(Character character)
		{
			//IL_002c: 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_0054: 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_0068: 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_017f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)character == (Object)null || (Object)(object)((Component)character).gameObject == (Object)null || object.ReferenceEquals(character, _scanPlayer))
			{
				return;
			}
			Vector3 position = ((Component)character).transform.position;
			if ((position.y > 3000f && !_config.ScanDungeonContents.Value) || !WithinHorizontalRadius(_scanCenter, position, _scanRadiusSq) || !MayReveal(position))
			{
				return;
			}
			int instanceID = ((Object)character).GetInstanceID();
			if (_seenLiveInstances.Contains(instanceID) || InvokeBool(character, IsPlayerMethod, fallback: false) || InvokeBool(character, IsTamedMethod, fallback: false) || InvokeBool(character, IsBossMethod, fallback: false) || !IsHostileOrMonster(character, _scanPlayer))
			{
				return;
			}
			string prefabName = GetPrefabName(((Component)character).gameObject);
			if (string.IsNullOrEmpty(prefabName))
			{
				return;
			}
			if (_config.SuppressSightingsInsideSpawnerRadius.Value)
			{
				float exclusionRadius = Mathf.Max(0f, _config.SpawnerSightingExclusionRadius.Value);
				if (PhysicalSpawnerIndex.WithinAny(_scanSpawnerFootprints, position, exclusionRadius) || PhysicalSpawnerIndex.Covers(_scanSpawnerFootprints, position, prefabName))
				{
					return;
				}
			}
			string displayName = GetDisplayName(character, prefabName);
			string iconKey = string.Empty;
			if (_icons != null && _icons.IsBuilt)
			{
				WayfinderIconEntry wayfinderIconEntry = _icons.FindBestTrophy(prefabName);
				if (wayfinderIconEntry == null)
				{
					wayfinderIconEntry = _icons.FindBestTrophy(displayName);
				}
				if (wayfinderIconEntry != null)
				{
					iconKey = wayfinderIconEntry.Key;
				}
			}
			WayfinderPinRecord wayfinderPinRecord = _database.AddSightingObservation(prefabName, displayName, position, iconKey, "sighting:" + prefabName + ":" + instanceID, Mathf.Max(2f, _config.EnemySightingClusterDistance.Value));
			if (wayfinderPinRecord != null)
			{
				_seenLiveInstances.Add(instanceID);
				_scanRemembered++;
			}
		}

		private void RunSpawnerCleanup()
		{
			_lastSpawnerCleanupTime = Time.unscaledTime;
			float exclusionRadius = Mathf.Max(0f, _config.SpawnerSightingExclusionRadius.Value);
			int num = _database.RemoveSightingMembers((string subtype, Vector3 position) => PhysicalSpawnerIndex.WithinAny(_scanSpawnerFootprints, position, exclusionRadius) || PhysicalSpawnerIndex.Covers(_scanSpawnerFootprints, position, subtype));
			if (_config.DebugLogging.Value && num > 0)
			{
				_log.LogInfo((object)("Spawner-aware sightings: removed " + num + " redundant sighting member(s) inside matching physical spawner radii."));
			}
		}

		private void ResetActiveScan()
		{
			_scanInProgress = false;
			_scanCharacters.Clear();
			_scanCursor = 0;
			_scanPlayer = null;
			_scanSpawnerFootprints = null;
			_cleanupAfterScan = false;
		}

		private static MethodInfo FindIsEnemyMethod()
		{
			try
			{
				MethodInfo[] methods = typeof(BaseAI).GetMethods(BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
				foreach (MethodInfo methodInfo in methods)
				{
					if (string.Equals(methodInfo.Name, "IsEnemy", StringComparison.Ordinal))
					{
						ParameterInfo[] parameters = methodInfo.GetParameters();
						if (methodInfo.IsStatic && parameters.Length == 2 && typeof(Character).IsAssignableFrom(parameters[0].ParameterType) && typeof(Character).IsAssignableFrom(parameters[1].ParameterType))
						{
							return methodInfo;
						}
					}
				}
			}
			catch
			{
			}
			return null;
		}

		private static bool IsHostileOrMonster(Character character, Player player)
		{
			if ((Object)(object)character == (Object)null || (Object)(object)player == (Object)null || IsEnemyMethod == null)
			{
				return false;
			}
			try
			{
				object obj = IsEnemyMethod.Invoke(null, new object[2] { player, character });
				return obj is bool && (bool)obj;
			}
			catch
			{
				return false;
			}
		}

		private static bool InvokeBool(object instance, MethodInfo method, bool fallback)
		{
			if (instance == null || method == null)
			{
				return fallback;
			}
			try
			{
				object obj = method.Invoke(instance, null);
				return (obj is bool) ? ((bool)obj) : fallback;
			}
			catch
			{
				return fallback;
			}
		}

		private static string GetDisplayName(Character character, string fallback)
		{
			string text = fallback;
			if ((Object)(object)character != (Object)null && GetHoverNameMethod != null)
			{
				try
				{
					object obj = GetHoverNameMethod.Invoke(character, null);
					string text2 = obj as string;
					if (!string.IsNullOrEmpty(text2))
					{
						text = text2;
					}
				}
				catch
				{
				}
			}
			try
			{
				if (Localization.instance != null)
				{
					text = Localization.instance.Localize(text);
				}
			}
			catch
			{
			}
			if (!string.IsNullOrEmpty(text))
			{
				return text;
			}
			return fallback;
		}

		private static string GetPrefabName(GameObject gameObject)
		{
			if ((Object)(object)gameObject == (Object)null)
			{
				return string.Empty;
			}
			try
			{
				string prefabName = Utils.GetPrefabName(gameObject);
				if (!string.IsNullOrEmpty(prefabName))
				{
					return prefabName.Replace("(Clone)", string.Empty).Trim();
				}
			}
			catch
			{
			}
			return (((Object)gameObject).name ?? string.Empty).Replace("(Clone)", string.Empty).Trim();
		}

		private bool MayReveal(Vector3 position)
		{
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			if (_config.ScanUnexploredAreas.Value)
			{
				return true;
			}
			Minimap instance = Minimap.instance;
			if ((Object)(object)instance == (Object)null || IsExploredMethod == null)
			{
				return true;
			}
			try
			{
				object obj = IsExploredMethod.Invoke(instance, new object[1] { position });
				return !(obj is bool) || (bool)obj;
			}
			catch
			{
				return true;
			}
		}

		private static bool WithinHorizontalRadius(Vector3 a, Vector3 b, float radiusSq)
		{
			float num = a.x - b.x;
			float num2 = a.z - b.z;
			return num * num + num2 * num2 <= radiusSq;
		}
	}
	internal sealed class GravestoneIntegration
	{
		private sealed class GraveState
		{
			internal string Key;

			internal Vector3 Position;

			internal PinData Pin;
		}

		private static readonly FieldInfo PinsField = AccessTools.Field(typeof(Minimap), "m_pins");

		private static readonly Type ZNetViewType = AccessTools.TypeByName("ZNetView");

		private static readonly MethodInfo GetZdoIdMethod = FindOptionalInstanceMethod(ZNetViewType, "GetZDOID");

		private static readonly MethodInfo GetZdoMethod = FindOptionalInstanceMethod(ZNetViewType, "GetZDO");

		private readonly ManualLogSource _log;

		private readonly WayfinderConfig _config;

		private readonly RuntimeIconRegistry _icons;

		private readonly Dictionary<string, GraveState> _graves = new Dictionary<string, GraveState>(StringComparer.Ordinal);

		private readonly Dictionary<PinData, string> _graveKeyByPin = new Dictionary<PinData, string>();

		private float _nextBindTime;

		internal GravestoneIntegration(ManualLogSource log, WayfinderConfig config, RuntimeIconRegistry icons)
		{
			_log = log;
			_config = config;
			_icons = icons;
		}

		internal void ResetSession()
		{
			_graves.Clear();
			_graveKeyByPin.Clear();
			_nextBindTime = 0f;
		}

		internal void ClearSession()
		{
			ResetSession();
		}

		internal void RegisterLoadedGrave(TombStone tombstone)
		{
			//IL_007a: 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)
			if ((Object)(object)tombstone == (Object)null)
			{
				return;
			}
			Component val = null;
			try
			{
				if (ZNetViewType != null)
				{
					val = ((Component)tombstone).GetComponent(ZNetViewType);
				}
			}
			catch
			{
			}
			if ((Object)(object)val == (Object)null)
			{
				return;
			}
			string stableGraveKey = GetStableGraveKey(val);
			if (!string.IsNullOrEmpty(stableGraveKey))
			{
				if (!_graves.TryGetValue(stableGraveKey, out var value) || value == null)
				{
					GraveState graveState = new GraveState();
					graveState.Key = stableGraveKey;
					value = graveState;
					_graves[stableGraveKey] = value;
				}
				try
				{
					value.Position = ((Component)tombstone).transform.position;
				}
				catch
				{
				}
				TryBindStateToNativeDeathPin(value, Minimap.instance);
			}
		}

		internal void BeforePermanentNetworkDestroy(GameObject gameObject)
		{
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//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_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)gameObject == (Object)null)
			{
				return;
			}
			TombStone val = null;
			try
			{
				val = gameObject.GetComponent<TombStone>();
			}
			catch
			{
			}
			if ((Object)(object)val == (Object)null)
			{
				return;
			}
			Component val2 = null;
			try
			{
				if (ZNetViewType != null)
				{
					val2 = gameObject.GetComponent(ZNetViewType);
				}
			}
			catch
			{
			}
			if ((Object)(object)val2 == (Object)null)
			{
				return;
			}
			string stableGraveKey = GetStableGraveKey(val2);
			Vector3 position = Vector3.zero;
			try
			{
				position = ((Component)val).transform.position;
			}
			catch
			{
			}
			GraveState value = null;
			if (!string.IsNullOrEmpty(stableGraveKey))
			{
				_graves.TryGetValue(stableGraveKey, out value);
			}
			if (value == null)
			{
				GraveState graveState = new GraveState();
				graveState.Key = stableGraveKey ?? string.Empty;
				graveState.Position = position;
				value = graveState;
			}
			else
			{
				value.Position = position;
			}
			Minimap instance = Minimap.instance;
			if (value.Pin == null)
			{
				TryBindStateToNativeDeathPin(value, instance);
			}
			PinData pin = value.Pin;
			if (pin != null && (Object)(object)instance != (Object)null)
			{
				try
				{
					instance.RemovePin(pin);
					if (_config != null && _config.DebugLogging.Value && _config.VerboseRuntimeLogging.Value)
					{
						_log.LogInfo((object)("Gravestone permanently disappeared; removed its associated native death marker (" + (string.IsNullOrEmpty(stableGraveKey) ? "unkeyed" : stableGraveKey) + ")."));
					}
				}
				catch (Exception ex)
				{
					if (_config != null && _config.DebugLogging.Value)
					{
						_log.LogWarning((object)("Could not remove cleaned-up gravestone marker: " + ex.Message));
					}
				}
			}
			if (pin != null)
			{
				_graveKeyByPin.Remove(pin);
			}
			if (!string.IsNullOrEmpty(stableGraveKey))
			{
				_graves.Remove(stableGraveKey);
			}
		}

		internal void Tick()
		{
			if (_config == null || !_config.Enabled.Value || Time.unscaledTime < _nextBindTime)
			{
				return;
			}
			_nextBindTime = Time.unscaledTime + 0.25f;
			Minimap instance = Minimap.instance;
			if ((Object)(object)instance == (Object)null || _graves.Count == 0)
			{
				return;
			}
			List<PinData> pins = GetPins(instance);
			if (pins == null)
			{
				return;
			}
			List<string> list = null;
			foreach (KeyValuePair<string, GraveState> grafe in _graves)
			{
				GraveState value = grafe.Value;
				if (value != null && value.Pin != null && !pins.Contains(value.Pin))
				{
					_graveKeyByPin.Remove(value.Pin);
					value.Pin = null;
					if (list == null)
					{
						list = new List<string>();
					}
					list.Add(grafe.Key);
				}
			}
			foreach (KeyValuePair<string, GraveState> grafe2 in _graves)
			{
				GraveState value2 = grafe2.Value;
				if (value2 != null && value2.Pin == null)
				{
					TryBindStateToNativeDeathPin(value2, instance);
				}
			}
		}

		internal bool TryGetGravestoneSprite(out Sprite sprite)
		{
			sprite = null;
			if (_icons != null && _icons.TryGet("wayfinder:gravestone", out sprite))
			{
				return (Object)(object)sprite != (Object)null;
			}
			return false;
		}

		internal static bool IsNativeDeathPin(PinData pin)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			if (pin == null)
			{
				return false;
			}
			string text = string.Empty;
			try
			{
				text = ((object)pin.m_type).ToString();
			}
			catch
			{
			}
			if (!string.IsNullOrEmpty(text) && text.IndexOf("death", StringComparison.OrdinalIgnoreCase) >= 0)
			{
				return true;
			}
			string a = pin.m_name ?? string.Empty;
			if (!string.Equals(a, "$msg_mapmarker_death", StringComparison.OrdinalIgnoreCase) && !string.Equals(a, "$map_death", StringComparison.OrdinalIgnoreCase))
			{
				return string.Equals(a, "Death", StringComparison.OrdinalIgnoreCase);
			}
			return true;
		}

		private void TryBindStateToNativeDeathPin(GraveState state, Minimap map)
		{
			if (state == null || state.Pin != null || (Object)(object)map == (Object)null)
			{
				return;
			}
			List<PinData> pins = GetPins(map);
			if (pins == null)
			{
				return;
			}
			PinData val = null;
			float num = 144f;
			for (int i = 0; i < pins.Count; i++)
			{
				PinData val2 = pins[i];
				if (IsNativeDeathPin(val2) && !_graveKeyByPin.ContainsKey(val2))
				{
					float num2 = val2.m_pos.x - state.Position.x;
					float num3 = val2.m_pos.z - state.Position.z;
					float num4 = num2 * num2 + num3 * num3;
					if (num4 <= num)
					{
						num = num4;
						val = val2;
					}
				}
			}
			if (val != null)
			{
				state.Pin = val;
				_graveKeyByPin[val] = state.Key ?? string.Empty;
			}
		}

		private static List<PinData> GetPins(Minimap map)
		{
			if ((Object)(object)map == (Object)null || PinsField == null)
			{
				return null;
			}
			try
			{
				return PinsField.GetValue(map) as List<PinData>;
			}
			catch
			{
				return null;
			}
		}

		private static string GetStableGraveKey(Component view)
		{
			if ((Object)(object)view == (Object)null)
			{
				return string.Empty;
			}
			object obj = null;
			if (GetZdoIdMethod != null)
			{
				try
				{
					obj = GetZdoIdMethod.Invoke(view, null);
				}
				catch
				{
					obj = null;
				}
			}
			if (obj == null && GetZdoMethod != null)
			{
				try
				{
					object obj3 = GetZdoMethod.Invoke(view, null);
					if (obj3 != null)
					{
						FieldInfo field = obj3.GetType().GetField("m_uid", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
						if (field != null)
						{
							obj = field.GetValue(obj3);
						}
					}
				}
				catch
				{
					obj = null;
				}
			}
			string text = StableIdToString(obj);
			if (!string.IsNullOrEmpty(text))
			{
				switch (text)
				{
				case "0":
				case "0:0":
				case "0_0":
					break;
				default:
					return "grave:" + text;
				}
			}
			return string.Empty;
		}

		private static MethodInfo FindOptionalInstanceMethod(Type type, string name)
		{
			if (type == null || string.IsNullOrEmpty(name))
			{
				return null;
			}
			try
			{
				return type.GetMethod(name, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, Type.EmptyTypes, null);
			}
			catch
			{
				return null;
			}
		}

		private static string StableIdToString(object id)
		{
			if (id == null)
			{
				return string.Empty;
			}
			try
			{
				Type type = id.GetType();
				BindingFlags flags = BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic;
				object obj = ReadSilentMember(type, id, flags, "m_userID", "userID", "UserID");
				object obj2 = ReadSilentMember(type, id, flags, "m_id", "id", "ID");
				if (obj != null && obj2 != null)
				{
					string text = Convert.ToString(obj);
					string text2 = Convert.ToString(obj2);
					if (!string.IsNullOrEmpty(text) && !string.IsNullOrEmpty(text2))
					{
						return text + ":" + text2;
					}
				}
			}
			catch
			{
			}
			try
			{
				return id.ToString();
			}
			catch
			{
				return string.Empty;
			}
		}

		private static object ReadSilentMember(Type type, object instance, BindingFlags flags, params string[] names)
		{
			if (type == null || instance == null || names == null)
			{
				return null;
			}
			foreach (string text in names)
			{
				if (string.IsNullOrEmpty(text))
				{
					continue;
				}
				try
				{
					FieldInfo field = type.GetField(text, flags);
					if (field != null)
					{
						return field.GetValue(instance);
					}
				}
				catch
				{
				}
				try
				{
					PropertyInfo property = type.GetProperty(text, flags);
					if (property != null && property.GetIndexParameters().Length == 0)
					{
						return property.GetValue(instance, null);
					}
				}
				catch
				{
				}
			}
			return null;
		}
	}
	internal static class LiveDiscoveryRegistry
	{
		private static readonly FieldInfo AllLocationsField = AccessTools.Field(typeof(Location), "s_allLocations");

		private static readonly Dictionary<int, Location> Locations = new Dictionary<int, Location>();

		private static readonly Dictionary<int, SpawnArea> SpawnAreas = new Dictionary<int, SpawnArea>();

		private static readonly Dictionary<int, RuneStone> Runestones = new Dictionary<int, RuneStone>();

		private static readonly Dictionary<int, Vegvisir> Vegvisirs = new Dictionary<int, Vegvisir>();

		private static readonly Dictionary<int, Trader> Traders = new Dictionary<int, Trader>();

		private static long _worldUid = long.MinValue;

		private static int _revision;

		internal static int Revision => _revision;

		internal static void ResetForWorld(long worldUid)
		{
			if (_worldUid != worldUid)
			{
				_worldUid = worldUid;
				Locations.Clear();
				SpawnAreas.Clear();
				Runestones.Clear();
				Vegvisirs.Clear();
				Traders.Clear();
				_revision++;
			}
		}

		internal static void RegisterLocation(Location location)
		{
			if (!AddLive<Location>(Locations, location))
			{
				return;
			}
			try
			{
				RegisterMany(((Component)location).GetComponentsInChildren<SpawnArea>(true), RegisterSpawnArea);
				RegisterMany(((Component)location).GetComponentsInChildren<RuneStone>(true), RegisterRunestone);
				RegisterMany(((Component)location).GetComponentsInChildren<Vegvisir>(true), RegisterVegvisir);
				RegisterMany(((Component)location).GetComponentsInChildren<Trader>(true), RegisterTrader);
			}
			catch
			{
			}
		}

		internal static void UnregisterLocation(Location location)
		{
			RemoveLive<Location>(Locations, location);
		}

		internal static void RegisterSpawnArea(SpawnArea area)
		{
			AddLive<SpawnArea>(SpawnAreas, area);
		}

		internal static void RegisterRunestone(RuneStone stone)
		{
			AddLive<RuneStone>(Runestones, stone);
		}

		internal static void RegisterVegvisir(Vegvisir vegvisir)
		{
			AddLive<Vegvisir>(Vegvisirs, vegvisir);
		}

		internal static void RegisterTrader(Trader trader)
		{
			AddLive<Trader>(Traders, trader);
		}

		internal static void SyncFromLoadedLocations()
		{
			if (AllLocationsField == null)
			{
				PruneDead();
				return;
			}
			try
			{
				if (AllLocationsField.GetValue(null) is IEnumerable enumerable)
				{
					foreach (object item in enumerable)
					{
						Location val = (Location)((item is Location) ? item : null);
						if ((Object)(object)val != (Object)null)
						{
							RegisterLocation(val);
						}
					}
				}
			}
			catch
			{
			}
			PruneDead();
		}

		internal static Location[] SnapshotLocations()
		{
			SyncFromLoadedLocations();
			return Snapshot<Location>(Locations);
		}

		internal static SpawnArea[] SnapshotSpawnAreas()
		{
			SyncFromLoadedLocations();
			return Snapshot<SpawnArea>(SpawnAreas);
		}

		internal static RuneStone[] SnapshotRunestones()
		{
			SyncFromLoadedLocations();
			return Snapshot<RuneStone>(Runestones);
		}

		internal static Vegvisir[] SnapshotVegvisirs()
		{
			SyncFromLoadedLocations();
			return Snapshot<Vegvisir>(Vegvisirs);
		}

		internal static Trader[] SnapshotTraders()
		{
			SyncFromLoadedLocations();
			return Snapshot<Trader>(Traders);
		}

		private static bool AddLive<T>(Dictionary<int, T> registry, T value) where T : Object
		{
			if (registry == null || (Object)(object)value == (Object)null)
			{
				return false;
			}
			int instanceID;
			try
			{
				instanceID = ((Object)value/*cast due to .constrained prefix*/).GetInstanceID();
			}
			catch
			{
				return false;
			}
			if (registry.TryGetValue(instanceID, out var value2) && (Object)(object)value2 != (Object)null)
			{
				return false;
			}
			registry[instanceID] = value;
			_revision++;
			return true;
		}

		private static void RemoveLive<T>(Dictionary<int, T> registry, T value) where T : Object
		{
			if (registry == null || object.ReferenceEquals(value, null))
			{
				return;
			}
			try
			{
				if (registry.Remove(((Object)value/*cast due to .constrained prefix*/).GetInstanceID()))
				{
					_revision++;
				}
			}
			catch
			{
			}
		}

		private static void RegisterMany<T>(T[] values, Action<T> register)
		{
			if (values != null && register != null)
			{
				for (int i = 0; i < values.Length; i++)
				{
					register(values[i]);
				}
			}
		}

		private static T[] Snapshot<T>(Dictionary<int, T> registry) where T : Object
		{
			if (registry == null || registry.Count == 0)
			{
				return new T[0];
			}
			List<T> list = new List<T>(registry.Count);
			List<int> list2 = null;
			foreach (KeyValuePair<int, T> item in registry)
			{
				T value = item.Value;
				if ((Object)(object)value == (Object)null)
				{
					if (list2 == null)
					{
						list2 = new List<int>();
					}
					list2.Add(item.Key);
				}
				else
				{
					list.Add(value);
				}
			}
			if (list2 != null)
			{
				for (int i = 0; i < list2.Count; i++)
				{
					registry.Remove(list2[i]);
				}
				_revision++;
			}
			return list.ToArray();
		}

		private static void PruneDead()
		{
			PruneDead<Location>(Locations);
			PruneDead<SpawnArea>(SpawnAreas);
			PruneDead<RuneStone>(Runestones);
			PruneDead<Vegvisir>(Vegvisirs);
			PruneDead<Trader>(Traders);
		}

		private static void PruneDead<T>(Dictionary<int, T> registry) where T : Object
		{
			if (registry == null || registry.Count == 0)
			{
				return;
			}
			List<int> list = null;
			foreach (KeyValuePair<int, T> item in registry)
			{
				if (!((Object)(object)item.Value != (Object)null))
				{
					if (list == null)
					{
						list = new List<int>();
					}
					list.Add(item.Key);
				}
			}
			if (list != null)
			{
				for (int i = 0; i < list.Count; i++)
				{
					registry.Remove(list[i]);
				}
				_revision++;
			}
		}
	}
	internal sealed class OreDiagnosticScanner
	{
		private readonly ManualLogSource _log;

		private readonly WayfinderConfig _config;

		private readonly HashSet<int> _loggedCandidates = new HashSet<int>();

		private float _nextScanTime;

		internal OreDiagnosticScanner(ManualLogSource log, WayfinderConfig config)
		{
			_log = log;
			_config = config;
		}

		internal void Tick()
		{
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			if (!_config.DebugLogging.Value || !_config.VerboseRuntimeLogging.Value || (Object)(object)Player.m_localPlayer == (Object)null || Time.unscaledTime < _nextScanTime)
			{
				return;
			}
			_nextScanTime = Time.unscaledTime + 4f;
			Vector3 position = ((Component)Player.m_localPlayer).transform.position;
			Collider[] array = Physics.OverlapSphere(position, 22f, -1, (QueryTriggerInteraction)2);
			HashSet<int> hashSet = new HashSet<int>();
			int num = 0;
			foreach (Collider val in array)
			{
				if ((Object)(object)val == (Object)null)
				{
					continue;
				}
				Transform val2 = ((Component)val).transform;
				int num2 = 0;
				while ((Object)(object)val2 != (Object)null && num2 < 5)
				{
					GameObject gameObject = ((Component)val2).gameObject;
					if (!((Object)(object)gameObject == (Object)null))
					{
						Scene scene = gameObject.scene;
						if (((Scene)(ref scene)).IsValid())
						{
							int instanceID = ((Object)gameObject).GetInstanceID();
							if (hashSet.Add(instanceID) && !_loggedCandidates.Contains(instanceID) && LooksOreLike(gameObject, out var reason))
							{
								_loggedCandidates.Add(instanceID);
								LogCandidate(gameObject, "nearby:" + reason);
								num++;
								if (num >= 12)
								{
									break;
								}
							}
						}
					}
					num2++;
					val2 = val2.parent;
				}
				if (num >= 12)
				{
					break;
				}
			}
			if (num > 0)
			{
				_log.LogInfo((object)("ORE-DIAG logged " + num + " new nearby ore/deposit candidate(s)."));
			}
		}

		internal void LogHit(GameObject gameObject, HitData hit, string hook)
		{
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			if (!_config.DebugLogging.Value || !_config.VerboseRuntimeLogging.Value || (Object)(object)gameObject == (Object)null || (Object)(object)Player.m_localPlayer == (Object)null)
			{
				return;
			}
			try
			{
				Vector3 position = gameObject.transform.position;
				Vector3 position2 = ((Component)Player.m_localPlayer).transform.position;
				float num = position.x - position2.x;
				float num2 = position.z - position2.z;
				if (num * num + num2 * num2 > 1225f)
				{
					return;
				}
			}
			catch
			{
			}
			LogCandidate(gameObject, "HIT:" + (hook ?? "unknown"));
		}

		private void LogCandidate(GameObject go, string reason)
		{
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: 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)
			if ((Object)(object)go == (Object)null)
			{
				return;
			}
			try
			{
				StringBuilder stringBuilder = new StringBuilder(1024);
				StringBuilder stringBuilder2 = stringBuilder.Append("ORE-DIAG ").Append(reason).Append(" | prefab='")
					.Append(GetPrefabName(go))
					.Append("'")
					.Append(" object='")
					.Append(((Object)go).name ?? string.Empty)
					.Append("'")
					.Append(" hierarchy='")
					.Append(GetHierarchy(go.transform))
					.Append("'")
					.Append(" pos=");
				float x = go.transform.position.x;
				StringBuilder stringBuilder3 = stringBuilder2.Append(x.ToString("0.0")).Append(",");
				float y = go.transform.position.y;
				StringBuilder stringBuilder4 = stringBuilder3.Append(y.ToString("0.0")).Append(",");
				float z = go.transform.position.z;
				stringBuilder4.Append(z.ToString("0.0")).Append(" activeSelf=").Append(go.activeSelf)
					.Append(" activeHierarchy=")
					.Append(go.activeInHierarchy)
					.Append(" components=[")
					.Append(GetComponentNames(go))
					.Append("]");
				string value = TryGetHoverName(go);
				if (!string.IsNullOrEmpty(value))
				{
					stringBuilder.Append(" hover='").Append(value).Append("'");
				}
				string visualHints = GetVisualHints(go);
				if (!string.IsNullOrEmpty(visualHints))
				{
					stringBuilder.Append(" visuals=[").Append(visualHints).Append("]");
				}
				string interestingComponentFields = GetInterestingComponentFields(go);
				if (!string.IsNullOrEmpty(interestingComponentFields))
				{
					stringBuilder.Append(" fields=[").Append(interestingComponentFields).Append("]");
				}
				_log.LogInfo((object)stringBuilder.ToString());
			}
			catch (Exception ex)
			{
				_log.LogWarning((object)("ORE-DIAG failed to describe candidate: " + ex.Message));
			}
		}

		private static bool LooksOreLike(GameObject go, out string reason)
		{
			reason = string.Empty;
			if ((Object)(object)go == (Object)null)
			{
				return false;
			}
			string normalized = Normalize((((Object)go).name ?? string.Empty) + " " + GetHierarchy(go.transform));
			if (ContainsOreToken(normalized))
			{
				reason = "name";
				return true;
			}
			Component[] components = go.GetComponents<Component>();
			foreach (Component val in components)
			{
				if (!((Object)(object)val == (Object)null))
				{
					string text = Normalize(((object)val).GetType().Name);
					if (text.Contains("minerock"))
					{
						reason = "component:" + ((object)val).GetType().Name;
						return true;
					}
				}
			}
			Renderer[] componentsInChildren = go.GetComponentsInChildren<Renderer>(true);
			foreach (Renderer val2 in componentsInChildren)
			{
				if ((Object)(object)val2 == (Object)null)
				{
					continue;
				}
				Material[] sharedMaterials = val2.sharedMaterials;
				if (sharedMaterials == null)
				{
					continue;
				}
				foreach (Material val3 in sharedMaterials)
				{
					if (!((Object)(object)val3 == (Object)null))
					{
						string normalized2 = Normalize(((Object)val3).name ?? string.Empty);
						if (ContainsOreToken(normalized2))
						{
							reason = "material:" + ((Object)val3).name;
							return true;
						}
					}
				}
			}
			MeshFilter[] componentsInChildren2 = go.GetComponentsInChildren<MeshFilter>(true);
			foreach (MeshFilter val4 in componentsInChildren2)
			{
				if (!((Object)(object)val4 == (Object)null) && !((Object)(object)val4.sharedMesh == (Object)null))
				{
					string normalized3 = Normalize(((Object)val4.sharedMesh).name ?? string.Empty);
					if (ContainsOreToken(normalized3))
					{
						reason = "mesh:" + ((Object)val4.sharedMesh).name;
						return true;
					}
				}
			}
			return false;
		}

		private static bool ContainsOreToken(string normalized)
		{
			if (string.IsNullOrEmpty(normalized))
			{
				return false;
			}
			if (!normalized.Contains("copper") && !normalized.Contains("tin") && !normalized.Contains("silver") && !normalized.Contains("obsidian") && !normalized.Contains("flametal") && !normalized.Contains("deposit") && !normalized.Contains("ore"))
			{
				return normalized.Contains("minerock");
			}
			return true;
		}

		private static string GetComponentNames(GameObject go)
		{
			Component[] components = go.GetComponents<Component>();
			StringBuilder stringBuilder = new StringBuilder();
			foreach (Component val in components)
			{
				if (!((Object)(object)val == (Object)null))
				{
					if (stringBuilder.Length > 0)
					{
						stringBuilder.Append(",");
					}
					stringBuilder.Append(((object)val).GetType().Name);
				}
			}
			return stringBuilder.ToString();
		}

		private static string GetInterestingComponentFields(GameObject go)
		{
			Component[] components = go.GetComponents<Component>();
			StringBuilder stringBuilder = new StringBuilder();
			BindingFlags bindingAttr = BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic;
			foreach (Component val in components)
			{
				if ((Object)(object)val == (Object)null)
				{
					continue;
				}
				string name = ((object)val).GetType().Name;
				string text = Normalize(name);
				if (!text.Contains("mine") && !text.Contains("drop") && !text.Contains("destruct") && !text.Contains("pickable") && !text.Contains("wear") && !text.Contains("health"))
				{
					continue;
				}
				FieldInfo[] fields;
				try
				{
					fields = ((object)val).GetType().GetFields(bindingAttr);
				}
				catch
				{
					continue;
				}
				int num = 0;
				for (int j = 0; j < fields.Length; j++)
				{
					if (num >= 8)
					{
						break;
					}
					FieldInfo fieldInfo = fields[j];
					string text2 = Normalize(fieldInfo.Name);
					if (!text2.Contains("name") && !text2.Contains("drop") && !text2.Contains("item") && !text2.Contains("prefab") && !text2.Contains("health") && !text2.Contains("destroy"))
					{
						continue;
					}
					object value = null;
					try
					{
						value = fieldInfo.GetValue(val);
					}
					catch
					{
					}
					string value2 = RenderValue(value);
					if (!string.IsNullOrEmpty(value2))
					{
						if (stringBuilder.Length > 0)
						{
							stringBuilder.Append("; ");
						}
						stringBuilder.Append(name).Append(".").Append(fieldInfo.Name)
							.Append("=")
							.Append(value2);
						num++;
					}
				}
			}
			return stringBuilder.ToString();
		}

		private static string RenderValue(object value)
		{
			if (value == null)
			{
				return string.Empty;
			}
			if (value is string result)
			{
				return result;
			}
			GameObject val = (GameObject)((value is GameObject) ? value : null);
			if ((Object)(object)val != (Object)null)
			{
				return "GameObject(" + GetPrefabName(val) + ")";
			}
			Object val2 = (Object)((value is Object) ? value : null);
			if (val2 != (Object)null)
			{
				return ((object)val2).GetType().Name + "(" + (val2.name ?? string.Empty) + ")";
			}
			Type type = value.GetType();
			string name = type.Name;
			if (name.IndexOf("DropTable", StringComparison.OrdinalIgnoreCase) >= 0)
			{
				string text = TryDescribeDropContainer(value);
				if (!string.IsNullOrEmpty(text))
				{
					return name + "(" + text + ")";
				}
				return name;
			}
			if (value is IEnumerable enumerable && !(value is string))
			{
				string text2 = TryDescribeEnumerable(enumerable);
				if (!string.IsNullOrEmpty(text2))
				{
					return name + "(" + text2 + ")";
				}
			}
			if (type.IsPrimitive || value is decimal)
			{
				return Convert.ToString(value, CultureInfo.InvariantCulture);
			}
			return name;
		}

		private static string TryDescribeDropContainer(object container)
		{
			if (container == null)
			{
				return string.Empty;
			}
			BindingFlags bindingAttr = BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic;
			FieldInfo[] fields;
			try
			{
				fields = container.GetType().GetFields(bindingAttr);
			}
			catch
			{
				return string.Empty;
			}
			foreach (FieldInfo fieldInfo in fields)
			{
				string text = Normalize(fieldInfo.Name);
				if (!text.Contains("drop") && !text.Contains("item"))
				{
					continue;
				}
				object obj2 = null;
				try
				{
					obj2 = fieldInfo.GetValue(container);
				}
				catch
				{
				}
				if (obj2 is IEnumerable enumerable && !(obj2 is string))
				{
					string text2 = TryDescribeEnumerable(enumerable);
					if (!string.IsNullOrEmpty(text2))
					{
						return text2;
					}
				}
			}
			return string.Empty;
		}

		private static string TryDescribeEnumerable(IEnumerable enumerable)
		{
			if (enumerable == null)
			{
				return string.Empty;
			}
			StringBuilder stringBuilder = new StringBuilder();
			int num = 0;
			foreach (object item in enumerable)
			{
				if (item == null || num >= 8)
				{
					continue;
				}
				GameObject val = (GameObject)((item is GameObject) ? item : null);
				if ((Object)(object)val != (Object)null)
				{
					if (stringBuilder.Length > 0)
					{
						stringBuilder.Append(",");
					}
					stringBuilder.Append(GetPrefabName(val));
					num++;
					continue;
				}
				BindingFlags bindingAttr = BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic;
				FieldInfo[] fields;
				try
				{
					fields = item.GetType().GetFields(bindingAttr);
				}
				catch
				{
					continue;
				}
				for (int i = 0; i < fields.Length; i++)
				{
					if (!typeof(GameObject).IsAssignableFrom(fields[i].FieldType))
					{
						continue;
					}
					string text = Normalize(fields[i].Name);
					if (!text.Contains("item") && !text.Contains("prefab") && !text.Contains("drop"))
					{
						continue;
					}
					GameObject val2 = null;
					try
					{
						object? value = fields[i].GetValue(item);
						val2 = (GameObject)((value is GameObject) ? value : null);
					}
					catch
					{
					}
					if (!((Object)(object)val2 == (Object)null))
					{
						if (stringBuilder.Length > 0)
						{
							stringBuilder.Append(",");
						}
						stringBuilder.Append(GetPrefabName(val2));
						num++;
						break;
					}
				}
			}
			return stringBuilder.ToString();
		}

		private static string TryGetHoverName(GameObject go)
		{
			Component[] componentsInParent = go.GetComponentsInParent<Component>(true);
			foreach (Component val in componentsInParent)
			{
				if ((Object)(object)val == (Object)null)
				{
					continue;
				}
				MethodInfo method = ((object)val).GetType().GetMethod("GetHoverName", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, Type.EmptyTypes, null);
				if (method == null || method.ReturnType != typeof(string))
				{
					continue;
				}
				try
				{
					string text = method.Invoke(val, null) as string;
					if (string.IsNullOrEmpty(text))
					{
						continue;
					}
					try
					{
						if (Localization.instance != null)
						{
							text = Localization.instance.Localize(text);
						}
					}
					catch
					{
					}
					return text;
				}
				catch
				{
				}
			}
			return string.Empty;
		}

		private static string GetVisualHints(GameObject go)
		{
			StringBuilder stringBuilder = new StringBuilder();
			Renderer[] componentsInChildren = go.GetComponentsInChildren<Renderer>(true);
			HashSet<string> hashSet = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
			foreach (Renderer val in componentsInChildren)
			{
				if ((Object)(object)val == (Object)null || val.sharedMaterials == null)
				{
					continue;
				}
				for (int j = 0; j < val.sharedMaterials.Length; j++)
				{
					Material val2 = val.sharedMaterials[j];
					if ((Object)(object)val2 != (Object)null && !string.IsNullOrEmpty(((Object)val2).name))
					{
						hashSet.Add(((Object)val2).name);
					}
				}
			}
			int num = 0;
			foreach (string item in hashSet)
			{
				if (num < 8)
				{
					if (stringBuilder.Length > 0)
					{
						stringBuilder.Append(",");
					}
					stringBuilder.Append("mat:").Append(item);
					num++;
					continue;
				}
				break;
			}
			MeshFilter[] componentsInChildren2 = go.GetComponentsInChildren<MeshFilter>(true);
			for (int k = 0; k < componentsInChildren2.Length; k++)
			{
				if (num >= 12)
				{
					break;
				}
				MeshFilter val3 = componentsInChildren2[k];
				if (!((Object)(object)val3 == (Object)null) && !((Object)(object)val3.sharedMesh == (Object)null) && !string.IsNullOrEmpty(((Object)val3.sharedMesh).name))
				{
					if (stringBuilder.Length > 0)
					{
						stringBuilder.Append(",");
					}
					stringBuilder.Append("mesh:").Append(((Object)val3.sharedMesh).name);
					num++;
				}
			}
			return stringBuilder.ToString();
		}

		private static string GetHierarchy(Transform transform)
		{
			if ((Object)(object)transform == (Object)null)
			{
				return string.Empty;
			}
			List<string> list = new List<string>();
			Transform val = transform;
			int num = 0;
			while ((Object)(object)val != (Object)null && num < 8)
			{
				list.Add(((Object)val).name ?? string.Empty);
				val = val.parent;
				num++;
			}
			list.Reverse();
			return string.Join("/", list.ToArray());
		}

		private static string GetPrefabName(GameObject gameObject)
		{
			if ((Object)(object)gameObject == (Object)null)
			{
				return string.Empty;
			}
			try
			{
				string prefabName = Utils.GetPrefabName(gameObject);
				if (!string.IsNullOrEmpty(prefabName))
				{
					return prefabName.Replace("(Clone)", string.Empty).Trim();
				}
			}
			catch
			{
			}
			return (((Object)gameObject).name ?? string.Empty).Replace("(Clone)", string.Empty).Trim();
		}

		private static string Normalize(string value)
		{
			if (string.IsNullOrEmpty(value))
			{
				return string.Empty;
			}
			char[] array = new char[value.Length];
			int length = 0;
			for (int i = 0; i < value.Length; i++)
			{
				char c = char.ToLowerInvariant(value[i]);
				if (char.IsLetterOrDigit(c))
				{
					array[length++] = c;
				}
			}
			return new string(array, 0, length);
		}
	}
	internal sealed class PhysicalSpawnerFootprint
	{
		internal Vector3 Position;

		internal float Radius;

		internal readonly HashSet<string> CreaturePrefabs = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
	}
	internal static class PhysicalSpawnerIndex
	{
		private static List<PhysicalSpawnerFootprint> _cached = new List<PhysicalSpawnerFootprint>();

		private static float _cacheExpiresAt;

		private static float _cachedPadding = float.MinValue;

		internal static void Reset()
		{
			_cached = new List<PhysicalSpawnerFootprint>();
			_cacheExpiresAt = 0f;
			_cachedPadding = float.MinValue;
		}

		internal static List<PhysicalSpawnerFootprint> GetCached(float padding, float cacheSeconds)
		{
			if (_cached != null && Time.unscaledTime < _cacheExpiresAt && Mathf.Abs(_cachedPadding - padding) < 0.01f)
			{
				return _cached;
			}
			_cachedPadding = padding;
			_cached = Build(padding);
			_cacheExpiresAt = Time.unscaledTime + Mathf.Max(1f, cacheSeconds);
			return _cached;
		}

		internal static List<PhysicalSpawnerFootprint> Build(float padding)
		{
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			List<PhysicalSpawnerFootprint> list = new List<PhysicalSpawnerFootprint>();
			SpawnArea[] array = LiveDiscoveryRegistry.SnapshotSpawnAreas();
			foreach (SpawnArea val in array)
			{
				if (!IsLiveSceneObject((Component)(object)val))
				{
					continue;
				}
				List<GameObject> list2 = ExtractSpawnPrefabs(val);
				if (list2.Count == 0)
				{
					continue;
				}
				PhysicalSpawnerFootprint physicalSpawnerFootprint = new PhysicalSpawnerFootprint();
				physicalSpawnerFootprint.Position = ((Component)val).transform.position;
				physicalSpawnerFootprint.Radius = Mathf.Max(1f, ReadSpawnRadius(val) + Mathf.Max(0f, padding));
				for (int j = 0; j < list2.Count; j++)
				{
					string text = Normalize(GetPrefabName(list2[j]));
					if (!string.IsNullOrEmpty(text))
					{
						physicalSpawnerFootprint.CreaturePrefabs.Add(text);
					}
				}
				if (physicalSpawnerFootprint.CreaturePrefabs.Count > 0)
				{
					list.Add(physicalSpawnerFootprint);
				}
			}
			return list;
		}

		internal static bool Covers(List<PhysicalSpawnerFootprint> footprints, Vector3 position, string creaturePrefab)
		{
			if (footprints == null || footprints.Count == 0 || string.IsNullOrEmpty(creaturePrefab))
			{
				return false;
			}
			string text = Normalize(creaturePrefab);
			if (string.IsNullOrEmpty(text))
			{
				return false;
			}
			for (int i = 0; i < footprints.Count; i++)
			{
				PhysicalSpawnerFootprint physicalSpawnerFootprint = footprints[i];
				if (physicalSpawnerFootprint == null)
				{
					continue;
				}
				float num = physicalSpawnerFootprint.Position.x - position.x;
				float num2 = physicalSpawnerFootprint.Position.z - position.z;
				float radius = physicalSpawnerFootprint.Radius;
				if (num * num + num2 * num2 > radius * radius)
				{
					continue;
				}
				foreach (string creaturePrefab2 in physicalSpawnerFootprint.CreaturePrefabs)
				{
					if (creaturePrefab2 == text)
					{
						return true;
					}
					if (creaturePrefab2.Length >= 4 && (text.StartsWith(creaturePrefab2, StringComparison.OrdinalIgnoreCase) || creaturePrefab2.StartsWith(text, StringComparison.OrdinalIgnoreCase)))
					{
						return true;
					}
				}
			}
			return false;
		}

		internal static bool WithinAny(List<PhysicalSpawnerFootprint> footprints, Vector3 position, float exclusionRadius)
		{
			if (footprints == null || footprints.Count == 0 || exclusionRadius <= 0f)
			{
				return false;
			}
			float num = Mathf.Max(1f, exclusionRadius);
			float num2 = num * num;
			for (int i = 0; i < footprints.Count; i++)
			{
				PhysicalSpawnerFootprint physicalSpawnerFootprint = footprints[i];
				if (physicalSpawnerFootprint != null)
				{
					float num3 = physicalSpawnerFootprint.Position.x - position.x;
					float num4 = physicalSpawnerFootprint.Position.z - position.z;
					if (num3 * num3 + num4 * num4 <= num2)
					{
						return true;
					}
				}
			}
			return false;
		}

		private static bool IsLiveSceneObject(Component component)
		{
			//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)
			if ((Object)(object)component == (Object)null || (Object)(object)component.gameObject == (Object)null)
			{
				return false;
			}
			try
			{
				Scene scene = component.gameObject.scene;
				return ((Scene)(ref scene)).IsValid();
			}
			catch
			{
				return false;
			}
		}

		private static float ReadSpawnRadius(SpawnArea area)
		{
			try
			{
				BindingFlags bindingAttr = BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic;
				FieldInfo[] fields = typeof(SpawnArea).GetFields(bindingAttr);
				foreach (FieldInfo fieldInfo in fields)
				{
					if (fieldInfo.FieldType != typeof(float))
					{
						continue;
					}
					string text = Normalize(fieldInfo.Name);
					if (text.Contains("spawnradius") || text == "mradius")
					{
						float num = (float)fieldInfo.GetValue(area);
						if (num > 0f && num < 250f)
						{
							return num;
						}
					}
				}
			}
			catch
			{
			}
			return 20f;
		}

		private static List<GameObject> ExtractSpawnPrefabs(SpawnArea area)
		{
			List<GameObject> result = new List<GameObject>();
			if ((Object)(object)area == (Object)null)
			{
				return result;
			}
			try
			{
				FieldInfo[] fields = typeof(SpawnArea).GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				for (int i = 0; i < fields.Length; i++)
				{
					object value = null;
					try
					{
						value = fields[i].GetValue(area);
					}
					catch
					{
					}
					AddSpawnPrefabsFromValue(value, result);
				}
			}
			catch
			{
			}
			return result;
		}

		private static void AddSpawnPrefabsFromValue(object value, List<GameObject> result)
		{
			if (value == null || result == null || value is string)
			{
				return;
			}
			GameObject val = (GameObject)((value is GameObject) ? value : null);
			if ((Object)(object)val != (Object)null)
			{
				AddUnique(result, val);
			}
			else
			{
				if (!(value is IEnumerable enumerable))
				{
					return;
				}
				foreach (object item in enumerable)
				{
					if (item == null)
					{
						continue;
					}
					GameObject val2 = (GameObject)((item is GameObject) ? item : null);
					if ((Object)(object)val2 != (Object)null)
					{
						AddUnique(result, val2);
						continue;
					}
					Type type = item.GetType();
					BindingFlags bindingAttr = BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic;
					FieldInfo[] fields = type.GetFields(bindingAttr);
					for (int i = 0; i < fields.Length; i++)
					{
						if (!typeof(GameObject).IsAssignableFrom(fields[i].FieldType))
						{
							continue;
						}
						string text = Normalize(fields[i].Name);
						if (!text.Contains("prefab") && !text.Contains("creature") && !text.Contains("spawn"))
						{
							continue;
						}
						try
						{
							object? value2 = fields[i].GetValue(item);
							GameObject val3 = (GameObject)((value2 is GameObject) ? value2 : null);
							if ((Object)(object)val3 != (Object)null)
							{
								AddUnique(result, val3);
							}
						}
						catch
						{
						}
					}
				}
			}
		}

		private static void AddUnique(List<GameObject> list, GameObject value)
		{
			if ((Object)(object)value == (Object)null)
			{
				return;
			}
			for (int i = 0; i < list.Count; i++)
			{
				if (object.ReferenceEquals(list[i], value))
				{
					return;
				}
			}
			list.Add(value);
		}

		private static string GetPrefabName(GameObject gameObject)
		{
			if ((Object)(object)gameObject == (Object)null)
			{
				return string.Empty;
			}
			try
			{
				string prefabName = Utils.GetPrefabName(gameObject);
				if (!string.IsNullOrEmpty(prefabName))
				{
					return prefabName.Replace("(Clone)", string.Empty).Trim();
				}
			}
			catch
			{
			}
			return (((Object)gameObject).name ?? string.Empty).Replace("(Clone)", string.Empty).Trim();
		}

		private static string Normalize(string value)
		{
			if (string.IsNullOrEmpty(value))
			{
				return string.Empty;
			}
			char[] array = new char[value.Length];
			int length = 0;
			for (int i = 0; i < value.Length; i++)
			{
				char c = char.ToLowerInvariant(value[i]);
				if (char.IsLetterOrDigit(c))
				{
					array[length++] = c;
				}
			}
			return new string(array, 0, length);
		}
	}
	internal sealed class PortalDiscovery
	{
		private static readonly MethodInfo IsExploredMethod = AccessTools.Method(typeof(Minimap), "IsExplored", new Type[1] { typeof(Vector3) }, (Type[])null);

		private readonly ManualLogSource _log;

		private readonly WayfinderConfig _config;

		private readonly WayfinderPinDatabase _database;

		private float _nextScanTime;

		internal PortalDiscovery(ManualLogSource log, WayfinderConfig config, WayfinderPinDatabase database)
		{
			_log = log;
			_config = config;
			_database = database;
		}

		internal void ResetSession()
		{
			_nextScanTime = 0f;
			_database.BeginPortalObservationPass();
		}

		internal void ClearSession()
		{
			_nextScanTime = 0f;
			_database.BeginPortalObservationPass();
		}

		internal void Tick()
		{
			//IL_008a: 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_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ec: 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)
			if (!_config.Enabled.Value || !_config.RememberPortals.Value || _database.WorldUid == 0 || (Object)(object)Player.m_localPlayer == (Object)null || Time.unscaledTime < _nextScanTime)
			{
				return;
			}
			_nextScanTime = Time.unscaledTime + Mathf.Max(0.25f, _config.PortalSyncInterval.Value);
			_database.BeginPortalObservationPass();
			Vector3 position = ((Component)Player.m_localPlayer).transform.position;
			float num = Mathf.Max(5f, _config.PortalDiscoveryRadius.Value);
			float radiusSq = num * num;
			TeleportWorld[] array = Object.FindObjectsByType<TeleportWorld>((FindObjectsSortMode)0);
			int num2 = 0;
			foreach (TeleportWorld val in array)
			{
				if (!((Object)(object)val == (Object)null) && !((Object)(object)((Component)val).gameObject == (Object)null))
				{
					Vector3 position2 = ((Component)val).transform.position;
					if (WithinHorizontalRadius(position, position2, radiusSq) && MayReveal(position2) && SyncPortal(val))
					{
						num2++;
					}
				}
			}
			if (_config.DebugLogging.Value && _config.VerboseRuntimeLogging.Value && num2 > 0)
			{
				_log.LogInfo((object)("Portal sync confirmed " + num2 + " loaded portal(s)."));
			}
		}

		internal void ForceSyncPortal(TeleportWorld portal)
		{
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)portal == (Object)null) && !((Object)(object)((Component)portal).gameObject == (Object)null) && _config.Enabled.Value && _config.RememberPortals.Value && _database.WorldUid != 0)
			{
				Vector3 position = ((Component)portal).transform.position;
				if (MayReveal(position))
				{
					SyncPortal(portal);
				}
			}
		}

		private bool SyncPortal(TeleportWorld portal)
		{
			//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_006b: 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 ((Object)(object)portal == (Object)null || (Object)(object)((Component)portal).gameObject == (Object)null)
			{
				return false;
			}
			Vector3 position = ((Component)portal).transform.position;
			string prefabName = GetPrefabName(((Component)portal).gameObject);
			string text = Normalize(prefabName);
			if (text.Contains("dungeon"))
			{
				return false;
			}
			string portalTag = ReadPortalTag(portal);
			bool connected;
			bool connectionKnown = TryReadConnectionState(portal, out connected);
			string subtype = (string.IsNullOrEmpty(prefabName) ? "Portal" : prefabName);
			string memberKey = BuildPortalMemberKey(prefabName, position);
			WayfinderPinRecord wayfinderPinRecord = _database.UpsertPortalObservation(subtype, portalTag, position, memberKey, connectionKnown, connected, _config.PortalNameFromTag.Value);
			return wayfinderPinRecord != null;
		}

		internal void NotifyDestroyed(GameObject source)
		{
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)source == (Object)null || !_config.RemoveDestroyedPortals.Value || _database.WorldUid == 0)
			{
				return;
			}
			TeleportWorld val = FindPortal(source);
			if (!((Object)(object)val == (Object)null) && !((Object)(object)((Component)val).gameObject == (Object)null))
			{
				Vector3 position = ((Component)val).transform.position;
				string prefabName = GetPrefabName(((Component)val).gameObject);
				string memberKey = BuildPortalMemberKey(prefabName, position);
				if (_database.RemovePointByMemberKey(WayfinderPinCategory.Portal, memberKey) && _config.DebugLogging.Value)
				{
					_log.LogInfo((object)"Removed destroyed Wayfinder portal marker.");
				}
			}
		}

		private static TeleportWorld FindPortal(GameObject source)
		{
			if ((Object)(object)source == (Object)null)
			{
				return null;
			}
			Transform val = source.transform;
			while ((Object)(object)val != (Object)null)
			{
				try
				{
					TeleportWorld component = ((Component)val).gameObject.GetComponent<TeleportWorld>();
					if ((Object)(object)component != (Object)null)
					{
						return component;
					}
				}
				catch
				{
				}
				val = val.parent;
			}
			try
			{
				TeleportWorld[] componentsInChildren = source.GetComponentsInChildren<TeleportWorld>(true);
				if (componentsInChildren != null && componentsInChildren.Length > 0)
				{
					return componentsInChildren[0];
				}
			}
			catch
			{
			}
			return null;
		}

		private static string BuildPortalMemberKey(string prefabName, Vector3 position)
		{
			return "portal:" + (prefabName ?? string.Empty) + "@" + Mathf.RoundToInt(position.x * 10f) + ":" + Mathf.RoundToInt(position.y * 10f) + ":" + Mathf.RoundToInt(position.z * 10f);
		}

		private static string ReadPortalTag(TeleportWorld portal)
		{
			if ((Object)(object)portal == (Object)null)
			{
				return string.Empty;
			}
			try
			{
				string text = portal.GetText();
				if (!string.IsNullOrEmpty(text))
				{
					return text.Trim();
				}
			}
			catch
			{
			}
			Type type = ((object)portal).GetType();
			BindingFlags bindingFlags = BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic;
			string text2 = ReadStringMember(type, portal, bindingFlags, "m_targetTag", "targetTag", "TargetTag", "m_tag", "m_portalTag", "portalTag", "Tag", "tag");
			if (!string.IsNullOrEmpty(text2))
			{
				return text2.Trim();
			}
			string text3 = ReadTagFromZdo(type, portal, bindingFlags);
			if (!string.IsNullOrEmpty(text3))
			{
				return text3.Trim();
			}
			try
			{
				FieldInfo[] fields = type.GetFields(bindingFlags);
				foreach (FieldInfo fieldInfo in fields)
				{
					if (fieldInfo == null || fieldInfo.FieldType != typeof(string))
					{
						continue;
					}
					string text4 = fieldInfo.Name ?? string.Empty;
					if (text4.IndexOf("tag", StringComparison.OrdinalIgnoreCase) >= 0)
					{
						string text5 = fieldInfo.GetValue(portal) as string;
						if (!string.IsNullOrEmpty(text5))
						{
							return text5.Trim();
						}
					}
				}
			}
			catch
			{
			}
			return string.Empty;
		}

		private static string ReadTagFromZdo(Type portalType, TeleportWorld portal, BindingFlags flags)
		{
			object obj = ReadObjectMember(portalType, portal, flags, "m_nview", "m_netView", "nview", "NetView");
			if (obj == null)
			{
				return string.Empty;
			}
			object obj2 = null;
			try
			{
				MethodInfo method = obj.GetType().GetMethod("GetZDO", flags, null, Type.EmptyTypes, null);
				if (method != null)
				{
					obj2 = method.Invoke(obj, null);
				}
			}
			catch
			{
			}
			if (obj2 == null)
			{
				return string.Empty;
			}
			Type type = obj2.GetType();
			try
			{
				MethodInfo method2 = type.GetMethod("GetString", flags, null, new Type[2]
				{
					typeof(string),
					typeof(string)
				}, null);
				if (method2 != null)
				{
					object obj4 = method2.Invoke(obj2, new object[2]
					{
						"tag",
						string.Empty
					});
					string text = obj4 as string;
					if (!string.IsNullOrEmpty(text))
					{
						return text;
					}
				}
			}
			catch
			{
			}
			try
			{
				Assembly assembly = portalType.Assembly;
				Type type2 = assembly.GetType("ZDOVars");
				if (type2 != null)
				{
					int? num = ReadStaticIntMember(type2, "s_tag", "s_portalTag");
					if (num.HasValue)
					{
						MethodInfo method3 = type.GetMethod("GetString", flags, null, new Type[2]
						{
							typeof(int),
							typeof(string)
						}, null);
						if (method3 != null)
						{
							object obj6 = method3.Invoke(obj2, new object[2]
							{
								num.Value,
								string.Empty
							});
							string text2 = obj6 as string;
							if (!string.IsNullOrEmpty(text2))
							{
								return text2;
							}
						}
					}
				}
			}
			catch
			{
			}
			return string.Empty;
		}

		private static bool TryReadConnectionState(TeleportWorld portal, out bool connected)
		{
			connected = false;
			if ((Object)(object)portal == (Object)null)
			{
				return false;
			}
			Type type = ((object)portal).GetType();
			BindingFlags bindingAttr = BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic;
			string[] array = new string[4] { "TargetFound", "IsConnected", "HasTarget", "HasConnectedPortal" };
			for (int i = 0; i < array.Length; i++)
			{
				try
				{
					MethodInfo method = type.GetMethod(array[i], bindingAttr, null, Type.EmptyTypes, null);
					if (!(method == null) && !(method.ReturnType != typeof(bool)))
					{
						object obj = method.Invoke(portal, null);
						if (obj is bool)
						{
							connected = (bool)obj;
							return true;
						}
					}
				}
				catch
				{
				}
			}
			string[] array2 = new string[6] { "m_targetFound", "m_target_found", "m_connected", "m_isConnected", "connected", "IsConnected" };
			for (int j = 0; j < array2.Length; j++)
			{
				try
				{
					FieldInfo field = type.GetField(array2[j], bindingAttr);
					if (field != null && field.FieldType == typeof(bool))
					{
						connected = (bool)field.GetValue(portal);
						return true;
					}
				}
				catch
				{
				}
				try
				{
					PropertyInfo property = type.GetProperty(array2[j], bindingAttr);
					if (property != null && property.PropertyType == typeof(bool) && property.GetIndexParameters().Length == 0)
					{
						connected = (bool)property.GetValue(portal, null);
						return true;
					}
				}
				catch
				{
				}
			}
			return false;
		}

		private static string ReadStringMember(Type type, object instance, BindingFlags flags, params string[] names)
		{
			if (type == null || instance == null || names == null)
			{
				return string.Empty;
			}
			foreach (string name in names)
			{
				try
				{
					FieldInfo field = type.GetField(name, flags);
					if (field != null && field.FieldType == typeof(string))
					{
						string text = field.GetValue(instance) as string;
						if (!string.IsNullOrEmpty(text))
						{
							return text;
						}
					}
				}
				catch
				{
				}
				try
				{
					PropertyInfo property = type.GetProperty(name, flags);
					if (property != null && property.PropertyType == typeof(string) && property.GetIndexParameters().Length == 0)
					{
						string text2 = property.GetValue(instance, null) as string;
						if (!string.IsNullOrEmpty(text2))
						{
							return text2;
						}
					}
				}
				catch
				{
				}
			}
			return string.Empty;
		}

		private static object ReadObjectMember(Type type, object instance, BindingFlags flags, params string[] names)
		{
			if (type == null || instance == null || names == null)
			{
				return null;
			}
			for (int i = 0; i < names.Length; i++)
			{
				try
				{
					FieldInfo field = type.GetField(names[i], flags);
					if (field != null)
					{
						object value = field.GetValue(instance);
						if (value != null)
						{
							return value;
						}
					}
				}
				catch
				{
				}
				try
				{
					PropertyInfo property = type.GetProperty(names[i], flags);
					if (property != null && property.GetIndexParameters().Length == 0)
					{
						object value2 = property.GetValue(instance, null);
						if (value2 != null)
						{
							return value2;
						}
					}
				}
				catch
				{
				}
			}
			return null;
		}

		private static int? ReadStaticIntMember(Type type, params string[] names)
		{
			if (type == null || names == null)
			{
				return null;
			}
			BindingFlags bindingAttr = BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic;
			for (int i = 0; i < names.Length; i++)
			{
				try
				{
					FieldInfo field = type.GetField(names[i], bindingAttr);
					if (field != null && field.FieldType == typeof(int))
					{
						return (int)field.GetValue(null);
					}
				}
				catch
				{
				}
				try
				{
					PropertyInfo property = type.GetProperty(names[i], bindingAttr);
					if (property != null && property.PropertyType == typeof(int) && property.GetIndexParameters().Length == 0)
					{
						return (int)property.GetValue(null, null);
					}
				}
				catch
				{
				}
			}
			return null;
		}

		private bool MayReveal(Vector3 position)
		{
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			if (_config.ScanUnexploredAreas.Value)
			{
				return true;
			}
			Minimap instance = Minimap.instance;
			if ((Object)(object)instance == (Object)null || IsExploredMethod == null)
			{
				return false;
			}
			try
			{
				object obj = IsExploredMethod.Invoke(instance, new object[1] { position });
				return obj is bool && (bool)obj;
			}
			catch
			{
				return false;
			}
		}

		private static string GetPrefabName(GameObject gameObject)
		{
			if ((Object)(object)gameObject == (Object)null)
			{
				return string.Empty;
			}
			try
			{
				string prefabName = Utils.GetPrefabName(gameObject);
				if (!string.IsNullOrEmpty(prefabName))
				{
					return prefabName.Replace("(Clone)", string.Empty).Trim();
				}
			}
			catch
			{
			}
			return (((Object)gameObject).name ?? string.Empty).Replace("(Clone)", string.Empty).Trim();
		}

		private static bool WithinHorizontalRadius(Vector3 a, Vector3 b, float radiusSq)
		{
			float num = a.x - b.x;
			float num2 = a.z - b.z;
			return num * num + num2 * num2 <= radiusSq;
		}

		private static string Normalize(string value)
		{
			if (string.IsNullOrEmpty(value))
			{
				return string.Empty;
			}
			char[] array = new char[value.Length];
			int length = 0;
			for (int i = 0; i < value.Length; i++)
			{
				char c = char.ToLowerInvariant(value[i]);
				if (char.IsLetterOrDigit(c))
				{
					array[length++] = c;
				}
			}
			return new string(array, 0, length);
		}
	}
	internal sealed class ResourceDiscovery
	{
		private const float DungeonInteriorY = 3000f;

		private readonly ManualLogSource _log;

		private readonly WayfinderConfig _config;

		private readonly RuntimeIconRegistry _icons;

		private readonly WayfinderPinDatabase _database;

		private long _lastCleanupWorldUid = long.MinValue;

		private string _lastCleanupSignature = string.Empty;

		private long _lastIconRepairWorldUid = long.MinValue;

		private int _lastIconRepairRecordCount = -1;

		internal ResourceDiscovery(ManualLogSource log, WayfinderConfig config, RuntimeIconRegistry icons, WayfinderPinDatabase database)
		{
			_log = log;
			_config = config;
			_icons = icons;
			_database = database;
		}

		internal void ObservePickable(Pickable pickable)
		{
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			if (CanDiscoverInteraction() && !ShouldSuppressDungeonContents() && !((Object)(object)pickable == (Object)null) && !((Object)(object)pickable.m_itemPrefab == (Object)null))
			{
				ObserveItemSource(pickable.m_itemPrefab, ((Component)pickable).transform.position, "pickable:" + StableObjectKey(((Component)pickable).gameObject), WayfinderPinSource.InteractionDiscovery);
			}
		}

		internal void ObservePickableFromScan(Pickable pickable)
		{
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			if (CanDiscoverAreaScan() && !ShouldSuppressDungeonContents() && !((Object)(object)pickable == (Object)null) && !((Object)(object)pickable.m_itemPrefab == (Object)null))
			{
				ObserveItemSource(pickable.m_itemPrefab, ((Component)pickable).transform.position, "pickable:" + StableObjectKey(((Component)pickable).gameObject), WayfinderPinSource.AreaScan);
			}
		}

		internal void ObserveMineRock(MineRock rock, HitData hit)
		{
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			if (CanDiscoverInteraction() && !ShouldSuppressDungeonContents() && !((Object)(object)rock == (Object)null) && WasHitByLocalPlayer(hit))
			{
				GameObject val = ResolveMineableResourceItem(((Component)rock).gameObject, rock.m_name, rock.m_dropItems);
				if ((Object)(object)val != (Object)null)
				{
					ObserveItemSource(val, ((Component)rock).transform.position, "minerock:" + StableObjectKey(((Component)rock).gameObject), WayfinderPinSource.InteractionDiscovery);
				}
			}
		}

		internal void ObserveMineRockFromScan(MineRock rock)
		{
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			if (CanDiscoverAreaScan() && !ShouldSuppressDungeonContents() && !((Object)(object)rock == (Object)null) && !IsWishboneOnlyMineable(((Component)rock).gameObject, rock.m_name))
			{
				GameObject val = ResolveMineableResourceItem(((Component)rock).gameObject, rock.m_name, rock.m_dropItems);
				if ((Object)(object)val != (Object)null)
				{
					ObserveItemSource(val, ((Component)rock).transform.position, "minerock:" + StableObjectKey(((Component)rock).gameObject), WayfinderPinSource.AreaScan);
				}
			}
		}

		internal void ObserveMineRock5(MineRock5 rock, HitData hit)
		{
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			if (CanDiscoverInteraction() && !ShouldSuppressDungeonContents() && !((Object)(object)rock == (Object)null) && WasHitByLocalPlayer(hit))
			{
				GameObject val = ResolveMineableResourceItem(((Component)rock).gameObject, rock.m_name, rock.m_dropItems);
				if ((Object)(object)val != (Object)null)
				{
					ObserveItemSource(val, ((Component)rock).transform.position, "minerock5:" + StableObjectKey(((Component)rock).gameObject), WayfinderPinSource.InteractionDiscovery);
				}
			}
		}

		internal void ObserveMineRock5FromScan(MineRock5 rock)
		{
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			if (CanDiscoverAreaScan() && !ShouldSuppressDungeonContents() && !((Object)(object)rock == (Object)null) && !IsWishboneOnlyMineable(((Component)rock).gameObject, rock.m_name))
			{
				GameObject val = ResolveMineableResourceItem(((Component)rock).gameObject, rock.m_name, rock.m_dropItems);
				if ((Object)(object)val != (Object)null)
				{
					ObserveItemSource(val, ((Component)rock).transform.position, "minerock5:" + StableObjectKey(((Component)rock).gameObject), WayfinderPinSource.AreaScan);
				}
			}
		}

		internal bool ObserveVisibleMineableFromScan(GameObject sourceObject, string resourcePrefab)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			if (!CanDiscoverAreaScan() || (Object)(object)sourceObject == (Object)null || string.IsNullOrEmpty(resourcePrefab))
			{
				return false;
			}
			Vector3 position = sourceObject.transform.position;
			if (ShouldSuppressResourcePosition(position))
			{
				return false;
			}
			if (IsWishboneOnlyResourcePrefab(resourcePrefab))
			{
				return false;
			}
			GameObject val = FindRepresentativeResourceItem(resourcePrefab);
			if ((Object)(object)val == (Object)null)
			{
				return false;
			}
			ObserveItemSource(val, position, "visualore:" + resourcePrefab + ":" + StableObjectKey(sourceObject), WayfinderPinSource.AreaScan);
			return true;
		}

		internal bool ObserveDropOnDestroyedFromScan(DropOnDestroyed dropper)
		{
			//IL_0019: 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_0020: 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)
			if (!CanDiscoverAreaScan() || (Object)(object)dropper == (Object)null)
			{
				return false;
			}
			Vector3 position = ((Component)dropper).transform.position;
			if (ShouldSuppressResourcePosition(position))
			{
				return false;
			}
			DropTable dropOnDestroyedTable = GetDropOnDestroyedTable(dropper);
			if (!IsKnownMineableDropNode(((Component)dropper).gameObject, dropOnDestroyedTable))
			{
				return false;
			}
			if (IsWishboneOnlyMineable(((Component)dropper).gameObject, ((Object)((Component)dropper).gameObject).name))
			{
				return false;
			}
			GameObject val = ResolveMineableResourceItem(((Component)dropper).gameObject, GetHoverTextOrName(((Component)dropper).gameObject), dropOnDestroyedTable);
			if ((Object)(object)val == (Object)null)
			{
				return false;
			}
			ObserveItemSource(val, position, "destroyeddrop:" + StableObjectKey(((Component)dropper).gameObject), WayfinderPinSource.AreaScan);
			return true;
		}

		internal void ObserveDestructibleDrop(GameObject hitObject, HitData hit)
		{
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			if (!CanDiscoverInteraction() || (Object)(object)hitObject == (Object)null || !WasHitByLocalPlayer(hit))
			{
				return;
			}
			DropOnDestroyed val = hitObject.GetComponent<DropOnDestroyed>();
			if ((Object)(object)val == (Object)null)
			{
				val = hitObject.GetComponentInParent<DropOnDestroyed>();
			}
			if ((Object)(object)val == (Object)null)
			{
				val = hitObject.GetComponentInChildren<DropOnDestroyed>();
			}
			if ((Object)(object)val == (Object)null)
			{
				return;
			}
			Vector3 position = ((Component)val).transform.position;
			if (ShouldSuppressResourcePosition(position))
			{
				return;
			}
			DropTable dropOnDestroyedTable = GetDropOnDestroyedTable(val);
			if (IsKnownMineableDropNode(((Component)val).gameObject, dropOnDestroyedTable))
			{
				GameObject val2 = ResolveMineableResourceItem(((Component)val).gameObject, GetHoverTextOrName(((Component)val).gameObject), dropOnDestroyedTable);
				if (!((Object)(object)val2 == (Object)null))
				{
					ObserveItemSource(val2, position, "destroyeddrop:" + StableObjectKey(((Component)val).gameObject), WayfinderPinSource.InteractionDiscovery);
				}
			}
		}

		internal void ApplyLiveFilterCleanup()
		{
			if (_database.WorldUid == 0)
			{
				return;
			}
			string text = _config.AutoPinStone.Value + "|" + _config.AutoPinBranches.Value + "|" + _config.AutoPinFlint.Value + "|" + _config.AutoPinDandelions.Value + "|" + _config.ScanDungeonContents.Value;
			if (_lastCleanupWorldUid != _database.WorldUid || !string.Equals(_lastCleanupSignature, text, StringComparison.Ordinal))
			{
				_lastCleanupWorldUid = _database.WorldUid;
				_lastCleanupSignature = text;
				if (!_config.AutoPinStone.Value)
				{
					_database.RemoveAutoResourceSubtype("Stone");
				}
				if (!_config.AutoPinBranches.Value)
				{
					_database.RemoveAutoResourceSubtype("Wood");
					_database.RemoveAutoResourceSubtype("Branch");
				}
				if (!_config.AutoPinFlint.Value)
				{
					_database.RemoveAutoResourceSubtype("Flint");
				}
				if (!_config.AutoPinDandelions.Value)
				{
					_database.RemoveAutoResourceSubtype("Dandelion");
				}
				_database.RemoveResourceMembers((string subtype, Vector3 position) => IsLowValueResource(subtype) && IsNearGeneratedSite(position, 12f));
				_database.RemoveAutoResourceSubtypeBySource("Silver", WayfinderPinSource.AreaScan);
				_database.RemoveAutoResourceSubtypeBySource("SilverOre", WayfinderPinSource.AreaScan);
				_database.RemoveAutoResourceSubtypeBySource("IronScrap", WayfinderPinSource.AreaScan);
				_database.RemoveAutoResourceSubtypeBySource("ScrapIron", WayfinderPinSource.AreaScan);
				_database.RemoveAutoResourceSubtypeAboveY("IronScrap", 3000f);
				_database.RemoveAutoResourceSubtypeAboveY("ScrapIron", 3000f);
				if (!_config.ScanDungeonContents.Value)
				{
					_database.RemoveAutoDungeonResources(3000f);
				}
			}
		}

		private bool CanDiscoverInteraction()
		{
			if (_config.Enabled.Value && _config.InteractionDiscovery.Value)
			{
				return _database.WorldUid != 0;
			}
			return false;
		}

		private bool CanDiscoverAreaScan()
		{
			if (_config.Enabled.Value && _config.AreaScanning.Value)
			{
				return _database.WorldUid != 0;
			}
			return false;
		}

		private bool ShouldSuppressDungeonContents()
		{
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			if (_config.ScanDungeonContents.Value)
			{
				return false;
			}
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null)
			{
				return false;
			}
			try
			{
				return ((Character)localPlayer).InInterior();
			}
			catch
			{
				return (Object)(object)((Component)localPlayer).transform != (Object)null && ((Component)localPlayer).transform.position.y > 3000f;
			}
		}

		private void ObserveItemSource(GameObject itemPrefab, Vector3 position, string memberKey, WayfinderPinSource source)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)itemPrefab == (Object)null || ShouldSuppressResourcePosition(position))
			{
				return;
			}
			ItemDrop component = itemPrefab.GetComponent<ItemDrop>();
			if ((Object)(object)component == (Object)null || component.m_itemData == null || component.m_itemData.m_shared == null)
			{
				return;
			}
			string text = CleanPrefabName(((Object)itemPrefab).name ?? string.Empty);
			if (string.IsNullOrEmpty(text) || !ShouldAutoPinResource(text) || ShouldSuppressOreObservation(text, position, source))
			{
				return;
			}
			string name = component.m_itemData.m_shared.m_name;
			string text2 = Localize(name, text);
			string text3 = CanonicalResourceKey(text);
			if (IsLowValueResource(text3) && IsNearGeneratedSite(position, 12f))
			{
				return;
			}
			string text4 = ResolveResourceIconKey(text);
			if (string.IsNullOrEmpty(text4))
			{
				text4 = "item:" + text;
				if (!_icons.TryGet(text4, out var _))
				{
					_icons.MarkDirty();
				}
			}
			WayfinderPinRecord wayfinderPinRecord = _database.AddResourceObservation(text3, text2, position, text4, source, memberKey);
			if (_config.DebugLogging.Value && _config.VerboseRuntimeLogging.Value && wayfinderPinRecord != null)
			{
				_log.LogInfo((object)("Remembered resource: " + text2 + " (cluster count " + wayfinderPinRecord.count + ", icon " + text4 + ", pos " + position.x.ToString("0.0") + "," + position.z.ToString("0.0") + ", member " + memberKey + ")"));
			}
		}

		internal void RepairKnownResourceIcons(bool force = false)
		{
			if (!_icons.IsBuilt || _database.WorldUid == 0)
			{
				return;
			}
			int num = ((_database.Records != null) ? _database.Records.Count : 0);
			if (!force && _lastIconRepairWorldUid == _database.WorldUid && _lastIconRepairRecordCount == num)
			{
				return;
			}
			_lastIconRepairWorldUid = _database.WorldUid;
			_lastIconRepairRecordCount = num;
			List<WayfinderPinRecord> list = new List<WayfinderPinRecord>();
			IReadOnlyList<WayfinderPinRecord> records = _database.Records;
			for (int i = 0; i < records.Count; i++)
			{
				WayfinderPinRecord wayfinderPinRecord = records[i];
				if (wayfinderPinRecord == null || wayfinderPinRecord.category != WayfinderPinCategory.Resource)
				{
					continue;
				}
				string text = ResolveResourceIconKey(wayfinderPinRecord.subtype);
				if (!string.IsNullOrEmpty(text))
				{
					if (!string.Equals(wayfinderPinRecord.iconKey, text, StringComparison.OrdinalIgnoreCase))
					{
						wayfinderPinRecord.iconKey = text;
						list.Add(wayfinderPinRecord);
					}
					string text2 = CanonicalResourceKey(wayfinderPinRecord.subtype);
					if (!string.IsNullOrEmpty(text2) && !string.Equals(wayfinderPinRecord.subtype, text2, StringComparison.OrdinalIgnoreCase))
					{
						wayfinderPinRecord.subtype = text2;
						list.Add(wayfinderPinRecord);
					}
				}
			}
			HashSet<string> hashSet = new HashSet<string>(StringComparer.Ordinal);
			for (int j = 0; j < list.Count; j++)
			{
				WayfinderPinRecord wayfinderPinRecord2 = list[j];
				if (wayfinderPinRecord2 != null && !string.IsNullOrEmpty(wayfinderPinRecord2.id) && hashSet.Add(wayfinderPinRecord2.id))
				{
					_database.AddOrUpdate(wayfinderPinRecord2);
				}
			}
			if (_config.DebugLogging.Value && hashSet.Count > 0)
			{
				_log.LogInfo((object)("Repaired " + hashSet.Count + " persisted resource icon records."));
			}
		}

		private bool IsNearGeneratedSite(Vector3 position, float radius)
		{
			//IL_003a: 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)
			IReadOnlyList<WayfinderPinRecord> records = _database.Records;
			if (records == null || radius <= 0f)
			{
				return false;
			}
			float num = radius * radius;
			for (int i = 0; i < records.Count; i++)
			{
				WayfinderPinRecord wayfinderPinRecord = records[i];
				if (wayfinderPinRecord != null && WayfinderIconPolicy.IsGeneratedLocationCategory(wayfinderPinRecord.category))
				{
					float num2 = wayfinderPinRecord.Position.x - position.x;
					float num3 = wayfinderPinRecord.Position.z - position.z;
					if (num2 * num2 + num3 * num3 <= num)
					{
						return true;
					}
				}
			}
			return false;
		}

		private static bool IsLowValueResource(string subtype)
		{
			string text = Normalize(subtype);
			switch (text)
			{
			default:
				return text == "dandelion";
			case "stone":
			case "wood":
			case "branch":
			case "flint":
				return true;
			}
		}

		private string ResolveResourceIconKey(string resourceName)
		{
			if (!_icons.IsBuilt || string.IsNullOrEmpty(resourceName))
			{
				return string.Empty;
			}
			string text = Normalize(resourceName);
			if (text.Contains("copper"))
			{
				string text2 = ExactIconKey("CopperOre");
				if (string.IsNullOrEmpty(text2))
				{
					return _icons.FindBestItemKey("CopperOre", "$item_copperore", "Copper");
				}
				return text2;
			}
			if (text.Contains("tin"))
			{
				string text2 = ExactIconKey("TinOre");
				if (string.IsNullOrEmpty(text2))
				{
					return _icons.FindBestItemKey("TinOre", "$item_tinore", "Tin");
				}
				return text2;
			}
			if (text.Contains("obsidian"))
			{
				string text2 = ExactIconKey("Obsidian");
				if (string.IsNullOrEmpty(text2))
				{
					return _icons.FindBestItemKey("Obsidian");
				}
				return text2;
			}
			if (text.Contains("silver"))
			{
				string text2 = ExactIconKey("SilverOre");
				if (string.IsNullOrEmpty(text2))
				{
					return _icons.FindBestItemKey("SilverOre", "$item_silverore", "Silver");
				}
				return text2;
			}
			if (text.Contains("ironscrap") || text.Contains("scrapiron") || text.Contains("muddy"))
			{
				string text2 = ExactIconKey("IronScrap");
				if (string.IsNullOrEmpty(text2))
				{
					return _icons.FindBestItemKey("IronScrap", "ScrapIron");
				}
				return text2;
			}
			if (text.Contains("flametal"))
			{
				string text2 = ExactIconKey("FlametalOreNew");
				if (string.IsNullOrEmpty(text2))
				{
					text2 = ExactIconKey("FlametalOre");
				}
				if (string.IsNullOrEmpty(text2))
				{
					return _icons.FindBestItemKey("FlametalOreNew", "FlametalOre", "FlametalNew", "Flametal");
				}
				return text2;
			}
			if (text.Contains("blackmarble"))
			{
				return ExactOrBest("BlackMarble");
			}
			if (text.Contains("softtissue"))
			{
				return ExactOrBest("SoftTissue");
			}
			if (text.Contains("crystal"))
			{
				return ExactOrBest("Crystal");
			}
			if (text.Contains("guck"))
			{
				return ExactOrBest("Guck");
			}
			return _icons.FindBestItemKey(resourceName);
		}

		private string ExactOrBest(string prefabName)
		{
			string text = ExactIconKey(prefabName);
			if (string.IsNullOrEmpty(text))
			{
				return _icons.FindBestItemKey(prefabName);
			}
			return text;
		}

		private string ExactIconKey(string prefabName)
		{
			if (string.IsNullOrEmpty(prefabName))
			{
				return string.Empty;
			}
			string text = "item:" + prefabName;
			if (!_icons.TryGet(text, out var sprite) || !((Object)(object)sprite != (Object)null))
			{
				return string.Empty;
			}
			return text;
		}

		private static string CanonicalResourceKey(string resourceName)
		{
			if (string.IsNullOrEmpty(resourceName))
			{
				return resourceName;
			}
			string text = Normalize(resourceName);
			if (text.Contains("copper"))
			{
				return "Copper";
			}
			if (text.Contains("tin"))
			{
				return "Tin";
			}
			if (text.Contains("obsidian"))
			{
				return "Obsidian";
			}
			if (text.Contains("silver"))
			{
				return "Silver";
			}
			if (text.Contains("ironscrap") || text.Contains("scrapiron") || text.Contains("muddy"))
			{
				return "IronScrap";
			}
			if (text.Contains("flametal"))
			{
				return "Flametal";
			}
			if (text.Contains("blackmarble"))
			{
				return "BlackMarble";
			}
			if (text.Contains("softtissue"))
			{
				return "SoftTissue";
			}
			if (text.Contains("crystal"))
			{
				return "Crystal";
			}
			if (text.Contains("guck"))
			{
				return "Guck";
			}
			return resourceName;
		}

		private bool ShouldAutoPinResource(string prefabName)
		{
			if (string.Equals(prefabName, "Stone", StringComparison.OrdinalIgnoreCase))
			{
				return _config.AutoPinStone.Value;
			}
			if (string.Equals(prefabName, "Wood", StringComparison.OrdinalIgnoreCase) || string.Equals(prefabName, "Branch", StringComparison.OrdinalIgnoreCase) || prefabName.IndexOf("branch", StringComparison.OrdinalIgnoreCase) >= 0)
			{
				return _config.AutoPinBranches.Value;
			}
			if (string.Equals(prefabName, "Flint", StringComparison.OrdinalIgnoreCase))
			{
				return _config.AutoPinFlint.Value;
			}
			if (string.Equals(prefabName, "Dandelion", StringComparison.OrdinalIgnoreCase))
			{
				return _config.AutoPinDandelions.Value;
			}
			return true;
		}

		private bool ShouldSuppressResourcePosition(Vector3 position)
		{
			if (!_config.ScanDungeonContents.Value)
			{
				return position.y > 3000f;
			}
			return false;
		}

		private static DropTable GetDropOnDestroyedTable(DropOnDestroyed dropper)
		{
			if ((Object)(object)dropper == (Object)null)
			{
				return null;
			}
			try
			{
				BindingFlags bindingAttr = BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic;
				FieldInfo field = typeof(DropOnDestroyed).GetField("m_dropWhenDestroyed", bindingAttr);
				if (field != null)
				{
					object value = field.GetValue(dropper);
					DropTable val = (DropTable)((value is DropTable) ? value : null);
					if (val != null)
					{
						return val;
					}
				}
				FieldInfo[] fields = typeof(DropOnDestroyed).GetFields(bindingAttr);
				for (int i = 0; i < fields.Length; i++)
				{
					if (typeof(DropTable).IsAssignableFrom(fields[i].FieldType))
					{
						object? value2 = fields[i].GetValue(dropper);
						DropTable val2 = (DropTable)((value2 is DropTable) ? value2 : null);
						if (val2 != null)
						{
							return val2;
						}
					}
				}
			}
			catch
			{
			}
			return null;
		}

		private static bool IsKnownMineableDropNode(GameObject worldObject, DropTable table)
		{
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			string text = Normalize(((Object)(object)worldObject == (Object)null) ? string.Empty : CleanPrefabName(((Object)worldObject).name ?? string.Empty));
			if (text.Contains("tin") || text.Contains("copper") || text.Contains("silver") || text.Contains("obsidian") || text.Contains("flametal") || text.Contains("meteorite") || text.Contains("muddy") || text.Contains("scrapiron") || text.Contains("ironscrap") || text.Contains("blackmarble") || text.Contains("softtissue") || text.Contains("crystal") || text.Contains("guck"))
			{
				return true;
			}
			if (table == null || table.m_drops == null)
			{
				return false;
			}
			for (int i = 0; i < table.m_drops.Count; i++)
			{
				GameObject item = table.m_drops[i].m_item;
				if (!((Object)(object)item == (Object)null))
				{
					string text2 = Normalize(CleanPrefabName(((Object)item).name ?? string.Empty));
					if (text2.Contains("tinore") || text2.Contains("copperore") || text2.Contains("silverore") || text2.Contains("obsidian") || text2.Contains("flametal") || text2.Contains("ironscrap") || text2.Contains("scrapiron") || text2.Contains("blackmarble") || text2.Contains("softtissue") || text2.Contains("crystal") || text2.Contains("guck"))
					{
						return true;
					}
				}
			}
			return false;
		}

		private static string GetHoverTextOrName(GameObject gameObject)
		{
			if ((Object)(object)gameObject == (Object)null)
			{
				return string.Empty;
			}
			try
			{
				HoverText component = gameObject.GetComponent<HoverText>();
				if ((Object)(object)component != (Object)null)
				{
					MethodInfo method = typeof(HoverText).GetMethod("GetHoverText", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
					if (method != null && method.GetParameters().Length == 0)
					{
						object obj = method.Invoke(component, null);
						string text = obj as string;
						if (!string.IsNullOrEmpty(text))
						{
							return text;
						}
					}
				}
			}
			catch
			{
			}
			return ((Object)gameObject).name ?? string.Empty;
		}

		private static GameObject FindRepresentativeResourceItem(string resourcePrefab)
		{
			string text = Normalize(resourcePrefab);
			if (text.Contains("copper"))
			{
				return FindObjectDbItem("CopperOre", "Copper");
			}
			if (text.Contains("tin"))
			{
				return FindObjectDbItem("TinOre", "Tin");
			}
			if (text.Contains("obsidian"))
			{
				return FindObjectDbItem("Obsidian");
			}
			if (text.Contains("flametal"))
			{
				return FindObjectDbItem("FlametalOreNew", "FlametalOre", "FlametalNew", "Flametal");
			}
			if (text.Contains("blackmarble"))
			{
				return FindObjectDbItem("BlackMarble");
			}
			if (text.Contains("softtissue"))
			{
				return FindObjectDbItem("SoftTissue");
			}
			if (text.Contains("crystal"))
			{
				return FindObjectDbItem("Crystal");
			}
			if (text.Contains("guck"))
			{
				return FindObjectDbItem("Guck");
			}
			if (text.Contains("silver"))
			{
				return FindObjectDbItem("SilverOre", "Silver");
			}
			if (IsIronIdentity(text))
			{
				return FindObjectDbItem("IronScrap", "ScrapIron");
			}
			return FindObjectDbItem(resourcePrefab);
		}

		private static bool IsWishboneOnlyMineable(GameObject worldObject, string configuredName)
		{
			string text = (((Object)(object)worldObject == (Object)null) ? string.Empty : CleanPrefabName(((Object)worldObject).name ?? string.Empty));
			string text2 = Normalize(text + " " + (configuredName ?? string.Empty));
			if (!text2.Contains("silver"))
			{
				return IsIronIdentity(text2);
			}
			return true;
		}

		private static bool IsWishboneOnlyResourcePrefab(string prefabName)
		{
			string text = Normalize(prefabName);
			if (!(text == "silver") && !(text == "silverore"))
			{
				return IsIronIdentity(text);
			}
			return true;
		}

		private static bool IsIronIdentity(string normalized)
		{
			if (string.IsNullOrEmpty(normalized))
			{
				return false;
			}
			if (!normalized.Contains("ironscrap") && !normalized.Contains("scrapiron") && !normalized.Contains("muddyscrap") && !normalized.Contains("muddypile") && !normalized.Contains("muddy"))
			{
				return normalized.Contains("buriediron");
			}
			return true;
		}

		private bool ShouldSuppressOreObservation(string prefabName, Vector3 position, WayfinderPinSource source)
		{
			string text = Normalize(prefabName);
			if (source == WayfinderPinSource.AreaScan && (text == "silver" || text == "silverore" || IsIronIdentity(text)))
			{
				return true;
			}
			if (IsIronIdentity(text) && position.y > 3000f)
			{
				return true;
			}
			return false;
		}

		private static GameObject ResolveMineableResourceItem(GameObject worldObject, string configuredName, DropTable table)
		{
			string text = (((Object)(object)worldObject == (Object)null) ? string.Empty : CleanPrefabName(((Object)worldObject).name ?? string.Empty));
			string text2 = Normalize(text + " " + (configuredName ?? string.Empty));
			GameObject val = null;
			if (text2.Contains("copper"))
			{
				val = FindObjectDbItem("CopperOre", "Copper");
			}
			else if (text2.Contains("tin"))
			{
				val = FindObjectDbItem("TinOre", "Tin");
			}
			else if (text2.Contains("silver"))
			{
				val = FindObjectDbItem("SilverOre", "Silver");
			}
			else if (text2.Contains("obsidian"))
			{
				val = FindObjectDbItem("Obsidian");
			}
			else if (text2.Contains("flametal"))
			{
				val = FindObjectDbItem("FlametalOreNew", "FlametalOre", "FlametalNew", "Flametal");
			}
			else if (text2.Contains("muddy") || text2.Contains("scrapiron") || text2.Contains("ironscrap"))
			{
				val = FindObjectDbItem("IronScrap", "ScrapIron");
			}
			else if (text2.Contains("blackmarble"))
			{
				val = FindObjectDbItem("BlackMarble");
			}
			else if (text2.Contains("softtissue"))
			{
				val = FindObjectDbItem("SoftTissue");
			}
			else if (text2.Contains("crystal"))
			{
				val = FindObjectDbItem("Crystal");
			}
			else if (text2.Contains("guck"))
			{
				val = FindObjectDbItem("Guck");
			}
			if (!((Object)(object)val != (Object)null))
			{
				return FindPrimaryDrop(table);
			}
			return val;
		}

		private static GameObject FindObjectDbItem(params string[] prefabNames)
		{
			ObjectDB instance = ObjectDB.instance;
			if ((Object)(object)instance == (Object)null || prefabNames == null)
			{
				return null;
			}
			foreach (string text in prefabNames)
			{
				if (string.IsNullOrEmpty(text))
				{
					continue;
				}
				try
				{
					GameObject itemPrefab = instance.GetItemPrefab(text);
					if ((Object)(object)itemPrefab != (Object)null)
					{
						return itemPrefab;
					}
				}
				catch
				{
				}
				if (instance.m_items == null)
				{
					continue;
				}
				for (int j = 0; j < instance.m_items.Count; j++)
				{
					GameObject val = instance.m_items[j];
					if (!((Object)(object)val == (Object)null))
					{
						string a = CleanPrefabName(((Object)val).name ?? string.Empty);
						if (string.Equals(a, text, StringComparison.OrdinalIgnoreCase))
						{
							return val;
						}
					}
				}
			}
			return null;
		}

		private static bool IsSilverMineable(GameObject worldObject, string configuredName)
		{
			string text = (((Object)(object)worldObject == (Object)null) ? string.Empty : CleanPrefabName(((Object)worldObject).name ?? string.Empty));
			string text2 = Normalize(text + " " + (configuredName ?? string.Empty));
			return text2.Contains("silver");
		}

		private static bool IsSilverResourcePrefab(string prefabName)
		{
			string text = Normalize(prefabName);
			if (!(text == "silver"))
			{
				return text == "silverore";
			}
			return true;
		}

		private static GameObject FindPrimaryDrop(DropTable table)
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			if (table == null || table.m_drops == null || table.m_drops.Count == 0)
			{
				return null;
			}
			GameObject val = null;
			for (int i = 0; i < table.m_drops.Count; i++)
			{
				DropData val2 = table.m_drops[i];
				if (!((Object)(object)val2.m_item == (Object)null))
				{
					if ((Object)(object)val == (Object)null)
					{
						val = val2.m_item;
					}
					string prefabName = CleanPrefabName(((Object)val2.m_item).name ?? string.Empty);
					if (!IsGenericRockByproduct(prefabName))
					{
						return val2.m_item;
					}
				}
			}
			return val;
		}

		private static bool IsGenericRockByproduct(string prefabName)
		{
			return prefabName.Equals("Stone", StringComparison.OrdinalIgnoreCase);
		}

		private static bool WasHitByLocalPlayer(HitData hit)
		{
			if (hit == null || (Object)(object)Player.m_localPlayer == (Object)null)
			{
				return false;
			}
			Character attacker = hit.GetAttacker();
			return object.ReferenceEquals(attacker, Player.m_localPlayer);
		}

		private static string Localize(string rawName, string fallback)
		{
			if (string.IsNullOrEmpty(rawName))
			{
				return fallback;
			}
			try
			{
				if (Localization.instance != null)
				{
					return Localization.instance.Localize(rawName);
				}
			}
			catch
			{
			}
			return rawName;
		}

		private static string StableObjectKey(GameObject gameObject)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)gameObject == (Object)null)
			{
				return "missing";
			}
			Vector3 position = gameObject.transform.position;
			return CleanPrefabName(((Object)gameObject).name ?? "resource") + "@" + Mathf.RoundToInt(position.x * 10f) + ":" + Mathf.RoundToInt(position.y * 10f) + ":" + Mathf.RoundToInt(position.z * 10f);
		}

		private static string CleanPrefabName(string value)
		{
			if (!string.IsNullOrEmpty(value))
			{
				return value.Replace("(Clone)", string.Empty).Trim();
			}
			return string.Empty;
		}

		private static string Normalize(string value)
		{
			if (string.IsNullOrEmpty(value))
			{
				return string.Empty;
			}
			char[] array = new char[value.Length];
			int length = 0;
			for (int i = 0; i < value.Length; i++)
			{
				char c = char.ToLowerInvariant(value[i]);
				if (char.IsLetterOrDigit(c))
				{
					array[length++] = c;
				}
			}
			return new string(array, 0, length);
		}
	}
	internal sealed class RunestoneDiscovery
	{
		private static readonly MethodInfo IsExploredMethod = AccessTools.Method(typeof(Minimap), "IsExplored", new Type[1] { typeof(Vector3) }, (Type[])null);

		private readonly ManualLogSource _log;

		private readonly WayfinderConfig _config;

		private readonly WayfinderPinDatabase _database;

		private float _nextScanTime;

		private long _cleanedWorldUid = long.MinValue;

		private long _cacheWorldUid = long.MinValue;

		private RuneStone[] _cachedRunestones = (RuneStone[])(object)new RuneStone[0];

		private Vegvisir[] _cachedVegvisirs = (Vegvisir[])(object)new Vegvisir[0];

		private Vector3 _runestoneCacheCenter;

		private Vector3 _vegvisirCacheCenter;

		private float _nextRunestoneCacheRefresh;

		private float _nextVegvisirCacheRefresh;

		private bool _runestoneCacheInitialized;

		private bool _vegvisirCacheInitialized;

		private bool _refreshVegvisirNext;

		private bool _scanInProgress;

		private int _scanPhase;

		private int _scanCursor;

		private Vector3 _scanCenter;

		private float _scanRadiusSq;

		private int _scanRemembered;

		private long _scanWorldUid = long.MinValue;

		internal RunestoneDiscovery(ManualLogSource log, WayfinderConfig config, WayfinderPinDatabase database)
		{
			_log = log;
			_config = config;
			_database = database;
		}

		internal void Tick()
		{
			TickBudgeted(1000.0);
		}

		internal bool TickBudgeted(double budgetMs)
		{
			if (!_config.Enabled.Value || !_config.RememberGeneratedStructures.Value || _database.WorldUid == 0 || (Object)(object)Player.m_localPlayer == (Object)null)
			{
				ResetActiveScan();
				return false;
			}
			if (_scanWorldUid != _database.WorldUid)
			{
				_scanWorldUid = _database.WorldUid;
				ResetActiveScan();
			}
			long startTimestamp = DiscoveryWorkBudget.Start();
			if (_cleanedWorldUid != _database.WorldUid)
			{
				CleanupRememberedRunestones();
				_cleanedWorldUid = _database.WorldUid;
				if (DiscoveryWorkBudget.Expired(startTimestamp, budgetMs))
				{
					return true;
				}
			}
			if (!_scanInProgress)
			{
				if (Time.unscaledTime < _nextScanTime)
				{
					return false;
				}
				BeginScan();
				if (DiscoveryWorkBudget.Expired(startTimestamp, budgetMs))
				{
					return true;
				}
			}
			int num = 0;
			while (_scanPhase < 2)
			{
				if (_scanPhase == 0)
				{
					RuneStone[] array = _cachedRunestones;
					if (array == null)
					{
						array = (RuneStone[])(object)new RuneStone[0];
					}
					while (_scanCursor < array.Length)
					{
						RuneStone stone = array[_scanCursor++];
						num++;
						ProcessRunestone(stone);
						if (DiscoveryWorkBudget.Expired(startTimestamp, budgetMs))
						{
							return true;
						}
					}
					_scanPhase = 1;
					_scanCursor = 0;
					continue;
				}
				Vegvisir[] array2 = _cachedVegvisirs;
				if (array2 == null)
				{
					array2 = (Vegvisir[])(object)new Vegvisir[0];
				}
				while (_scanCursor < array2.Length)
				{
					Vegvisir vegvisir = array2[_scanCursor++];
					num++;
					ProcessVegvisir(vegvisir);
					if (DiscoveryWorkBudget.Expired(startTimestamp, budgetMs))
					{
						return true;
					}
				}
				_scanPhase = 2;
			}
			if (_config.DebugLogging.Value && _config.VerboseRuntimeLogging.Value && _scanRemembered > 0)
			{
				_log.LogInfo((object)("Runestone/Vegvisir discovery remembered/confirmed " + _scanRemembered + " stone(s)."));
			}
			_scanInProgress = false;
			_scanCursor = 0;
			_scanPhase = 0;
			return false;
		}

		private void BeginScan()
		{
			//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_0076: Unknown result type (might be due to invalid IL or missing references)
			_nextScanTime = Time.unscaledTime + Mathf.Max(1f, _config.StaticDiscoveryInterval.Value);
			_scanCenter = ((Component)Player.m_localPlayer).transform.position;
			float num = Mathf.Max(5f, _config.StructureDiscoveryRadius.Value);
			_scanRadiusSq = num * num;
			_scanRemembered = 0;
			_scanCursor = 0;
			_scanPhase = 0;
			RefreshOneSceneCacheIfNeeded(_scanCenter);
			_scanInProgress = true;
		}

		private void ProcessRunestone(RuneStone stone)
		{
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)stone == (Object)null || (Object)(object)((Component)stone).gameObject == (Object)null || (Object)(object)((Component)stone).GetComponent<Vegvisir>() != (Object)null || (Object)(object)((Component)stone).GetComponentInParent<Vegvisir>() != (Object)null)
			{
				return;
			}
			Vector3 position = ((Component)stone).transform.position;
			if (WithinHorizontalRadius(_scanCenter, position, _scanRadiusSq) && MayReveal(position))
			{
				string prefabName = GetPrefabName(((Component)stone).gameObject);
				if (!IsIgnoredStartStone(((Component)stone).transform, prefabName) && RememberRunestone(prefabName, "Runestone", position) != null)
				{
					_scanRemembered++;
				}
			}
		}

		private void ProcessVegvisir(Vegvisir vegvisir)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: 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_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: 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 ((Object)(object)vegvisir == (Object)null || (Object)(object)((Component)vegvisir).gameObject == (Object)null)
			{
				return;
			}
			Vector3 position = ((Component)vegvisir).transform.position;
			if (WithinHorizontalRadius(_scanCenter, position, _scanRadiusSq) && MayReveal(position))
			{
				string prefabName = GetPrefabName(((Component)vegvisir).gameObject);
				if (!IsIgnoredStartStone(((Component)vegvisir).transform, prefabName) && RememberRunestone(prefabName, "Vegvisir", position) != null)
				{
					_scanRemembered++;
				}
			}
		}

		private void ResetActiveScan()
		{
			_scanInProgress = false;
			_scanPhase = 0;
			_scanCursor = 0;
		}

		private void RefreshOneSceneCacheIfNeeded(Vector3 center)
		{
			//IL_01c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_018f: 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_0167: Unknown result type (might be due to invalid IL or missing references)
			//IL_0168: Unknown result type (might be due to invalid IL or missing references)
			if (_cacheWorldUid != _database.WorldUid)
			{
				_cacheWorldUid = _database.WorldUid;
				_cachedRunestones = (RuneStone[])(object)new RuneStone[0];
				_cachedVegvisirs = (Vegvisir[])(object)new Vegvisir[0];
				_runestoneCacheInitialized = false;
				_vegvisirCacheInitialized = false;
				_refreshVegvisirNext = false;
				_nextRunestoneCacheRefresh = 0f;
				_nextVegvisirCacheRefresh = 0f;
			}
			float num = Mathf.Max(12f, _config.StaticDiscoveryInterval.Value * 3f);
			float num2 = center.x - _runestoneCacheCenter.x;
			float num3 = center.z - _runestoneCacheCenter.z;
			bool flag = num2 * num2 + num3 * num3 >= 4096f;
			bool flag2 = !_runestoneCacheInitialized || _cachedRunestones == null || Time.unscaledTime >= _nextRunestoneCacheRefresh || flag;
			num2 = center.x - _vegvisirCacheCenter.x;
			num3 = center.z - _vegvisirCacheCenter.z;
			bool flag3 = num2 * num2 + num3 * num3 >= 4096f;
			bool flag4 = !_vegvisirCacheInitialized || _cachedVegvisirs == null || Time.unscaledTime >= _nextVegvisirCacheRefresh || flag3;
			if (flag2 && flag4)
			{
				if (_refreshVegvisirNext)
				{
					_cachedVegvisirs = LiveDiscoveryRegistry.SnapshotVegvisirs();
					_vegvisirCacheInitialized = true;
					_vegvisirCacheCenter = center;
					_nextVegvisirCacheRefresh = Time.unscaledTime + num;
				}
				else
				{
					_cachedRunestones = LiveDiscoveryRegistry.SnapshotRunestones();
					_runestoneCacheInitialized = true;
					_runestoneCacheCenter = center;
					_nextRunestoneCacheRefresh = Time.unscaledTime + num;
				}
				_refreshVegvisirNext = !_refreshVegvisirNext;
			}
			else if (flag2)
			{
				_cachedRunestones = LiveDiscoveryRegistry.SnapshotRunestones();
				_runestoneCacheInitialized = true;
				_runestoneCacheCenter = center;
				_nextRunestoneCacheRefresh = Time.unscaledTime + num;
			}
			else if (flag4)
			{
				_cachedVegvisirs = LiveDiscoveryRegistry.SnapshotVegvisirs();
				_vegvisirCacheInitialized = true;
				_vegvisirCacheCenter = center;
				_nextVegvisirCacheRefresh = Time.unscaledTime + num;
			}
		}

		private void CleanupRememberedRunestones()
		{
			IReadOnlyList<WayfinderPinRecord> records = _database.Records;
			if (records == null || records.Count == 0)
			{
				return;
			}
			List<string> list = new List<string>();
			List<WayfinderPinRecord> list2 = new List<WayfinderPinRecord>();
			for (int i = 0; i < records.Count; i++)
			{
				WayfinderPinRecord wayfinderPinRecord = records[i];
				if (wayfinderPinRecord != null && wayfinderPinRecord.category == WayfinderPinCategory.PointOfInterest && wayfinderPinRecord.source != WayfinderPinSource.Manual && wayfinderPinRecord.source != WayfinderPinSource.Imported && wayfinderPinRecord.source != WayfinderPinSource.Vanilla)
				{
					string name = (wayfinderPinRecord.subtype ?? string.Empty) + " " + (wayfinderPinRecord.displayName ?? string.Empty);
					if (WayfinderIconPolicy.IsBossGuidanceRunestoneName(name))
					{
						list.Add(wayfinderPinRecord.id);
					}
					else if ((string.Equals(wayfinderPinRecord.iconKey, "wayfinder:runestone", StringComparison.OrdinalIgnoreCase) || WayfinderIconPolicy.IsRunestoneName(name)) && !string.Equals(wayfinderPinRecord.iconKey, "wayfinder:runestone", StringComparison.OrdinalIgnoreCase))
					{
						wayfinderPinRecord.iconKey = "wayfinder:runestone";
						list2.Add(wayfinderPinRecord);
					}
				}
			}
			for (int j = 0; j < list.Count; j++)
			{
				_database.Remove(list[j], suppressAutoRediscovery: false);
			}
			for (int k = 0; k < list2.Count; k++)
			{
				_database.AddOrUpdate(list2[k]);
			}
			if (_config.DebugLogging.Value && (list.Count > 0 || list2.Count > 0))
			{
				_log.LogInfo((object)("Runestone cleanup removed " + list.Count + " boss-guidance marker(s) and repaired " + list2.Count + " runestone icon record(s)."));
			}
		}

		private WayfinderPinRecord RememberRunestone(string prefabName, string subtype, Vector3 position)
		{
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			string memberKey = "runestone:" + prefabName + "@" + Mathf.RoundToInt(position.x * 10f) + ":" + Mathf.RoundToInt(position.y * 10f) + ":" + Mathf.RoundToInt(position.z * 10f);
			return _database.AddPointObservation((!string.IsNullOrEmpty(prefabName)) ? prefabName : (string.Equals(subtype, "Vegvisir", StringComparison.OrdinalIgnoreCase) ? "Vegvisir" : "Runestone"), subtype, position, "wayfinder:runestone", WayfinderPinCategory.PointOfInterest, WayfinderPinSource.InteractionDiscovery, memberKey);
		}

		private static bool IsIgnoredStartStone(Transform transform, string prefabName)
		{
			if ((Object)(object)transform == (Object)null)
			{
				return true;
			}
			if (WayfinderIconPolicy.IsBossGuidanceRunestoneName(prefabName))
			{
				return true;
			}
			Transform val = transform;
			int num = 0;
			while ((Object)(object)val != (Object)null && num < 16)
			{
				if (WayfinderIconPolicy.IsBossGuidanceRunestoneName(((Object)(object)((Component)val).gameObject == (Object)null) ? string.Empty : ((Object)((Component)val).gameObject).name))
				{
					return true;
				}
				val = val.parent;
				num++;
			}
			return false;
		}

		private bool MayReveal(Vector3 position)
		{
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			if (_config.ScanUnexploredAreas.Value)
			{
				return true;
			}
			Minimap instance = Minimap.instance;
			if ((Object)(object)instance == (Object)null || IsExploredMethod == null)
			{
				return false;
			}
			try
			{
				object obj = IsExploredMethod.Invoke(instance, new object[1] { position });
				return obj is bool && (bool)obj;
			}
			catch
			{
				return false;
			}
		}

		private static string GetPrefabName(GameObject gameObject)
		{
			if ((Object)(object)gameObject == (Object)null)
			{
				return string.Empty;
			}
			try
			{
				string prefabName = Utils.GetPrefabName(gameObject);
				if (!string.IsNullOrEmpty(prefabName))
				{
					return prefabName.Replace("(Clone)", string.Empty).Trim();
				}
			}
			catch
			{
			}
			return (((Object)gameObject).name ?? string.Empty).Replace("(Clone)", string.Empty).Trim();
		}

		private static bool WithinHorizontalRadius(Vector3 a, Vector3 b, float radiusSq)
		{
			float num = a.x - b.x;
			float num2 = a.z - b.z;
			return num * num + num2 * num2 <= radiusSq;
		}
	}
	internal sealed class SpawnerDiscovery
	{
		private const float DungeonInteriorY = 3000f;

		private static readonly MethodInfo IsExploredMethod = AccessTools.Method(typeof(Minimap), "IsExplored", new Type[1] { typeof(Vector3) }, (Type[])null);

		private readonly ManualLogSource _log;

		private readonly WayfinderConfig _config;

		private readonly WayfinderPinDatabase _database;

		private readonly RuntimeIconRegistry _icons;

		private float _nextScanTime;

		private SpawnArea[] _cachedSpawnAreas = (SpawnArea[])(object)new SpawnArea[0];

		private Vector3 _spawnAreaCacheCenter;

		private float _nextSpawnAreaCacheRefresh;

		private bool _spawnAreaCacheInitialized;

		private long _spawnAreaCacheWorldUid = long.MinValue;

		private bool _scanInProgress;

		private SpawnArea[] _scanAreas = (SpawnArea[])(object)new SpawnArea[0];

		private int _scanCursor;

		private Vector3 _scanCenter;

		private float _scanRadiusSq;

		private int _scanRemembered;

		private long _scanWorldUid = long.MinValue;

		private static readonly FieldInfo[] SpawnAreaFields = typeof(SpawnArea).GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);

		internal SpawnerDiscovery(ManualLogSource log, WayfinderConfig config, WayfinderPinDatabase database, RuntimeIconRegistry icons)
		{
			_log = log;
			_config = config;
			_database = database;
			_icons = icons;
		}

		internal void Tick()
		{
			TickBudgeted(1000.0);
		}

		internal bool TickBudgeted(double budgetMs)
		{
			if (!_config.Enabled.Value || !_config.RememberPhysicalSpawners.Value || _database.WorldUid == 0 || (Object)(object)Player.m_localPlayer == (Object)null)
			{
				ResetActiveScan();
				return false;
			}
			if (_scanWorldUid != _database.WorldUid)
			{
				_scanWorldUid = _database.WorldUid;
				ResetActiveScan();
			}
			long startTimestamp = DiscoveryWorkBudget.Start();
			if (!_scanInProgress)
			{
				if (Time.unscaledTime < _nextScanTime)
				{
					return false;
				}
				BeginScan();
				if (DiscoveryWorkBudget.Expired(startTimestamp, budgetMs))
				{
					return true;
				}
			}
			int num = 0;
			while (_scanCursor < _scanAreas.Length)
			{
				SpawnArea area = _scanAreas[_scanCursor++];
				num++;
				ProcessSpawnArea(area);
				if (DiscoveryWorkBudget.Expired(startTimestamp, budgetMs))
				{
					return true;
				}
			}
			if (_config.DebugLogging.Value && _config.VerboseRuntimeLogging.Value && _scanRemembered > 0)
			{
				_log.LogInfo((object)("Physical spawner discovery remembered/confirmed " + _scanRemembered + " spawner locations."));
			}
			_scanInProgress = false;
			_scanAreas = (SpawnArea[])(object)new SpawnArea[0];
			_scanCursor = 0;
			return false;
		}

		private void BeginScan()
		{
			//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_0062: Unknown result type (might be due to invalid IL or missing references)
			_nextScanTime = Time.unscaledTime + Mathf.Max(1f, _config.StaticDiscoveryInterval.Value);
			_scanCenter = ((Component)Player.m_localPlayer).transform.position;
			float num = Mathf.Max(5f, _config.SpawnerDiscoveryRadius.Value);
			_scanRadiusSq = num * num;
			_scanAreas = GetCachedSpawnAreas(_scanCenter);
			if (_scanAreas == null)
			{
				_scanAreas = (SpawnArea[])(object)new SpawnArea[0];
			}
			_scanCursor = 0;
			_scanRemembered = 0;
			_scanInProgress = true;
		}

		private void ProcessSpawnArea(SpawnArea area)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: 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_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)area == (Object)null || (Object)(object)((Component)area).gameObject == (Object)null)
			{
				return;
			}
			Vector3 position = ((Component)area).transform.position;
			if (position.y > 3000f || !WithinHorizontalRadius(_scanCenter, position, _scanRadiusSq) || !MayReveal(position))
			{
				return;
			}
			List<GameObject> list = ExtractSpawnPrefabs(area);
			if (list.Count != 0 && TryGetSpawnerIdentity(((Component)area).gameObject, list, out var creatureLookup, out var subtype, out var displayName) && (!string.Equals(creatureLookup, "Surtling", StringComparison.OrdinalIgnoreCase) || _config.AutoPinSurtlingSpawners.Value))
			{
				WayfinderPinRecord wayfinderPinRecord = _database.AddPointObservation(subtype, displayName, position, "wayfinder:spawner", WayfinderPinCategory.Spawner, WayfinderPinSource.InteractionDiscovery, BuildSpawnerKey(subtype, position));
				if (wayfinderPinRecord != null)
				{
					_scanRemembered++;
				}
			}
		}

		private void ResetActiveScan()
		{
			_scanInProgress = false;
			_scanAreas = (SpawnArea[])(object)new SpawnArea[0];
			_scanCursor = 0;
		}

		private SpawnArea[] GetCachedSpawnAreas(Vector3 center)
		{
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			float num = center.x - _spawnAreaCacheCenter.x;
			float num2 = center.z - _spawnAreaCacheCenter.z;
			bool flag = num * num + num2 * num2 >= 4096f;
			if (!_spawnAreaCacheInitialized || _spawnAreaCacheWorldUid != _database.WorldUid || _cachedSpawnAreas == null || Time.unscaledTime >= _nextSpawnAreaCacheRefresh || flag)
			{
				_cachedSpawnAreas = LiveDiscoveryRegistry.SnapshotSpawnAreas();
				_spawnAreaCacheInitialized = true;
				_spawnAreaCacheWorldUid = _database.WorldUid;
				_spawnAreaCacheCenter = center;
				float num3 = Mathf.Max(12f, _config.StaticDiscoveryInterval.Value * 3f);
				_nextSpawnAreaCacheRefresh = Time.unscaledTime + num3;
			}
			return _cachedSpawnAreas;
		}

		private static List<GameObject> ExtractSpawnPrefabs(SpawnArea area)
		{
			List<GameObject> result = new List<GameObject>();
			if ((Object)(object)area == (Object)null)
			{
				return result;
			}
			try
			{
				for (int i = 0; i < SpawnAreaFields.Length; i++)
				{
					object value = null;
					try
					{
						value = SpawnAreaFields[i].GetValue(area);
					}
					catch
					{
					}
					AddSpawnPrefabsFromValue(value, result);
				}
			}
			catch
			{
			}
			return result;
		}

		private static void AddSpawnPrefabsFromValue(object value, List<GameObject> result)
		{
			if (value == null || result == null || value is string)
			{
				return;
			}
			GameObject val = (GameObject)((value is GameObject) ? value : null);
			if ((Object)(object)val != (Object)null)
			{
				AddUnique(result, val);
			}
			else
			{
				if (!(value is IEnumerable enumerable))
				{
					return;
				}
				foreach (object item in enumerable)
				{
					if (item == null)
					{
						continue;
					}
					GameObject val2 = (GameObject)((item is GameObject) ? item : null);
					if ((Object)(object)val2 != (Object)null)
					{
						AddUnique(result, val2);
						continue;
					}
					Type type = item.GetType();
					FieldInfo[] fields = type.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
					for (int i = 0; i < fields.Length; i++)
					{
						if (!typeof(GameObject).IsAssignableFrom(fields[i].FieldType))
						{
							continue;
						}
						string text = Normalize(fields[i].Name);
						if (!text.Contains("prefab") && !text.Contains("creature") && !text.Contains("spawn"))
						{
							continue;
						}
						try
						{
							object? value2 = fields[i].GetValue(item);
							GameObject val3 = (GameObject)((value2 is GameObject) ? value2 : null);
							if ((Object)(object)val3 != (Object)null)
							{
								AddUnique(result, val3);
							}
						}
						catch
						{
						}
					}
					PropertyInfo[] properties = type.GetProperties(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
					for (int j = 0; j < properties.Length; j++)
					{
						if (!properties[j].CanRead || !typeof(GameObject).IsAssignableFrom(properties[j].PropertyType))
						{
							continue;
						}
						string text2 = Normalize(properties[j].Name);
						if (!text2.Contains("prefab") && !text2.Contains("creature") && !text2.Contains("spawn"))
						{
							continue;
						}
						try
						{
							object? value3 = properties[j].GetValue(item, null);
							GameObject val4 = (GameObject)((value3 is GameObject) ? value3 : null);
							if ((Object)(object)val4 != (Object)null)
							{
								AddUnique(result, val4);
							}
						}
						catch
						{
						}
					}
				}
			}
		}

		private static void AddUnique(List<GameObject> list, GameObject value)
		{
			if ((Object)(object)value == (Object)null)
			{
				return;
			}
			for (int i = 0; i < list.Count; i++)
			{
				if (object.ReferenceEquals(list[i], value))
				{
					return;
				}
			}
			list.Add(value);
		}

		private static bool TryGetSpawnerIdentity(GameObject worldObject, List<GameObject> spawnPrefabs, out string creatureLookup, out string subtype, out string displayName)
		{
			creatureLookup = string.Empty;
			subtype = string.Empty;
			displayName = string.Empty;
			if (spawnPrefabs == null || spawnPrefabs.Count == 0)
			{
				return false;
			}
			string prefabName = GetPrefabName(worldObject);
			string text = Normalize(prefabName);
			string text2 = string.Empty;
			for (int i = 0; i < spawnPrefabs.Count; i++)
			{
				GameObject val = spawnPrefabs[i];
				if ((Object)(object)val == (Object)null)
				{
					continue;
				}
				string prefabName2 = GetPrefabName(val);
				if (!string.IsNullOrEmpty(prefabName2))
				{
					if (string.IsNullOrEmpty(text2))
					{
						text2 = HumanizeCreatureName(prefabName2);
					}
					string text3 = Normalize(prefabName2);
					if (text3.Contains("surtling"))
					{
						creatureLookup = "Surtling";
						subtype = "SurtlingSpawner";
						displayName = "Surtling Spawner";
						return true;
					}
					if (text3.Contains("greydwarf"))
					{
						creatureLookup = "Greydwarf";
						subtype = "GreydwarfNest";
						displayName = "Greydwarf Nest";
						return true;
					}
					if (text3.Contains("skeleton") || text3.Contains("rancidremains"))
					{
						creatureLookup = "Skeleton";
						subtype = "SkeletonSpawner";
						displayName = (text.Contains("bonepile") ? "Evil Bone Pile" : "Skeleton Spawner");
						return true;
					}
					if (text3.Contains("draugr"))
					{
						creatureLookup = "Draugr";
						subtype = "DraugrSpawner";
						displayName = (text.Contains("bodypile") ? "Body Pile" : "Draugr Spawner");
						return true;
					}
					if (text3.Contains("charred") || text3.Contains("twitcher"))
					{
						creatureLookup = "Charred";
						subtype = "CharredSpawner";
						displayName = HumanizeSpawnerWorldName(prefabName, "Charred Spawner");
						return true;
					}
				}
			}
			if (string.IsNullOrEmpty(text2))
			{
				return false;
			}
			creatureLookup = text2;
			subtype = Normalize(text2) + "Spawner";
			displayName = HumanizeSpawnerWorldName(prefabName, text2 + " Spawner");
			return true;
		}

		private static string HumanizeSpawnerWorldName(string worldName, string fallback)
		{
			string text = Normalize(worldName);
			if (text.Contains("monumentoftorment"))
			{
				return "Monument of Torment";
			}
			if (text.Contains("effigyofmalice"))
			{
				return "Effigy of Malice";
			}
			if (text.Contains("greydwarfnest"))
			{
				return "Greydwarf Nest";
			}
			if (text.Contains("bonepile"))
			{
				return "Evil Bone Pile";
			}
			if (text.Contains("bodypile"))
			{
				return "Body Pile";
			}
			return fallback;
		}

		private static string HumanizeCreatureName(string prefabName)
		{
			if (string.IsNullOrEmpty(prefabName))
			{
				return "Creature";
			}
			string text = prefabName.Replace("(Clone)", string.Empty).Replace('_', ' ').Trim();
			if (text.IndexOf("Greydwarf", StringComparison.OrdinalIgnoreCase) >= 0)
			{
				return "Greydwarf";
			}
			if (text.IndexOf("Surtling", StringComparison.OrdinalIgnoreCase) >= 0)
			{
				return "Surtling";
			}
			if (text.IndexOf("Skeleton", StringComparison.OrdinalIgnoreCase) >= 0)
			{
				return "Skeleton";
			}
			if (text.IndexOf("Draugr", StringComparison.OrdinalIgnoreCase) >= 0)
			{
				return "Draugr";
			}
			return text;
		}

		private static string GetPrefabName(GameObject gameObject)
		{
			if ((Object)(object)gameObject == (Object)null)
			{
				return string.Empty;
			}
			try
			{
				string prefabName = Utils.GetPrefabName(gameObject);
				if (!string.IsNullOrEmpty(prefabName))
				{
					return prefabName.Replace("(Clone)", string.Empty).Trim();
				}
			}
			catch
			{
			}
			return (((Object)gameObject).name ?? string.Empty).Replace("(Clone)", string.Empty).Trim();
		}

		private bool MayReveal(Vector3 position)
		{
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			if (_config.ScanUnexploredAreas.Value)
			{
				return true;
			}
			Minimap instance = Minimap.instance;
			if ((Object)(object)instance == (Object)null || IsExploredMethod == null)
			{
				return false;
			}
			try
			{
				object obj = IsExploredMethod.Invoke(instance, new object[1] { position });
				return obj is bool && (bool)obj;
			}
			catch
			{
				return false;
			}
		}

		private static string BuildSpawnerKey(string type, Vector3 position)
		{
			return "spawner:" + type + "@" + Mathf.RoundToInt(position.x * 10f) + ":" + Mathf.RoundToInt(position.y * 10f) + ":" + Mathf.RoundToInt(position.z * 10f);
		}

		private static bool WithinHorizontalRadius(Vector3 a, Vector3 b, float radiusSq)
		{
			float num = a.x - b.x;
			float num2 = a.z - b.z;
			return num * num + num2 * num2 <= radiusSq;
		}

		private static string Normalize(string value)
		{
			if (string.IsNullOrEmpty(value))
			{
				return string.Empty;
			}
			char[] array = new char[value.Length];
			int length = 0;
			for (int i = 0; i < value.Length; i++)
			{
				char c = char.ToLowerInvariant(value[i]);
				if (char.IsLetterOrDigit(c))
				{
					array[length++] = c;
				}
			}
			return new string(array, 0, length);
		}
	}
	internal sealed class StructureDiscovery
	{
		private static readonly MethodInfo IsExploredMethod = AccessTools.Method(typeof(Minimap), "IsExplored", new Type[1] { typeof(Vector3) }, (Type[])null);

		private static readonly FieldInfo PinsField = AccessTools.Field(typeof(Minimap), "m_pins");

		private readonly ManualLogSource _log;

		private readonly WayfinderConfig _config;

		private readonly WayfinderPinDatabase _database;

		private readonly RuntimeIconRegistry _icons;

		private float _nextScanTime;

		private long _cleanupWorldUid = long.MinValue;

		private Location[] _cachedLocations = (Location[])(object)new Location[0];

		private Vector3 _locationCacheCenter;

		private float _nextLocationCacheRefresh;

		private bool _locationCacheInitialized;

		private bool _scanInProgress;

		private Location[] _scanLocations = (Location[])(object)new Location[0];

		private int _scanCursor;

		private Vector3 _scanCenter;

		private float _scanRadiusSq;

		private int _scanRemembered;

		private int _scanRevisionBefore;

		private bool _scanFinishPending;

		private long _scanWorldUid = long.MinValue;

		internal StructureDiscovery(ManualLogSource log, WayfinderConfig config, WayfinderPinDatabase database, RuntimeIconRegistry icons)
		{
			_log = log;
			_config = config;
			_database = database;
			_icons = icons;
		}

		internal void Tick()
		{
			TickBudgeted(1000.0);
		}

		internal bool TickBudgeted(double budgetMs)
		{
			if (!_config.Enabled.Value || !_config.RememberGeneratedStructures.Value || _database.WorldUid == 0 || (Object)(object)Player.m_localPlayer == (Object)null)
			{
				ResetActiveScan();
				return false;
			}
			if (_scanWorldUid != _database.WorldUid)
			{
				_scanWorldUid = _database.WorldUid;
				ResetActiveScan();
			}
			long startTimestamp = DiscoveryWorkBudget.Start();
			if (!_scanInProgress)
			{
				if (Time.unscaledTime < _nextScanTime)
				{
					return false;
				}
				BeginScan();
				if (DiscoveryWorkBudget.Expired(startTimestamp, budgetMs))
				{
					return true;
				}
			}
			int num = 0;
			while (!_scanFinishPending && _scanCursor < _scanLocations.Length)
			{
				Location location = _scanLocations[_scanCursor++];
				num++;
				ProcessLocation(location);
				if (DiscoveryWorkBudget.Expired(startTimestamp, budgetMs))
				{
					return true;
				}
			}
			_scanFinishPending = true;
			if (DiscoveryWorkBudget.Expired(startTimestamp, budgetMs))
			{
				return true;
			}
			FinishScan();
			return false;
		}

		private void BeginScan()
		{
			//IL_015d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0162: Unknown result type (might be due to invalid IL or missing references)
			//IL_019f: Unknown result type (might be due to invalid IL or missing references)
			_nextScanTime = Time.unscaledTime + Mathf.Max(1f, _config.StaticDiscoveryInterval.Value);
			if (_cleanupWorldUid != _database.WorldUid)
			{
				_cleanupWorldUid = _database.WorldUid;
				_locationCacheInitialized = false;
				_database.RemoveAutoPointSubtypesContaining("greydwarfnest", "spawner", "bonepile", "bodypile", "monumentoftorment", "elite monument of torment", "effigyofmalice", "firehole", "surtling");
				int num = NormalizeExistingGeneratedLocationMetadata();
				if (_config.DebugLogging.Value && num > 0)
				{
					_log.LogInfo((object)("Normalized " + num + " existing generated-location category/name/art record(s)."));
				}
				int num2 = _database.CollapseNearbyAutoPoints(delegate(WayfinderPinRecord record)
				{
					if (record == null || record.category == WayfinderPinCategory.Portal || !WayfinderIconPolicy.IsGeneratedLocationCategory(record.category))
					{
						return (string)null;
					}
					string defaultIconKey = WayfinderIconPolicy.GetDefaultIconKey(record);
					return (!string.IsNullOrEmpty(defaultIconKey)) ? ("generated:" + defaultIconKey) : null;
				}, 18f);
				if (_config.DebugLogging.Value && num2 > 0)
				{
					_log.LogInfo((object)("Collapsed " + num2 + " overlapping generated-location marker(s) into one site marker."));
				}
			}
			_scanCenter = ((Component)Player.m_localPlayer).transform.position;
			float num3 = Mathf.Max(5f, _config.StructureDiscoveryRadius.Value);
			_scanRadiusSq = num3 * num3;
			_scanRevisionBefore = _database.Revision;
			_scanLocations = GetCachedLocations(_scanCenter);
			if (_scanLocations == null)
			{
				_scanLocations = (Location[])(object)new Location[0];
			}
			_scanCursor = 0;
			_scanRemembered = 0;
			_scanFinishPending = false;
			_scanInProgress = true;
		}

		private void ProcessLocation(Location location)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: 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_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: 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)
			if ((Object)(object)location == (Object)null || (Object)(object)((Component)location).gameObject == (Object)null)
			{
				return;
			}
			Vector3 position = ((Component)location).transform.position;
			if (!WithinHorizontalRadius(_scanCenter, position, _scanRadiusSq) || !MayReveal(position))
			{
				return;
			}
			string locationPrefabName = GetLocationPrefabName(location);
			if (string.IsNullOrEmpty(locationPrefabName) || ShouldLeaveToVanillaPins(locationPrefabName) || LooksLikePhysicalSpawner(locationPrefabName))
			{
				return;
			}
			string memberKey = BuildLocationKey(locationPrefabName, position);
			WayfinderPinCategory category = WayfinderIconPolicy.ClassifyGeneratedLocation(locationPrefabName);
			string displayName = WayfinderIconPolicy.GetGeneratedLocationDisplayName(locationPrefabName);
			string iconKey = WayfinderIconPolicy.GetGeneratedLocationIconKey(locationPrefabName, category);
			if (TryGetBossInfo(locationPrefabName, out var displayName2, out var trophyLookup))
			{
				category = WayfinderPinCategory.Boss;
				displayName = displayName2;
				if (HasVanillaBossPinNear(position, 30f))
				{
					return;
				}
				if (_icons != null && _icons.IsBuilt)
				{
					WayfinderIconEntry wayfinderIconEntry = _icons.FindBestBossTrophy(trophyLookup);
					if (wayfinderIconEntry != null)
					{
						iconKey = wayfinderIconEntry.Key;
					}
				}
			}
			WayfinderPinRecord wayfinderPinRecord = _database.AddPointObservation(locationPrefabName, displayName, position, iconKey, category, WayfinderPinSource.InteractionDiscovery, memberKey);
			if (wayfinderPinRecord != null)
			{
				_scanRemembered++;
			}
		}

		private void FinishScan()
		{
			int num = 0;
			if (_database.Revision != _scanRevisionBefore)
			{
				num = _database.CollapseNearbyAutoPoints(delegate(WayfinderPinRecord record)
				{
					if (record == null || record.category == WayfinderPinCategory.Portal || !WayfinderIconPolicy.IsGeneratedLocationCategory(record.category))
					{
						return (string)null;
					}
					string defaultIconKey = WayfinderIconPolicy.GetDefaultIconKey(record);
					return (!string.IsNullOrEmpty(defaultIconKey)) ? ("generated:" + defaultIconKey) : null;
				}, 18f);
			}
			if (_config.DebugLogging.Value && _config.VerboseRuntimeLogging.Value && (_scanRemembered > 0 || num > 0))
			{
				_log.LogInfo((object)("Structure discovery remembered/confirmed " + _scanRemembered + " generated POIs and collapsed " + num + " overlapping site marker(s)."));
			}
			_scanInProgress = false;
			_scanFinishPending = false;
			_scanLocations = (Location[])(object)new Location[0];
			_scanCursor = 0;
		}

		private void ResetActiveScan()
		{
			_scanInProgress = false;
			_scanFinishPending = false;
			_scanLocations = (Location[])(object)new Location[0];
			_scanCursor = 0;
		}

		private Location[] GetCachedLocations(Vector3 center)
		{
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			float num = center.x - _locationCacheCenter.x;
			float num2 = center.z - _locationCacheCenter.z;
			bool flag = num * num + num2 * num2 >= 4096f;
			if (!_locationCacheInitialized || _cachedLocations == null || Time.unscaledTime >= _nextLocationCacheRefresh || flag)
			{
				_cachedLocations = LiveDiscoveryRegistry.SnapshotLocations();
				_locationCacheInitialized = true;
				_locationCacheCenter = center;
				float num3 = Mathf.Max(12f, _config.StaticDiscoveryInterval.Value * 3f);
				_nextLocationCacheRefresh = Time.unscaledTime + num3;
			}
			return _cachedLocations;
		}

		private static string GetLocationPrefabName(Location location)
		{
			if ((Object)(object)location == (Object)null || (Object)(object)((Component)location).gameObject == (Object)null)
			{
				return string.Empty;
			}
			try
			{
				string prefabName = Utils.GetPrefabName(((Component)location).gameObject);
				if (!string.IsNullOrEmpty(prefabName))
				{
					return CleanPrefabName(prefabName);
				}
			}
			catch
			{
			}
			return CleanPrefabName(((Object)((Component)location).gameObject).name ?? string.Empty);
		}

		private static string CleanPrefabName(string value)
		{
			if (string.IsNullOrEmpty(value))
			{
				return string.Empty;
			}
			return value.Replace("(Clone)", string.Empty).Trim();
		}

		private bool MayReveal(Vector3 position)
		{
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			if (_config.ScanUnexploredAreas.Value)
			{
				return true;
			}
			Minimap instance = Minimap.instance;
			if ((Object)(object)instance == (Object)null || IsExploredMethod == null)
			{
				return false;
			}
			try
			{
				object obj = IsExploredMethod.Invoke(instance, new object[1] { position });
				return obj is bool && (bool)obj;
			}
			catch
			{
				return false;
			}
		}

		private int NormalizeExistingGeneratedLocationMetadata()
		{
			//IL_011d: Unknown result type (might be due to invalid IL or missing references)
			IReadOnlyList<WayfinderPinRecord> records = _database.Records;
			if (records == null)
			{
				return 0;
			}
			List<WayfinderPinRecord> list = new List<WayfinderPinRecord>();
			List<string> list2 = new List<string>();
			for (int i = 0; i < records.Count; i++)
			{
				WayfinderPinRecord wayfinderPinRecord = records[i];
				if (wayfinderPinRecord == null || wayfinderPinRecord.source == WayfinderPinSource.Manual || wayfinderPinRecord.source == WayfinderPinSource.Imported || wayfinderPinRecord.source == WayfinderPinSource.Vanilla || !IsGeneratedLocationRecord(wayfinderPinRecord))
				{
					continue;
				}
				if (IsIgnoredGeneratedLocationNoise(wayfinderPinRecord.subtype))
				{
					if (!string.IsNullOrEmpty(wayfinderPinRecord.id))
					{
						list2.Add(wayfinderPinRecord.id);
					}
				}
				else
				{
					if (wayfinderPinRecord.category == WayfinderPinCategory.Boss || wayfinderPinRecord.category == WayfinderPinCategory.Trader || wayfinderPinRecord.category == WayfinderPinCategory.Portal || wayfinderPinRecord.category == WayfinderPinCategory.Spawner || WayfinderIconPolicy.IsRunestoneName(wayfinderPinRecord.subtype) || string.Equals(wayfinderPinRecord.iconKey, "wayfinder:runestone", StringComparison.OrdinalIgnoreCase) || TraderIdentity.IsTraderLocationPrefab(wayfinderPinRecord.subtype))
					{
						continue;
					}
					WayfinderPinCategory wayfinderPinCategory;
					string text;
					string text2;
					if (TryGetBossInfo(wayfinderPinRecord.subtype, out var displayName, out var trophyLookup))
					{
						if (HasVanillaBossPinNear(wayfinderPinRecord.Position, 30f))
						{
							if (!string.IsNullOrEmpty(wayfinderPinRecord.id))
							{
								list2.Add(wayfinderPinRecord.id);
							}
							continue;
						}
						wayfinderPinCategory = WayfinderPinCategory.Boss;
						text = displayName;
						text2 = wayfinderPinRecord.iconKey;
						if (_icons != null && _icons.IsBuilt)
						{
							WayfinderIconEntry wayfinderIconEntry = _icons.FindBestBossTrophy(trophyLookup);
							if (wayfinderIconEntry != null && !string.IsNullOrEmpty(wayfinderIconEntry.Key))
							{
								text2 = wayfinderIconEntry.Key;
							}
						}
						if (string.IsNullOrEmpty(text2))
						{
							text2 = "wayfinder:creature";
						}
					}
					else
					{
						wayfinderPinCategory = WayfinderIconPolicy.ClassifyGeneratedLocation(wayfinderPinRecord.subtype);
						text = WayfinderIconPolicy.GetGeneratedLocationDisplayName(wayfinderPinRecord.subtype);
						text2 = WayfinderIconPolicy.GetGeneratedLocationIconKey(wayfinderPinRecord.subtype, wayfinderPinCategory);
					}
					bool flag = false;
					if (wayfinderPinRecord.category != wayfinderPinCategory)
					{
						wayfinderPinRecord.category = wayfinderPinCategory;
						flag = true;
					}
					if (!string.IsNullOrEmpty(text) && !string.Equals(wayfinderPinRecord.displayName, text, StringComparison.Ordinal))
					{
						wayfinderPinRecord.displayName = text;
						flag = true;
					}
					if (!string.IsNullOrEmpty(text2) && !string.Equals(wayfinderPinRecord.iconKey, text2, StringComparison.OrdinalIgnoreCase))
					{
						wayfinderPinRecord.iconKey = text2;
						flag = true;
					}
					if (flag)
					{
						list.Add(wayfinderPinRecord);
					}
				}
			}
			for (int j = 0; j < list2.Count; j++)
			{
				_database.Remove(list2[j], suppressAutoRediscovery: false);
			}
			for (int k = 0; k < list.Count; k++)
			{
				_database.AddOrUpdate(list[k]);
			}
			return list.Count + list2.Count;
		}

		private static bool IsGeneratedLocationRecord(WayfinderPinRecord record)
		{
			if (record == null || record.members == null)
			{
				return false;
			}
			for (int i = 0; i < record.members.Count; i++)
			{
				WayfinderClusterMember wayfinderClusterMember = record.members[i];
				if (wayfinderClusterMember != null && !string.IsNullOrEmpty(wayfinderClusterMember.key) && wayfinderClusterMember.key.StartsWith("location:", StringComparison.OrdinalIgnoreCase))
				{
					return true;
				}
			}
			return false;
		}

		private static bool ShouldLeaveToVanillaPins(string prefabName)
		{
			string text = Normalize(prefabName);
			if (text.Length == 0)
			{
				return true;
			}
			if (IsIgnoredGeneratedLocationNoise(prefabName))
			{
				return true;
			}
			if (WayfinderIconPolicy.IsVegvisirName(prefabName))
			{
				return true;
			}
			if (text.Contains("starttemple") || text.Contains("sacrificial") || WayfinderIconPolicy.IsBossGuidanceRunestoneName(prefabName))
			{
				return true;
			}
			if (TraderIdentity.IsTraderLocationPrefab(prefabName) || text.Contains("merchant") || text.Contains("haldor") || text.Contains("hildir") || text.Contains("bogwitch"))
			{
				return true;
			}
			return false;
		}

		private static bool IsIgnoredGeneratedLocationNoise(string prefabName)
		{
			string text = Normalize(prefabName);
			if (text.Length == 0)
			{
				return false;
			}
			if (!text.Contains("infestedtree"))
			{
				return text.Contains("greydwarfcamp");
			}
			return true;
		}

		private static bool LooksLikePhysicalSpawner(string prefabName)
		{
			string text = Normalize(prefabName);
			if (text.Length == 0)
			{
				return false;
			}
			if (!text.Contains("greydwarfnest") && !text.Contains("spawner") && !text.Contains("bonepile") && !text.Contains("bodypile") && !text.Contains("monumentoftorment") && !text.Contains("effigyofmalice") && !text.Contains("firehole"))
			{
				return text.Contains("surtling");
			}
			return true;
		}

		private static bool TryGetBossInfo(string prefabName, out string displayName, out string trophyLookup)
		{
			displayName = string.Empty;
			trophyLookup = string.Empty;
			string text = Normalize(prefabName);
			if (text.Contains("eikthyrnir") || text.Contains("eikthyr"))
			{
				displayName = "Eikthyr";
				trophyLookup = "Eikthyr";
				return true;
			}
			if (text.Contains("gdking") || text.Contains("theelder") || text == "elder")
			{
				displayName = "The Elder";
				trophyLookup = "Elder";
				return true;
			}
			if (text.Contains("bonemass"))
			{
				displayName = "Bonemass";
				trophyLookup = "Bonemass";
				return true;
			}
			if (text.Contains("dragonqueen") || text.Contains("moder"))
			{
				displayName = "Moder";
				trophyLookup = "Moder";
				return true;
			}
			if (text.Contains("goblinking") || text.Contains("yagluth"))
			{
				displayName = "Yagluth";
				trophyLookup = "Yagluth";
				return true;
			}
			if (text.Contains("seekerqueen") || text.Contains("queenboss") || text.Contains("mistlandsdvergrbossentrance") || text.Contains("dvergrbossentrance"))
			{
				displayName = "The Queen";
				trophyLookup = "Queen";
				return true;
			}
			if (text.Contains("fader") || text.Contains("faderboss"))
			{
				displayName = "Fader";
				trophyLookup = "Fader";
				return true;
			}
			return false;
		}

		private static bool HasVanillaBossPinNear(Vector3 position, float radius)
		{
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Invalid comparison between Unknown and I4
			Minimap instance = Minimap.instance;
			if ((Object)(object)instance == (Object)null || PinsField == null)
			{
				return false;
			}
			try
			{
				if (!(PinsField.GetValue(instance) is List<PinData> list))
				{
					return false;
				}
				float num = radius * radius;
				for (int i = 0; i < list.Count; i++)
				{
					PinData val = list[i];
					if (val != null && (int)val.m_type == 9)
					{
						float num2 = val.m_pos.x - position.x;
						float num3 = val.m_pos.z - position.z;
						if (num2 * num2 + num3 * num3 <= num)
						{
							return true;
						}
					}
				}
			}
			catch
			{
			}
			return false;
		}

		private static WayfinderPinCategory ClassifyLocation(string prefabName)
		{
			string text = Normalize(prefabName);
			if (text.Contains("crypt") || text.Contains("burial") || text.Contains("cave") || text.Contains("mine") || text.Contains("tomb") || text.Contains("dungeon") || text.Contains("citadel") || text.Contains("sealedtower") || text.Contains("howlingcavern") || text.Contains("putridhole"))
			{
				return WayfinderPinCategory.Dungeon;
			}
			return WayfinderPinCategory.PointOfInterest;
		}

		private static string HumanizePrefabName(string prefabName)
		{
			if (string.IsNullOrEmpty(prefabName))
			{
				return "Point of Interest";
			}
			string text = prefabName.Replace("(Clone)", string.Empty).Replace('_', ' ').Trim();
			StringBuilder stringBuilder = new StringBuilder(text.Length + 8);
			char c = '\0';
			for (int i = 0; i < text.Length; i++)
			{
				char c2 = text[i];
				if (i > 0 && c2 != ' ' && c != ' ' && ((char.IsUpper(c2) && char.IsLower(c)) || (char.IsDigit(c2) && !char.IsDigit(c))))
				{
					stringBuilder.Append(' ');
				}
				stringBuilder.Append(c2);
				c = c2;
			}
			return stringBuilder.ToString().Trim();
		}

		private static string BuildLocationKey(string prefabName, Vector3 position)
		{
			return "location:" + prefabName + "@" + Mathf.RoundToInt(position.x * 10f) + ":" + Mathf.RoundToInt(position.y * 10f) + ":" + Mathf.RoundToInt(position.z * 10f);
		}

		private static bool WithinHorizontalRadius(Vector3 a, Vector3 b, float radiusSq)
		{
			float num = a.x - b.x;
			float num2 = a.z - b.z;
			return num * num + num2 * num2 <= radiusSq;
		}

		private static string Normalize(string value)
		{
			if (string.IsNullOrEmpty(value))
			{
				return string.Empty;
			}
			char[] array = new char[value.Length];
			int length = 0;
			for (int i = 0; i < value.Length; i++)
			{
				char c = char.ToLowerInvariant(value[i]);
				if (char.IsLetterOrDigit(c))
				{
					array[length++] = c;
				}
			}
			return new string(array, 0, length);
		}
	}
	internal sealed class TraderDiscovery
	{
		private sealed class TraderCampObservation
		{
			internal string TraderType;

			internal string DisplayName;

			internal string PossibleDisplayName;

			internal string PrefabName;

			internal Vector3 Position;
		}

		private static readonly MethodInfo IsExploredMethod = AccessTools.Method(typeof(Minimap), "IsExplored", new Type[1] { typeof(Vector3) }, (Type[])null);

		private static readonly FieldInfo PinsField = AccessTools.Field(typeof(Minimap), "m_pins");

		private readonly ManualLogSource _log;

		private readonly WayfinderConfig _config;

		private readonly WayfinderPinDatabase _database;

		private float _nextScanTime;

		private long _cacheWorldUid = long.MinValue;

		private Location[] _cachedLocations = (Location[])(object)new Location[0];

		private Trader[] _cachedTraders = (Trader[])(object)new Trader[0];

		private Vector3 _locationCacheCenter;

		private Vector3 _traderCacheCenter;

		private float _nextLocationCacheRefresh;

		private float _nextTraderCacheRefresh;

		private bool _locationCacheInitialized;

		private bool _traderCacheInitialized;

		private bool _refreshTraderNext;

		private bool _scanInProgress;

		private int _scanPhase;

		private int _scanCursor;

		private Vector3 _scanCenter;

		private float _scanRadiusSq;

		private List<TraderCampObservation> _scanCamps = new List<TraderCampObservation>();

		private List<PinData> _scanPins = new List<PinData>();

		private int _scanConfirmed;

		private int _scanCandidates;

		private int _scanPurged;

		private long _scanWorldUid = long.MinValue;

		internal TraderDiscovery(ManualLogSource log, WayfinderConfig config, WayfinderPinDatabase database)
		{
			_log = log;
			_config = config;
			_database = database;
		}

		internal void ResetSession()
		{
			_nextScanTime = 0f;
			_cacheWorldUid = long.MinValue;
			_cachedLocations = (Location[])(object)new Location[0];
			_cachedTraders = (Trader[])(object)new Trader[0];
			_locationCacheInitialized = false;
			_traderCacheInitialized = false;
			_refreshTraderNext = false;
			_nextLocationCacheRefresh = 0f;
			_nextTraderCacheRefresh = 0f;
			ResetActiveScan();
		}

		internal void Tick()
		{
			TickBudgeted(1000.0);
		}

		internal bool TickBudgeted(double budgetMs)
		{
			if (!_config.Enabled.Value || _database.WorldUid == 0 || (Object)(object)Player.m_localPlayer == (Object)null)
			{
				ResetActiveScan();
				return false;
			}
			if (_scanWorldUid != _database.WorldUid)
			{
				_scanWorldUid = _database.WorldUid;
				ResetActiveScan();
			}
			long startTimestamp = DiscoveryWorkBudget.Start();
			if (!_scanInProgress)
			{
				if (Time.unscaledTime < _nextScanTime)
				{
					return false;
				}
				if (AllKnownTraderTypesConfirmed())
				{
					_nextScanTime = Time.unscaledTime + Mathf.Max(1f, _config.StaticDiscoveryInterval.Value);
					return false;
				}
				BeginScan();
				if (DiscoveryWorkBudget.Expired(startTimestamp, budgetMs))
				{
					return true;
				}
			}
			int num = 0;
			while (_scanPhase < 4)
			{
				if (_scanPhase == 0)
				{
					Location[] array = _cachedLocations;
					if (array == null)
					{
						array = (Location[])(object)new Location[0];
					}
					while (_scanCursor < array.Length)
					{
						ProcessCampLocation(array[_scanCursor++]);
						num++;
						if (DiscoveryWorkBudget.Expired(startTimestamp, budgetMs))
						{
							return true;
						}
					}
					_scanPhase = 1;
					_scanCursor = 0;
					continue;
				}
				if (_scanPhase == 1)
				{
					while (_scanCursor < _scanPins.Count)
					{
						ProcessNativePin(_scanPins[_scanCursor++]);
						num++;
						if (DiscoveryWorkBudget.Expired(startTimestamp, budgetMs))
						{
							return true;
						}
					}
					_scanPhase = 2;
					_scanCursor = 0;
					continue;
				}
				if (_scanPhase == 2)
				{
					Trader[] array2 = _cachedTraders;
					if (array2 == null)
					{
						array2 = (Trader[])(object)new Trader[0];
					}
					while (_scanCursor < array2.Length)
					{
						ProcessLoadedTrader(array2[_scanCursor++]);
						num++;
						if (DiscoveryWorkBudget.Expired(startTimestamp, budgetMs))
						{
							return true;
						}
					}
					_scanPhase = 3;
					_scanCursor = 0;
					continue;
				}
				while (_scanCursor < _scanCamps.Count)
				{
					ProcessCandidateCamp(_scanCamps[_scanCursor++]);
					num++;
					if (DiscoveryWorkBudget.Expired(startTimestamp, budgetMs))
					{
						return true;
					}
				}
				_scanPhase = 4;
			}
			if (_config.DebugLogging.Value && _config.VerboseRuntimeLogging.Value && (_scanConfirmed > 0 || _scanCandidates > 0 || _scanPurged > 0))
			{
				_log.LogInfo((object)("Trader discovery confirmed " + _scanConfirmed + " trader(s), remembered/confirmed " + _scanCandidates + " encountered candidate camp(s), and purged " + _scanPurged + " stale same-type candidate marker(s)."));
			}
			ResetActiveScan();
			return false;
		}

		private void BeginScan()
		{
			//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_009a: Unknown result type (might be due to invalid IL or missing references)
			_nextScanTime = Time.unscaledTime + Mathf.Max(1f, _config.StaticDiscoveryInterval.Value);
			_scanCenter = ((Component)Player.m_localPlayer).transform.position;
			float num = Mathf.Max(5f, _config.StructureDiscoveryRadius.Value);
			_scanRadiusSq = num * num;
			_scanCamps.Clear();
			_scanPins.Clear();
			_scanConfirmed = 0;
			_scanCandidates = 0;
			_scanPurged = 0;
			_scanCursor = 0;
			_scanPhase = 0;
			RefreshOneSceneCacheIfNeeded(_scanCenter);
			Minimap instance = Minimap.instance;
			if ((Object)(object)instance != (Object)null && PinsField != null)
			{
				try
				{
					if (PinsField.GetValue(instance) is List<PinData> collection)
					{
						_scanPins.AddRange(collection);
					}
				}
				catch
				{
				}
			}
			_scanInProgress = true;
		}

		private void ProcessCampLocation(Location location)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: 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_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: 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_0088: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)location == (Object)null || (Object)(object)((Component)location).gameObject == (Object)null)
			{
				return;
			}
			Vector3 position = ((Component)location).transform.position;
			if (WithinHorizontalRadius(_scanCenter, position, _scanRadiusSq) && MayReveal(position))
			{
				string prefabName = TraderIdentity.GetPrefabName(((Component)location).gameObject);
				if (TraderIdentity.TryFromLocationPrefab(prefabName, out var traderType, out var displayName, out var possibleDisplayName))
				{
					TraderCampObservation traderCampObservation = new TraderCampObservation();
					traderCampObservation.TraderType = traderType;
					traderCampObservation.DisplayName = displayName;
					traderCampObservation.PossibleDisplayName = possibleDisplayName;
					traderCampObservation.PrefabName = prefabName;
					traderCampObservation.Position = position;
					_scanCamps.Add(traderCampObservation);
				}
			}
		}

		private void ProcessNativePin(PinData pin)
		{
			//IL_0043: 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 (!TraderIdentity.TryFromNativePin(pin, out var traderType, out var displayName))
			{
				return;
			}
			if (string.Equals(traderType, "generic", StringComparison.OrdinalIgnoreCase))
			{
				string text = InferTraderTypeNear(pin.m_pos, 96f);
				if (string.IsNullOrEmpty(text))
				{
					return;
				}
				traderType = text;
				displayName = TraderIdentity.GetDisplayName(traderType);
			}
			if (ConfirmTrader(traderType, displayName, pin.m_pos, ref _scanPurged))
			{
				_scanConfirmed++;
			}
		}

		private void ProcessLoadedTrader(Trader trader)
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: 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_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)trader == (Object)null) && !((Object)(object)((Component)trader).gameObject == (Object)null) && TraderIdentity.TryFromTraderObject(trader, out var traderType, out var displayName))
			{
				Vector3 position = ((Component)trader).transform.position;
				TraderCampObservation traderCampObservation = FindNearestCamp(_scanCamps, traderType, position, 96f);
				if (traderCampObservation != null)
				{
					position = traderCampObservation.Position;
				}
				if (MayReveal(position) && ConfirmTrader(traderType, displayName, position, ref _scanPurged))
				{
					_scanConfirmed++;
				}
			}
		}

		private void ProcessCandidateCamp(TraderCampObservation camp)
		{
			//IL_0038: 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)
			if (camp != null && !string.IsNullOrEmpty(camp.TraderType) && !HasConfirmedTrader(camp.TraderType))
			{
				WayfinderPinRecord wayfinderPinRecord = _database.AddPointObservation(TraderIdentity.CandidateSubtype(camp.TraderType), camp.PossibleDisplayName, camp.Position, "wayfinder:trader", WayfinderPinCategory.Trader, WayfinderPinSource.InteractionDiscovery, BuildCandidateKey(camp.TraderType, camp.PrefabName, camp.Position));
				if (wayfinderPinRecord != null)
				{
					_scanCandidates++;
				}
			}
		}

		private void ResetActiveScan()
		{
			_scanInProgress = false;
			_scanPhase = 0;
			_scanCursor = 0;
			_scanCamps.Clear();
			_scanPins.Clear();
		}

		private void RefreshOneSceneCacheIfNeeded(Vector3 center)
		{
			//IL_01c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_018f: 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_0167: Unknown result type (might be due to invalid IL or missing references)
			//IL_0168: Unknown result type (might be due to invalid IL or missing references)
			if (_cacheWorldUid != _database.WorldUid)
			{
				_cacheWorldUid = _database.WorldUid;
				_cachedLocations = (Location[])(object)new Location[0];
				_cachedTraders = (Trader[])(object)new Trader[0];
				_locationCacheInitialized = false;
				_traderCacheInitialized = false;
				_refreshTraderNext = false;
				_nextLocationCacheRefresh = 0f;
				_nextTraderCacheRefresh = 0f;
			}
			float num = Mathf.Max(15f, _config.StaticDiscoveryInterval.Value * 4f);
			float num2 = center.x - _locationCacheCenter.x;
			float num3 = center.z - _locationCacheCenter.z;
			bool flag = num2 * num2 + num3 * num3 >= 6400f;
			bool flag2 = !_locationCacheInitialized || _cachedLocations == null || Time.unscaledTime >= _nextLocationCacheRefresh || flag;
			num2 = center.x - _traderCacheCenter.x;
			num3 = center.z - _traderCacheCenter.z;
			bool flag3 = num2 * num2 + num3 * num3 >= 6400f;
			bool flag4 = !_traderCacheInitialized || _cachedTraders == null || Time.unscaledTime >= _nextTraderCacheRefresh || flag3;
			if (flag2 && flag4)
			{
				if (_refreshTraderNext)
				{
					_cachedTraders = LiveDiscoveryRegistry.SnapshotTraders();
					_traderCacheInitialized = true;
					_traderCacheCenter = center;
					_nextTraderCacheRefresh = Time.unscaledTime + num;
				}
				else
				{
					_cachedLocations = LiveDiscoveryRegistry.SnapshotLocations();
					_locationCacheInitialized = true;
					_locationCacheCenter = center;
					_nextLocationCacheRefresh = Time.unscaledTime + num;
				}
				_refreshTraderNext = !_refreshTraderNext;
			}
			else if (flag2)
			{
				_cachedLocations = LiveDiscoveryRegistry.SnapshotLocations();
				_locationCacheInitialized = true;
				_locationCacheCenter = center;
				_nextLocationCacheRefresh = Time.unscaledTime + num;
			}
			else if (flag4)
			{
				_cachedTraders = LiveDiscoveryRegistry.SnapshotTraders();
				_traderCacheInitialized = true;
				_traderCacheCenter = center;
				_nextTraderCacheRefresh = Time.unscaledTime + num;
			}
		}

		private bool AllKnownTraderTypesConfirmed()
		{
			if (HasConfirmedTrader("haldor") && HasConfirmedTrader("hildir"))
			{
				return HasConfirmedTrader("bogwitch");
			}
			return false;
		}

		private List<TraderCampObservation> FindEncounteredTraderCamps()
		{
			//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_006f: 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_0076: 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_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			List<TraderCampObservation> list = new List<TraderCampObservation>();
			Vector3 position = ((Component)Player.m_localPlayer).transform.position;
			float num = Mathf.Max(5f, _config.StructureDiscoveryRadius.Value);
			float radiusSq = num * num;
			Location[] cachedLocations = _cachedLocations;
			foreach (Location val in cachedLocations)
			{
				if ((Object)(object)val == (Object)null || (Object)(object)((Component)val).gameObject == (Object)null)
				{
					continue;
				}
				Vector3 position2 = ((Component)val).transform.position;
				if (WithinHorizontalRadius(position, position2, radiusSq) && MayReveal(position2))
				{
					string prefabName = TraderIdentity.GetPrefabName(((Component)val).gameObject);
					if (TraderIdentity.TryFromLocationPrefab(prefabName, out var traderType, out var displayName, out var possibleDisplayName))
					{
						TraderCampObservation traderCampObservation = new TraderCampObservation();
						traderCampObservation.TraderType = traderType;
						traderCampObservation.DisplayName = displayName;
						traderCampObservation.PossibleDisplayName = possibleDisplayName;
						traderCampObservation.PrefabName = prefabName;
						traderCampObservation.Position = position2;
						list.Add(traderCampObservation);
					}
				}
			}
			return list;
		}

		private int ConfirmFromVanillaPins(ref int purged)
		{
			//IL_0097: 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)
			Minimap instance = Minimap.instance;
			if ((Object)(object)instance == (Object)null || PinsField == null)
			{
				return 0;
			}
			List<PinData> list = null;
			try
			{
				list = PinsField.GetValue(instance) as List<PinData>;
			}
			catch
			{
			}
			if (list == null)
			{
				return 0;
			}
			int num = 0;
			for (int i = 0; i < list.Count; i++)
			{
				PinData val = list[i];
				if (!TraderIdentity.TryFromNativePin(val, out var traderType, out var displayName))
				{
					continue;
				}
				if (string.Equals(traderType, "generic", StringComparison.OrdinalIgnoreCase))
				{
					string text = InferTraderTypeNear(val.m_pos, 96f);
					if (string.IsNullOrEmpty(text))
					{
						continue;
					}
					traderType = text;
					displayName = TraderIdentity.GetDisplayName(traderType);
				}
				if (ConfirmTrader(traderType, displayName, val.m_pos, ref purged))
				{
					num++;
				}
			}
			return num;
		}

		private int ConfirmFromLoadedTraders(List<TraderCampObservation> camps, ref int purged)
		{
			//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_0044: 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_0058: 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_006e: Unknown result type (might be due to invalid IL or missing references)
			Trader[] cachedTraders = _cachedTraders;
			int num = 0;
			foreach (Trader val in cachedTraders)
			{
				if (!((Object)(object)val == (Object)null) && !((Object)(object)((Component)val).gameObject == (Object)null) && TraderIdentity.TryFromTraderObject(val, out var traderType, out var displayName))
				{
					Vector3 position = ((Component)val).transform.position;
					TraderCampObservation traderCampObservation = FindNearestCamp(camps, traderType, position, 96f);
					if (traderCampObservation != null)
					{
						position = traderCampObservation.Position;
					}
					if (MayReveal(position) && ConfirmTrader(traderType, displayName, position, ref purged))
					{
						num++;
					}
				}
			}
			return num;
		}

		private bool ConfirmTrader(string traderType, string displayName, Vector3 position, ref int purged)
		{
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			if (string.IsNullOrEmpty(traderType))
			{
				return false;
			}
			if (HasConfirmedTrader(traderType))
			{
				purged += PurgeCandidateMarkers(traderType);
				return false;
			}
			WayfinderPinRecord wayfinderPinRecord = _database.AddPointObservation(TraderIdentity.ConfirmedSubtype(traderType), string.IsNullOrEmpty(displayName) ? TraderIdentity.GetDisplayName(traderType) : displayName, position, "wayfinder:trader", WayfinderPinCategory.Trader, WayfinderPinSource.InteractionDiscovery, BuildConfirmedKey(traderType, position));
			if (wayfinderPinRecord == null)
			{
				return false;
			}
			purged += PurgeCandidateMarkers(traderType);
			return true;
		}

		private bool HasConfirmedTrader(string traderType)
		{
			IReadOnlyList<WayfinderPinRecord> records = _database.Records;
			string b = TraderIdentity.ConfirmedSubtype(traderType);
			for (int i = 0; i < records.Count; i++)
			{
				WayfinderPinRecord wayfinderPinRecord = records[i];
				if (wayfinderPinRecord != null && wayfinderPinRecord.category == WayfinderPinCategory.Trader && string.Equals(wayfinderPinRecord.subtype, b, StringComparison.OrdinalIgnoreCase))
				{
					return true;
				}
			}
			return false;
		}

		private int PurgeCandidateMarkers(string traderType)
		{
			List<string> list = new List<string>();
			IReadOnlyList<WayfinderPinRecord> records = _database.Records;
			string b = TraderIdentity.CandidateSubtype(traderType);
			for (int i = 0; i < records.Count; i++)
			{
				WayfinderPinRecord wayfinderPinRecord = records[i];
				if (wayfinderPinRecord != null && wayfinderPinRecord.category == WayfinderPinCategory.Trader && wayfinderPinRecord.source != WayfinderPinSource.Manual && wayfinderPinRecord.source != WayfinderPinSource.Imported && wayfinderPinRecord.source != WayfinderPinSource.Vanilla && string.Equals(wayfinderPinRecord.subtype, b, StringComparison.OrdinalIgnoreCase))
				{
					list.Add(wayfinderPinRecord.id);
				}
			}
			int num = 0;
			for (int j = 0; j < list.Count; j++)
			{
				if (_database.Remove(list[j], suppressAutoRediscovery: false))
				{
					num++;
				}
			}
			return num;
		}

		private string InferTraderTypeNear(Vector3 position, float radius)
		{
			//IL_002a: 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)
			Location[] cachedLocations = _cachedLocations;
			float radiusSq = radius * radius;
			foreach (Location val in cachedLocations)
			{
				if (!((Object)(object)val == (Object)null) && !((Object)(object)((Component)val).gameObject == (Object)null) && WithinHorizontalRadius(position, ((Component)val).transform.position, radiusSq) && TraderIdentity.TryFromLocationPrefab(TraderIdentity.GetPrefabName(((Component)val).gameObject), out var traderType, out var _, out var _))
				{
					return traderType;
				}
			}
			return string.Empty;
		}

		private static TraderCampObservation FindNearestCamp(List<TraderCampObservation> camps, string traderType, Vector3 position, float radius)
		{
			if (camps == null)
			{
				return null;
			}
			float num = radius * radius;
			TraderCampObservation result = null;
			for (int i = 0; i < camps.Count; i++)
			{
				TraderCampObservation traderCampObservation = camps[i];
				if (traderCampObservation != null && string.Equals(traderCampObservation.TraderType, traderType, StringComparison.OrdinalIgnoreCase))
				{
					float num2 = traderCampObservation.Position.x - position.x;
					float num3 = traderCampObservation.Position.z - position.z;
					float num4 = num2 * num2 + num3 * num3;
					if (num4 <= num)
					{
						num = num4;
						result = traderCampObservation;
					}
				}
			}
			return result;
		}

		private bool MayReveal(Vector3 position)
		{
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			if (_config.ScanUnexploredAreas.Value)
			{
				return true;
			}
			Minimap instance = Minimap.instance;
			if ((Object)(object)instance == (Object)null || IsExploredMethod == null)
			{
				return false;
			}
			try
			{
				object obj = IsExploredMethod.Invoke(instance, new object[1] { position });
				return obj is bool && (bool)obj;
			}
			catch
			{
				return false;
			}
		}

		private static string BuildCandidateKey(string traderType, string prefabName, Vector3 position)
		{
			return "tradercandidate:" + traderType + ":" + prefabName + "@" + Mathf.RoundToInt(position.x * 10f) + ":" + Mathf.RoundToInt(position.y * 10f) + ":" + Mathf.RoundToInt(position.z * 10f);
		}

		private static string BuildConfirmedKey(string traderType, Vector3 position)
		{
			return "traderconfirmed:" + traderType + "@" + Mathf.RoundToInt(position.x * 10f) + ":" + Mathf.RoundToInt(position.y * 10f) + ":" + Mathf.RoundToInt(position.z * 10f);
		}

		private static bool WithinHorizontalRadius(Vector3 a, Vector3 b, float radiusSq)
		{
			float num = a.x - b.x;
			float num2 = a.z - b.z;
			return num * num + num2 * num2 <= radiusSq;
		}
	}
	internal static class TraderIdentity
	{
		internal const string Haldor = "haldor";

		internal const string Hildir = "hildir";

		internal const string BogWitch = "bogwitch";

		internal static bool TryFromLocationPrefab(string prefabName, out string traderType, out string displayName, out string possibleDisplayName)
		{
			traderType = string.Empty;
			displayName = string.Empty;
			possibleDisplayName = string.Empty;
			switch (Normalize(prefabName))
			{
			case "vendorblackforest":
				traderType = "haldor";
				displayName = "Haldor";
				possibleDisplayName = "Possible Haldor Camp";
				return true;
			case "hildircamp":
				traderType = "hildir";
				displayName = "Hildir";
				possibleDisplayName = "Possible Hildir Camp";
				return true;
			case "bogwitchcamp":
				traderType = "bogwitch";
				displayName = "Bog Witch";
				possibleDisplayName = "Possible Bog Witch Hut";
				return true;
			default:
				return false;
			}
		}

		internal static bool IsTraderLocationPrefab(string prefabName)
		{
			string traderType;
			string displayName;
			string possibleDisplayName;
			return TryFromLocationPrefab(prefabName, out traderType, out displayName, out possibleDisplayName);
		}

		internal static bool TryFromTraderObject(Trader trader, out string traderType, out string displayName)
		{
			traderType = string.Empty;
			displayName = string.Empty;
			if ((Object)(object)trader == (Object)null || (Object)(object)((Component)trader).gameObject == (Object)null)
			{
				return false;
			}
			string prefabName = GetPrefabName(((Component)trader).gameObject);
			string text = Normalize(prefabName + " " + ((Object)((Component)trader).gameObject).name);
			if (text.Contains("haldor"))
			{
				traderType = "haldor";
				displayName = "Haldor";
				return true;
			}
			if (text.Contains("hildir") && !ContainsHildirQuestSuffix(text))
			{
				traderType = "hildir";
				displayName = "Hildir";
				return true;
			}
			if (text.Contains("bogwitch"))
			{
				traderType = "bogwitch";
				displayName = "Bog Witch";
				return true;
			}
			Location val = null;
			try
			{
				val = ((Component)trader).GetComponentInParent<Location>();
			}
			catch
			{
			}
			if ((Object)(object)val != (Object)null && (Object)(object)((Component)val).gameObject != (Object)null && TryFromLocationPrefab(GetPrefabName(((Component)val).gameObject), out traderType, out displayName, out var _))
			{
				return true;
			}
			return false;
		}

		internal static bool TryFromNativePin(PinData pin, out string traderType, out string displayName)
		{
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			traderType = string.Empty;
			displayName = string.Empty;
			if (pin == null)
			{
				return false;
			}
			string text = pin.m_name ?? string.Empty;
			string value = text;
			try
			{
				if (Localization.instance != null && !string.IsNullOrEmpty(text))
				{
					value = Localization.instance.Localize(text);
				}
			}
			catch
			{
			}
			string value2 = string.Empty;
			try
			{
				value2 = ((object)pin.m_type).ToString();
			}
			catch
			{
			}
			string text2 = Normalize(value2);
			string text3 = Normalize(text);
			string text4 = Normalize(value);
			string text5 = text2 + " " + text3 + " " + text4;
			if (text3.Contains("npchaldor") || text4 == "haldor" || text2 == "haldor")
			{
				traderType = "haldor";
				displayName = "Haldor";
				return true;
			}
			if (text3.Contains("npchildir") || text4 == "hildir" || text2 == "hildir")
			{
				traderType = "hildir";
				displayName = "Hildir";
				return true;
			}
			if (text3.Contains("npcbogwitch") || text4 == "bogwitch" || text2 == "bogwitch")
			{
				traderType = "bogwitch";
				displayName = "Bog Witch";
				return true;
			}
			if (text2 == "trader" || text3 == "trader" || text4 == "trader")
			{
				traderType = "generic";
				displayName = "Trader";
				return true;
			}
			if (text5.Contains("haldor"))
			{
				traderType = "haldor";
				displayName = "Haldor";
				return true;
			}
			if (text5.Contains("bogwitch"))
			{
				traderType = "bogwitch";
				displayName = "Bog Witch";
				return true;
			}
			return false;
		}

		internal static string ConfirmedSubtype(string traderType)
		{
			return "trader:" + (traderType ?? string.Empty);
		}

		internal static string CandidateSubtype(string traderType)
		{
			return ConfirmedSubtype(traderType) + ":candidate";
		}

		internal static string GetDisplayName(string traderType)
		{
			if (string.Equals(traderType, "haldor", StringComparison.OrdinalIgnoreCase))
			{
				return "Haldor";
			}
			if (string.Equals(traderType, "hildir", StringComparison.OrdinalIgnoreCase))
			{
				return "Hildir";
			}
			if (string.Equals(traderType, "bogwitch", StringComparison.OrdinalIgnoreCase))
			{
				return "Bog Witch";
			}
			return "Trader";
		}

		internal static string GetPossibleDisplayName(string traderType)
		{
			if (string.Equals(traderType, "haldor", StringComparison.OrdinalIgnoreCase))
			{
				return "Possible Haldor Camp";
			}
			if (string.Equals(traderType, "hildir", StringComparison.OrdinalIgnoreCase))
			{
				return "Possible Hildir Camp";
			}
			if (string.Equals(traderType, "bogwitch", StringComparison.OrdinalIgnoreCase))
			{
				return "Possible Bog Witch Hut";
			}
			return "Possible Trader Camp";
		}

		internal static string GetPrefabName(GameObject gameObject)
		{
			if ((Object)(object)gameObject == (Object)null)
			{
				return string.Empty;
			}
			try
			{
				string prefabName = Utils.GetPrefabName(gameObject);
				if (!string.IsNullOrEmpty(prefabName))
				{
					return prefabName.Replace("(Clone)", string.Empty).Trim();
				}
			}
			catch
			{
			}
			return (((Object)gameObject).name ?? string.Empty).Replace("(Clone)", string.Empty).Trim();
		}

		internal static string Normalize(string value)
		{
			if (string.IsNullOrEmpty(value))
			{
				return string.Empty;
			}
			char[] array = new char[value.Length];
			int length = 0;
			for (int i = 0; i < value.Length; i++)
			{
				char c = char.ToLowerInvariant(value[i]);
				if (char.IsLetterOrDigit(c))
				{
					array[length++] = c;
				}
			}
			return new string(array, 0, length);
		}

		private static bool ContainsHildirQuestSuffix(string normalized)
		{
			if (!normalized.Contains("hildir1") && !normalized.Contains("hildir2") && !normalized.Contains("hildir3") && !normalized.Contains("hildircave") && !normalized.Contains("hildircrypt"))
			{
				return normalized.Contains("hildirplainsfortress");
			}
			return true;
		}
	}
	internal sealed class VehicleDiscovery
	{
		private sealed class LiveVehicleObservation
		{
			internal string Kind;

			internal string StableKey;

			internal string Subtype;

			internal Vector3 Position;
		}

		private static readonly MethodInfo FindObjectsByTypeTypeMethod = typeof(Object).GetMethod("FindObjectsByType", BindingFlags.Static | BindingFlags.Public, null, new Type[2]
		{
			typeof(Type),
			typeof(FindObjectsSortMode)
		}, null);

		private static readonly MethodInfo FindObjectsOfTypeTypeMethod = typeof(Object).GetMethod("FindObjectsOfType", BindingFlags.Static | BindingFlags.Public, null, new Type[1] { typeof(Type) }, null);

		private readonly ManualLogSource _log;

		private readonly WayfinderConfig _config;

		private readonly WayfinderPinDatabase _database;

		private readonly Type _shipType;

		private readonly Type _cartType;

		private readonly Type _znetViewType;

		private readonly MethodInfo _getZdoIdMethod;

		private readonly MethodInfo _getZdoMethod;

		private readonly MethodInfo _isValidMethod;

		private float _nextScanTime;

		private bool _warnedMissingShipType;

		private bool _warnedMissingCartType;

		internal VehicleDiscovery(ManualLogSource log, WayfinderConfig config, WayfinderPinDatabase database)
		{
			_log = log;
			_config = config;
			_database = database;
			_shipType = AccessTools.TypeByName("Ship");
			_cartType = AccessTools.TypeByName("Vagon");
			_znetViewType = AccessTools.TypeByName("ZNetView");
			_getZdoIdMethod = FindOptionalInstanceMethod(_znetViewType, "GetZDOID");
			_getZdoMethod = FindOptionalInstanceMethod(_znetViewType, "GetZDO");
			_isValidMethod = FindOptionalInstanceMethod(_znetViewType, "IsValid");
		}

		internal void ResetSession()
		{
			_nextScanTime = 0f;
			int num = _database.CollapseDuplicateDynamicMemberKeys(WayfinderPinCategory.Vehicle);
			if (num > 0 && _config.DebugLogging.Value)
			{
				_log.LogInfo((object)("Collapsed " + num + " duplicate dynamic vehicle record(s) sharing the same stable ZDO identity."));
			}
		}

		internal void ClearSession()
		{
			_nextScanTime = 0f;
		}

		internal void Tick()
		{
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_011c: Unknown result type (might be due to invalid IL or missing references)
			if (_config.Enabled.Value && _database.WorldUid != 0 && !((Object)(object)Player.m_localPlayer == (Object)null) && !((Object)(object)ZNet.instance == (Object)null) && (_config.TrackBoats.Value || _config.TrackCarts.Value) && !(Time.unscaledTime < _nextScanTime))
			{
				_nextScanTime = Time.unscaledTime + Mathf.Max(0.1f, _config.VehicleUpdateInterval.Value);
				Vector3 position = ((Component)Player.m_localPlayer).transform.position;
				float num = Mathf.Max(10f, _config.VehicleDiscoveryRadius.Value);
				float radiusSq = num * num;
				HashSet<string> hashSet = new HashSet<string>(StringComparer.Ordinal);
				List<LiveVehicleObservation> observations = new List<LiveVehicleObservation>();
				if (_config.TrackBoats.Value)
				{
					ScanType(_shipType, "boat", position, radiusSq, hashSet, observations);
				}
				if (_config.TrackCarts.Value)
				{
					ScanType(_cartType, "cart", position, radiusSq, hashSet, observations);
				}
				CleanupStaleAliases(observations, hashSet);
				float staleGraceSeconds = Mathf.Max(1.25f, Mathf.Max(0.1f, _config.VehicleUpdateInterval.Value) * 3f);
				_database.FinalizeDynamicObservationPass(WayfinderPinCategory.Vehicle, hashSet, staleGraceSeconds);
				if (!_config.KeepLastKnownVehiclePosition.Value)
				{
					_database.RemoveUnseenDynamicPoints(WayfinderPinCategory.Vehicle, hashSet);
				}
			}
		}

		private void ScanType(Type type, string kind, Vector3 playerPosition, float radiusSq, HashSet<string> seenKeys, List<LiveVehicleObservation> observations)
		{
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fd: Unknown result type (might be due to invalid IL or missing references)
			if (type == null)
			{
				if (kind == "boat" && !_warnedMissingShipType)
				{
					_warnedMissingShipType = true;
					if (_config.DebugLogging.Value)
					{
						_log.LogWarning((object)"Vehicle tracker could not resolve Valheim Ship type.");
					}
				}
				else if (kind == "cart" && !_warnedMissingCartType)
				{
					_warnedMissingCartType = true;
					if (_config.DebugLogging.Value)
					{
						_log.LogWarning((object)"Vehicle tracker could not resolve Valheim Vagon type.");
					}
				}
				return;
			}
			Object[] array = FindSceneObjectsOfType(type);
			if (array == null)
			{
				return;
			}
			foreach (Object obj in array)
			{
				Component val = (Component)(object)((obj is Component) ? obj : null);
				if ((Object)(object)val == (Object)null || (Object)(object)val.gameObject == (Object)null || !val.gameObject.activeInHierarchy)
				{
					continue;
				}
				Vector3 position = val.transform.position;
				bool flag = WithinHorizontalRadius(playerPosition, position, radiusSq);
				string text = BuildStableVehicleKey(val, kind);
				if (string.IsNullOrEmpty(text))
				{
					if (flag && _config.DebugLogging.Value)
					{
						_log.LogWarning((object)("Skipping loaded " + kind + " because a stable ZDO identity was not available: " + GetPrefabName(val.gameObject)));
					}
					continue;
				}
				bool flag2 = _database.HasDynamicPointByMemberKey(WayfinderPinCategory.Vehicle, text);
				if (flag || flag2)
				{
					seenKeys.Add(text);
					string prefabName = GetPrefabName(val.gameObject);
					string displayName = GetDisplayName(kind, prefabName);
					string subtype = "vehicle:" + kind + ":" + (string.IsNullOrEmpty(prefabName) ? displayName : prefabName);
					string iconKey = ((kind == "cart") ? "wayfinder:cart" : "wayfinder:boat");
					_database.UpsertDynamicPoint(subtype, displayName, position, iconKey, WayfinderPinCategory.Vehicle, text, 0.08f);
					observations?.Add(new LiveVehicleObservation
					{
						Kind = kind,
						StableKey = text,
						Subtype = subtype,
						Position = position
					});
				}
			}
		}

		private void CleanupStaleAliases(List<LiveVehicleObservation> observations, HashSet<string> liveMemberKeys)
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			if (observations == null || observations.Count == 0)
			{
				return;
			}
			int num = 0;
			for (int i = 0; i < observations.Count; i++)
			{
				LiveVehicleObservation liveVehicleObservation = observations[i];
				if (liveVehicleObservation != null && !string.IsNullOrEmpty(liveVehicleObservation.StableKey))
				{
					num += _database.RemoveStaleDynamicAliasesNear(WayfinderPinCategory.Vehicle, liveVehicleObservation.Position, 1.35f, "vehicle:" + liveVehicleObservation.Kind + ":", liveVehicleObservation.StableKey, liveMemberKeys);
				}
			}
			if (num > 0 && _config.DebugLogging.Value)
			{
				_log.LogInfo((object)("Removed " + num + " stale dynamic vehicle alias record(s) near live vehicles."));
			}
		}

		internal void NotifyDestroyed(GameObject source)
		{
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)source == (Object)null || !_config.RemoveDestroyedVehicles.Value || _database.WorldUid == 0)
			{
				return;
			}
			Component val = FindVehicleInParents(source, _shipType);
			string text = "boat";
			if ((Object)(object)val == (Object)null)
			{
				val = FindVehicleInParents(source, _cartType);
				text = "cart";
			}
			if (!((Object)(object)val == (Object)null))
			{
				string text2 = BuildStableVehicleKey(val, text);
				bool flag = false;
				if (!string.IsNullOrEmpty(text2))
				{
					flag = _database.RemoveDynamicPointByMemberKey(WayfinderPinCategory.Vehicle, text2);
				}
				if (!flag)
				{
					flag = _database.RemoveNearestDynamicPoint(WayfinderPinCategory.Vehicle, val.transform.position, 2.25f, "vehicle:" + text + ":");
				}
				if (flag && _config.DebugLogging.Value)
				{
					_log.LogInfo((object)("Removed destroyed Wayfinder " + text + " marker."));
				}
			}
		}

		private string BuildStableVehicleKey(Component component, string kind)
		{
			if ((Object)(object)component == (Object)null)
			{
				return null;
			}
			Component val = FindZNetView(component);
			if ((Object)(object)val == (Object)null)
			{
				return null;
			}
			if (_isValidMethod != null)
			{
				try
				{
					object obj = _isValidMethod.Invoke(val, null);
					if (obj is bool && !(bool)obj)
					{
						return null;
					}
				}
				catch
				{
				}
			}
			object obj3 = null;
			if (_getZdoIdMethod != null)
			{
				try
				{
					obj3 = _getZdoIdMethod.Invoke(val, null);
				}
				catch
				{
					obj3 = null;
				}
			}
			if (obj3 == null && _getZdoMethod != null)
			{
				try
				{
					object obj5 = _getZdoMethod.Invoke(val, null);
					if (obj5 != null)
					{
						FieldInfo field = obj5.GetType().GetField("m_uid", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
						if (field != null)
						{
							obj3 = field.GetValue(obj5);
						}
					}
				}
				catch
				{
					obj3 = null;
				}
			}
			string text = StableIdToString(obj3);
			if (!string.IsNullOrEmpty(text))
			{
				switch (text)
				{
				case "0":
				case "0:0":
				case "0_0":
					break;
				default:
					return "vehicle:" + kind + ":" + text;
				}
			}
			return null;
		}

		private static MethodInfo FindOptionalInstanceMethod(Type type, string name)
		{
			if (type == null || string.IsNullOrEmpty(name))
			{
				return null;
			}
			try
			{
				return type.GetMethod(name, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, Type.EmptyTypes, null);
			}
			catch
			{
				return null;
			}
		}

		private static string StableIdToString(object id)
		{
			if (id == null)
			{
				return string.Empty;
			}
			try
			{
				Type type = id.GetType();
				BindingFlags flags = BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic;
				object obj = ReadSilentMember(type, id, flags, "m_userID", "userID", "UserID");
				object obj2 = ReadSilentMember(type, id, flags, "m_id", "id", "ID");
				if (obj != null && obj2 != null)
				{
					string text = Convert.ToString(obj);
					string text2 = Convert.ToString(obj2);
					if (!string.IsNullOrEmpty(text) && !string.IsNullOrEmpty(text2))
					{
						return text + ":" + text2;
					}
				}
			}
			catch
			{
			}
			try
			{
				return id.ToString();
			}
			catch
			{
				return string.Empty;
			}
		}

		private static object ReadSilentMember(Type type, object instance, BindingFlags flags, params string[] names)
		{
			if (type == null || instance == null || names == null)
			{
				return null;
			}
			foreach (string text in names)
			{
				if (string.IsNullOrEmpty(text))
				{
					continue;
				}
				try
				{
					FieldInfo field = type.GetField(text, flags);
					if (field != null)
					{
						return field.GetValue(instance);
					}
				}
				catch
				{
				}
				try
				{
					PropertyInfo property = type.GetProperty(text, flags);
					if (property != null && property.GetIndexParameters().Length == 0)
					{
						return property.GetValue(instance, null);
					}
				}
				catch
				{
				}
			}
			return null;
		}

		private Component FindZNetView(Component component)
		{
			if ((Object)(object)component == (Object)null || _znetViewType == null)
			{
				return null;
			}
			try
			{
				Component component2 = component.gameObject.GetComponent(_znetViewType);
				if ((Object)(object)component2 != (Object)null)
				{
					return component2;
				}
			}
			catch
			{
			}
			Transform val = component.transform;
			while ((Object)(object)val != (Object)null)
			{
				try
				{
					Component component3 = ((Component)val).gameObject.GetComponent(_znetViewType);
					if ((Object)(object)component3 != (Object)null)
					{
						return component3;
					}
				}
				catch
				{
				}
				val = val.parent;
			}
			try
			{
				Component[] componentsInChildren = component.gameObject.GetComponentsInChildren(_znetViewType, true);
				if (componentsInChildren != null && componentsInChildren.Length > 0)
				{
					return componentsInChildren[0];
				}
			}
			catch
			{
			}
			return null;
		}

		private static Component FindVehicleInParents(GameObject source, Type vehicleType)
		{
			if ((Object)(object)source == (Object)null || vehicleType == null)
			{
				return null;
			}
			Transform val = source.transform;
			while ((Object)(object)val != (Object)null)
			{
				try
				{
					Component component = ((Component)val).gameObject.GetComponent(vehicleType);
					if ((Object)(object)component != (Object)null)
					{
						return component;
					}
				}
				catch
				{
				}
				val = val.parent;
			}
			return null;
		}

		private static Object[] FindSceneObjectsOfType(Type type)
		{
			if (type == null)
			{
				return (Object[])(object)new Object[0];
			}
			try
			{
				if (FindObjectsByTypeTypeMethod != null)
				{
					object obj = FindObjectsByTypeTypeMethod.Invoke(null, new object[2]
					{
						type,
						(object)(FindObjectsSortMode)0
					});
					if (obj is Object[] result)
					{
						return result;
					}
				}
			}
			catch
			{
			}
			try
			{
				if (FindObjectsOfTypeTypeMethod != null)
				{
					object obj3 = FindObjectsOfTypeTypeMethod.Invoke(null, new object[1] { type });
					if (obj3 is Object[] result2)
					{
						return result2;
					}
				}
			}
			catch
			{
			}
			return (Object[])(object)new Object[0];
		}

		private static string GetDisplayName(string kind, string prefabName)
		{
			return WayfinderVehicleNaming.GetAutomaticDisplayName(kind, prefabName);
		}

		private static string GetPrefabName(GameObject gameObject)
		{
			if ((Object)(object)gameObject == (Object)null)
			{
				return string.Empty;
			}
			try
			{
				string prefabName = Utils.GetPrefabName(gameObject);
				if (!string.IsNullOrEmpty(prefabName))
				{
					return prefabName.Replace("(Clone)", string.Empty).Trim();
				}
			}
			catch
			{
			}
			return (((Object)gameObject).name ?? string.Empty).Replace("(Clone)", string.Empty).Trim();
		}

		private static bool WithinHorizontalRadius(Vector3 a, Vector3 b, float radiusSq)
		{
			float num = a.x - b.x;
			float num2 = a.z - b.z;
			return num * num + num2 * num2 <= radiusSq;
		}

		private static string Normalize(string value)
		{
			if (string.IsNullOrEmpty(value))
			{
				return string.Empty;
			}
			char[] array = new char[value.Length];
			int length = 0;
			for (int i = 0; i < value.Length; i++)
			{
				char c = char.ToLowerInvariant(value[i]);
				if (char.IsLetterOrDigit(c))
				{
					array[length++] = c;
				}
			}
			return new string(array, 0, length);
		}
	}
}
namespace JoeyBadManners.Wayfinder.HUD
{
	internal sealed class WayfinderCompassHUD
	{
		private static readonly FieldInfo LargeRootField = AccessTools.Field(typeof(Minimap), "m_largeRoot");

		private readonly ManualLogSource _log;

		private readonly WayfinderConfig _config;

		private readonly WayfinderPinManagementService _manager;

		private readonly RuntimeIconRegistry _icons;

		private Texture2D _frameTexture;

		private Texture2D _trackAccentTexture;

		private Texture2D _cardNTexture;

		private Texture2D _cardETexture;

		private Texture2D _cardSTexture;

		private Texture2D _cardWTexture;

		private GUIStyle _distanceStyle;

		private GUIStyle _nameStyle;

		internal WayfinderCompassHUD(ManualLogSource log, WayfinderConfig config, WayfinderPinManagementService manager, RuntimeIconRegistry icons)
		{
			_log = log;
			_config = config;
			_manager = manager;
			_icons = icons;
		}

		internal void Draw()
		{
			//IL_01f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0155: 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_015c: Unknown result type (might be due to invalid IL or missing references)
			//IL_016c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0171: Unknown result type (might be due to invalid IL or missing references)
			if (!_config.Enabled.Value || !_config.CompassEnabled.Value || (Object)(object)Player.m_localPlayer == (Object)null || (Object)(object)ZNet.instance == (Object)null || IsLargeMapOpen())
			{
				return;
			}
			List<WayfinderPinRecord> trackedPins = _manager.GetTrackedPins();
			bool value = _config.CompassShowCardinals.Value;
			if (trackedPins.Count == 0 && !value)
			{
				return;
			}
			EnsureStyles();
			EnsureArt();
			float num = Mathf.Max(360f, _config.CompassWidth.Value);
			float num2 = Mathf.Min(num, Mathf.Max(360f, (float)Screen.width - 32f));
			float top = Mathf.Max(0f, _config.CompassTopOffset.Value);
			float num3 = ((float)Screen.width - num2) * 0.5f;
			float num4 = num2 * 0.07527926f;
			num4 = Mathf.Clamp(num4, 54f, 82f);
			float totalHeight = num4 + (_config.CompassShowNames.Value ? 30f : 16f);
			float centerX = num3 + num2 * 0.5f;
			float num5 = Mathf.Clamp(_config.CompassArcDegrees.Value, 60f, 360f);
			float halfArc = num5 * 0.5f;
			Vector3 viewForward = GetViewForward();
			float heading = BearingFromDirection(viewForward);
			int depth = GUI.depth;
			Color color = GUI.color;
			GUI.depth = -900;
			try
			{
				DrawFrame(num3, top, num2, num4);
				if (value)
				{
					DrawBearingTicks(num3, top, num2, num4, heading, halfArc);
				}
				DrawCenterGuide(centerX, top, num4);
				DrawTrackedMarkers(trackedPins, num3, top, num2, num4, totalHeight, heading, halfArc);
			}
			catch (Exception ex)
			{
				if (_config.DebugLogging.Value)
				{
					_log.LogWarning((object)("Compass draw failed: " + ex.Message));
				}
			}
			finally
			{
				GUI.color = color;
				GUI.depth = depth;
			}
		}

		private void DrawFrame(float left, float top, float width, float frameHeight)
		{
			//IL_0045: 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)
			float num = Mathf.Clamp01(_config.CompassOpacity.Value);
			if ((Object)(object)_frameTexture != (Object)null)
			{
				GUI.color = new Color(1f, 1f, 1f, Mathf.Clamp01(0.78f + num * 0.22f));
				GUI.DrawTexture(new Rect(left, top, width, frameHeight), (Texture)(object)_frameTexture, (ScaleMode)0, true);
			}
		}

		private void DrawBearingTicks(float left, float top, float width, float frameHeight, float heading, float halfArc)
		{
			//IL_00ce: 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_00fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0167: Unknown result type (might be due to invalid IL or missing references)
			//IL_0179: Unknown result type (might be due to invalid IL or missing references)
			float num = top + frameHeight * 0.33f;
			for (int i = 0; i < 360; i += 15)
			{
				float num2 = Mathf.DeltaAngle(heading, (float)i);
				if (Mathf.Abs(num2) > halfArc)
				{
					continue;
				}
				float num3 = Mathf.Clamp(width * 0.085f, 34f, 72f);
				float num4 = width - num3 * 2f;
				float num5 = left + num3 + (num2 + halfArc) / (halfArc * 2f) * num4;
				bool flag = i % 90 == 0;
				bool flag2 = i % 45 == 0;
				float num6 = (flag ? 8f : (flag2 ? 5f : 3f));
				GUI.color = (flag ? new Color(0.79f, 0.67f, 0.43f, 0.82f) : new Color(0.64f, 0.62f, 0.57f, flag2 ? 0.5f : 0.27f));
				GUI.DrawTexture(new Rect(Mathf.Round(num5), num - num6 * 0.5f, flag ? 2f : 1f, num6), (Texture)(object)Texture2D.whiteTexture);
				if (flag)
				{
					Texture2D cardinalTexture = GetCardinalTexture(i);
					if (!((Object)(object)cardinalTexture == (Object)null))
					{
						float num7 = Mathf.Clamp(frameHeight * 0.44f, 26f, 36f);
						float num8 = Mathf.Round(num5 - num7 * 0.5f);
						float num9 = Mathf.Max(0f, Mathf.Round(top - num7 * 0.22f));
						GUI.color = Color.white;
						GUI.DrawTexture(new Rect(num8, num9, num7, num7), (Texture)(object)cardinalTexture, (ScaleMode)2, true);
					}
				}
			}
		}

		private Texture2D GetCardinalTexture(int bearing)
		{
			return (Texture2D)(Mathf.RoundToInt(Mathf.Repeat((float)bearing, 360f)) switch
			{
				0 => _cardNTexture, 
				90 => _cardETexture, 
				180 => _cardSTexture, 
				270 => _cardWTexture, 
				_ => null, 
			});
		}

		private void DrawCenterGuide(float centerX, float top, float frameHeight)
		{
			//IL_0014: 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)
			GUI.color = new Color(0.32f, 0.78f, 0.92f, 0.76f);
			GUI.DrawTexture(new Rect(centerX - 1f, top + frameHeight * 0.27f, 2f, frameHeight * 0.18f), (Texture)(object)Texture2D.whiteTexture);
		}

		private void DrawTrackedMarkers(List<WayfinderPinRecord> tracked, float left, float top, float width, float frameHeight, float totalHeight, float heading, float halfArc)
		{
			//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_00a7: 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_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_010f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0108: Unknown result type (might be due to invalid IL or missing references)
			//IL_010d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0233: Unknown result type (might be due to invalid IL or missing references)
			//IL_0238: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0336: Unknown result type (might be due to invalid IL or missing references)
			//IL_030f: Unknown result type (might be due to invalid IL or missing references)
			//IL_031e: Unknown result type (might be due to invalid IL or missing references)
			//IL_048e: Unknown result type (might be due to invalid IL or missing references)
			//IL_049b: Unknown result type (might be due to invalid IL or missing references)
			//IL_052b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0549: Unknown result type (might be due to invalid IL or missing references)
			if (tracked == null || tracked.Count == 0)
			{
				return;
			}
			Vector3 playerPosition = ((Component)Player.m_localPlayer).transform.position;
			bool value = _config.CompassShowDistance.Value;
			bool value2 = _config.CompassShowNames.Value;
			bool value3 = _config.CompassClampOffscreenTracked.Value;
			bool value4 = _config.WaypointShowVerticalDifference.Value;
			tracked.Sort(delegate(WayfinderPinRecord a, WayfinderPinRecord b)
			{
				//IL_0016: 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_0021: Unknown result type (might be due to invalid IL or missing references)
				//IL_0026: Unknown result type (might be due to invalid IL or missing references)
				//IL_0028: Unknown result type (might be due to invalid IL or missing references)
				//IL_002e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0033: 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)
				if (object.ReferenceEquals(a, b))
				{
					return 0;
				}
				if (a == null)
				{
					return -1;
				}
				if (b == null)
				{
					return 1;
				}
				Vector3 val3 = a.Position - playerPosition;
				Vector3 val4 = b.Position - playerPosition;
				float num24 = Mathf.Sqrt(val3.x * val3.x + val3.z * val3.z);
				float num25 = Mathf.Sqrt(val4.x * val4.x + val4.z * val4.z);
				return (Mathf.Abs(num24 - num25) > 0.5f) ? num25.CompareTo(num24) : b.trackSlot.CompareTo(a.trackSlot);
			});
			Vector3 viewForward = default(Vector3);
			for (int num = 0; num < tracked.Count; num++)
			{
				WayfinderPinRecord wayfinderPinRecord = tracked[num];
				if (wayfinderPinRecord == null || !wayfinderPinRecord.tracked)
				{
					continue;
				}
				Vector3 val = wayfinderPinRecord.Position - playerPosition;
				float num2 = Mathf.Sqrt(val.x * val.x + val.z * val.z);
				((Vector3)(ref viewForward))..ctor(val.x, 0f, val.z);
				if (((Vector3)(ref viewForward)).sqrMagnitude < 0.0001f)
				{
					viewForward = GetViewForward();
				}
				float num3 = BearingFromDirection(viewForward);
				float num4 = Mathf.DeltaAngle(heading, num3);
				bool flag = Mathf.Abs(num4) > halfArc;
				if (flag && !value3)
				{
					continue;
				}
				float num5 = ((!flag) ? Mathf.Clamp(num4 / halfArc, -1f, 1f) : ((num4 < 0f) ? (-1f) : 1f));
				float num6 = Mathf.Clamp(width * 0.095f, 38f, 78f);
				float num7 = width * 0.5f - num6;
				float num8 = left + width * 0.5f + num5 * num7;
				if (flag && value3)
				{
					float offscreenStackInsetPixels = GetOffscreenStackInsetPixels(tracked, wayfinderPinRecord, playerPosition, heading, halfArc, num5);
					num8 += ((num5 < 0f) ? offscreenStackInsetPixels : (0f - offscreenStackInsetPixels));
				}
				float num9 = Mathf.Clamp01(Mathf.Abs(num5));
				float num10 = (flag ? 0.7f : Mathf.Lerp(1f, 0.82f, num9));
				bool flag2 = WayfinderDynamicState.IsLastKnownVehicle(wayfinderPinRecord);
				if (flag2)
				{
					num10 *= Mathf.Clamp01(_config.LastKnownVehicleOpacity.Value);
				}
				Color color = TrackedColorPalette.GetColor(wayfinderPinRecord.trackSlot, num10);
				Sprite val2 = ResolveRecordIcon(wayfinderPinRecord);
				float num11 = (flag ? Mathf.Clamp(frameHeight * 0.4f, 24f, 32f) : Mathf.Clamp(frameHeight * 0.46f, 27f, 36f));
				float num12 = num8;
				float num13 = num12 - num11 * 0.5f;
				float num14 = top + frameHeight * 0.08f;
				if ((Object)(object)val2 != (Object)null)
				{
					DrawSprite(new Rect(num13, num14, num11, num11), val2, new Color(1f, 1f, 1f, num10));
				}
				if ((Object)(object)_trackAccentTexture != (Object)null)
				{
					float num15 = (flag ? 15f : 19f);
					float num16 = num15 * 0.6875f;
					float num17 = num12 - num15 * 0.5f;
					float num18 = num14 + num11 - 1f;
					GUI.color = color;
					GUI.DrawTexture(new Rect(num17, num18, num15, num16), (Texture)(object)_trackAccentTexture, (ScaleMode)2, true);
				}
				bool flag3 = HasPreferredTrackedMarkerOverlap(tracked, wayfinderPinRecord, playerPosition, left, width, heading, halfArc, value3, num12, num2);
				string text = string.Empty;
				if (value && !flag3)
				{
					text = (flag2 ? "~" : string.Empty) + Mathf.RoundToInt(num2) + "m";
				}
				if (!flag3 && value4 && Mathf.Abs(val.y) >= 8f)
				{
					int num19 = Mathf.RoundToInt(val.y);
					text += ((num19 >= 0) ? (" +" + num19) : (" " + num19));
				}
				if (!string.IsNullOrEmpty(text))
				{
					float num20 = 104f;
					float num21 = Mathf.Clamp(num12 - num20 * 0.5f, left + 4f, left + width - num20 - 4f);
					string text2 = "T" + (wayfinderPinRecord.trackSlot + 1) + "  " + text;
					if (flag)
					{
						text2 = ((num5 < 0f) ? ("‹ " + text2) : (text2 + " ›"));
					}
					DrawShadowLabel(new Rect(num21, top + frameHeight * 0.76f, num20, 18f), text2, _distanceStyle, color);
				}
				if (value2 && !flag3)
				{
					string text3 = GetRecordName(wayfinderPinRecord);
					if (flag2)
					{
						text3 += " (last known)";
					}
					if (text3.Length > 32)
					{
						text3 = text3.Substring(0, 31) + "...";
					}
					float num22 = 166f;
					float num23 = Mathf.Clamp(num8 - num22 * 0.5f, left + 4f, left + width - num22 - 4f);
					DrawShadowLabel(new Rect(num23, top + frameHeight + 2f, num22, 16f), text3, _nameStyle, new Color(0.88f, 0.84f, 0.75f, num10));
				}
			}
		}

		private bool HasPreferredTrackedMarkerOverlap(List<WayfinderPinRecord> tracked, WayfinderPinRecord current, Vector3 playerPosition, float left, float width, float heading, float halfArc, bool clampOffscreen, float currentMarkerX, float currentDistance)
		{
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			if (tracked == null || current == null || tracked.Count <= 1)
			{
				return false;
			}
			float num = 40f;
			for (int i = 0; i < tracked.Count; i++)
			{
				WayfinderPinRecord wayfinderPinRecord = tracked[i];
				if (wayfinderPinRecord != null && !object.ReferenceEquals(wayfinderPinRecord, current) && wayfinderPinRecord.tracked)
				{
					Vector3 val = wayfinderPinRecord.Position - playerPosition;
					float candidateDistance = Mathf.Sqrt(val.x * val.x + val.z * val.z);
					if (HasTrackingPriority(wayfinderPinRecord, candidateDistance, current, currentDistance) && TryGetTrackedMarkerX(tracked, wayfinderPinRecord, playerPosition, left, width, heading, halfArc, clampOffscreen, out var markerX) && Mathf.Abs(markerX - currentMarkerX) <= num)
					{
						return true;
					}
				}
			}
			return false;
		}

		private float GetOffscreenStackInsetPixels(List<WayfinderPinRecord> tracked, WayfinderPinRecord current, Vector3 playerPosition, float heading, float halfArc, float currentNormalized)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			if (tracked == null || current == null || tracked.Count <= 1)
			{
				return 0f;
			}
			Vector3 val = current.Position - playerPosition;
			float currentDistance = Mathf.Sqrt(val.x * val.x + val.z * val.z);
			int num = 0;
			Vector3 viewForward = default(Vector3);
			for (int i = 0; i < tracked.Count; i++)
			{
				WayfinderPinRecord wayfinderPinRecord = tracked[i];
				if (wayfinderPinRecord == null || object.ReferenceEquals(wayfinderPinRecord, current) || !wayfinderPinRecord.tracked)
				{
					continue;
				}
				Vector3 val2 = wayfinderPinRecord.Position - playerPosition;
				float candidateDistance = Mathf.Sqrt(val2.x * val2.x + val2.z * val2.z);
				if (!HasTrackingPriority(wayfinderPinRecord, candidateDistance, current, currentDistance))
				{
					continue;
				}
				((Vector3)(ref viewForward))..ctor(val2.x, 0f, val2.z);
				if (((Vector3)(ref viewForward)).sqrMagnitude < 0.0001f)
				{
					viewForward = GetViewForward();
				}
				float num2 = BearingFromDirection(viewForward);
				float num3 = Mathf.DeltaAngle(heading, num2);
				if (!(Mathf.Abs(num3) <= halfArc))
				{
					float num4 = ((num3 < 0f) ? (-1f) : 1f);
					if (num4 < 0f == currentNormalized < 0f)
					{
						num++;
					}
				}
			}
			return Mathf.Min(28f, (float)num * 7f);
		}

		private bool TryGetTrackedMarkerX(List<WayfinderPinRecord> tracked, WayfinderPinRecord record, Vector3 playerPosition, float left, float width, float heading, float halfArc, bool clampOffscreen, out float markerX)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: 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_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			markerX = 0f;
			if (record == null)
			{
				return false;
			}
			Vector3 val = record.Position - playerPosition;
			Vector3 viewForward = default(Vector3);
			((Vector3)(ref viewForward))..ctor(val.x, 0f, val.z);
			if (((Vector3)(ref viewForward)).sqrMagnitude < 0.0001f)
			{
				viewForward = GetViewForward();
			}
			float num = BearingFromDirection(viewForward);
			float num2 = Mathf.DeltaAngle(heading, num);
			bool flag = Mathf.Abs(num2) > halfArc;
			if (flag && !clampOffscreen)
			{
				return false;
			}
			float num3 = ((!flag) ? Mathf.Clamp(num2 / halfArc, -1f, 1f) : ((num2 < 0f) ? (-1f) : 1f));
			float num4 = Mathf.Clamp(width * 0.095f, 38f, 78f);
			float num5 = width * 0.5f - num4;
			markerX = left + width * 0.5f + num3 * num5;
			if (flag && clampOffscreen)
			{
				float offscreenStackInsetPixels = GetOffscreenStackInsetPixels(tracked, record, playerPosition, heading, halfArc, num3);
				markerX += ((num3 < 0f) ? offscreenStackInsetPixels : (0f - offscreenStackInsetPixels));
			}
			return true;
		}

		private static bool HasTrackingPriority(WayfinderPinRecord candidate, float candidateDistance, WayfinderPinRecord current, float currentDistance)
		{
			if (candidate == null || current == null)
			{
				return false;
			}
			if (candidateDistance < currentDistance - 0.5f)
			{
				return true;
			}
			if (Mathf.Abs(candidateDistance - currentDistance) <= 0.5f)
			{
				return candidate.trackSlot < current.trackSlot;
			}
			return false;
		}

		private Sprite ResolveRecordIcon(WayfinderPinRecord record)
		{
			if (record == null || _icons == null)
			{
				return null;
			}
			string effectiveIconKey = WayfinderIconPolicy.GetEffectiveIconKey(record);
			if (!string.IsNullOrEmpty(effectiveIconKey) && _icons.TryGet(effectiveIconKey, out var sprite))
			{
				return sprite;
			}
			if (!string.IsNullOrEmpty(record.iconKey) && _icons.TryGet(record.iconKey, out sprite))
			{
				return sprite;
			}
			string key;
			switch (record.category)
			{
			case WayfinderPinCategory.Resource:
				key = "wayfinder:resource";
				break;
			case WayfinderPinCategory.Creature:
				key = "wayfinder:creature";
				break;
			case WayfinderPinCategory.Boss:
				key = "wayfinder:creature";
				break;
			case WayfinderPinCategory.Dungeon:
				key = "wayfinder:dungeon";
				break;
			case WayfinderPinCategory.Spawner:
				key = "wayfinder:spawner";
				break;
			case WayfinderPinCategory.Habitat:
				key = "wayfinder:habitat";
				break;
			case WayfinderPinCategory.Sighting:
				key = "wayfinder:sighting";
				break;
			case WayfinderPinCategory.Vehicle:
				key = "wayfinder:vehicle";
				break;
			case WayfinderPinCategory.Trader:
				key = "wayfinder:trader";
				break;
			case WayfinderPinCategory.Portal:
				key = "wayfinder:portal";
				break;
			case WayfinderPinCategory.Outpost:
				key = "wayfinder:outpost";
				break;
			case WayfinderPinCategory.Farm:
				key = "wayfinder:farm";
				break;
			case WayfinderPinCategory.Dock:
				key = "wayfinder:dock";
				break;
			case WayfinderPinCategory.Road:
				key = "wayfinder:road";
				break;
			case WayfinderPinCategory.Bridge:
				key = "wayfinder:bridge";
				break;
			case WayfinderPinCategory.Camp:
				key = "wayfinder:camp";
				break;
			case WayfinderPinCategory.Storage:
				key = "wayfinder:storage";
				break;
			case WayfinderPinCategory.Danger:
				key = "wayfinder:danger";
				break;
			case WayfinderPinCategory.PointOfInterest:
			case WayfinderPinCategory.Base:
				key = "wayfinder:structure";
				break;
			default:
				key = "wayfinder:custom";
				break;
			}
			if (!_icons.TryGet(key, out sprite))
			{
				return null;
			}
			return sprite;
		}

		private static void DrawSprite(Rect rect, Sprite sprite, Color color)
		{
			//IL_0081: 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_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_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: 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_0077: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)sprite == (Object)null) && !((Object)(object)sprite.texture == (Object)null))
			{
				Color color2 = GUI.color;
				GUI.color = color;
				try
				{
					Rect textureRect = sprite.textureRect;
					Texture2D texture = sprite.texture;
					Rect val = default(Rect);
					((Rect)(ref val))..ctor(((Rect)(ref textureRect)).x / (float)((Texture)texture).width, ((Rect)(ref textureRect)).y / (float)((Texture)texture).height, ((Rect)(ref textureRect)).width / (float)((Texture)texture).width, ((Rect)(ref textureRect)).height / (float)((Texture)texture).height);
					GUI.DrawTextureWithTexCoords(rect, (Texture)(object)texture, val, true);
				}
				catch
				{
					GUI.DrawTexture(rect, (Texture)(object)sprite.texture, (ScaleMode)2, true);
				}
				GUI.color = color2;
			}
		}

		private void EnsureStyles()
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Expected O, but got Unknown
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Expected O, but got Unknown
			if (_distanceStyle == null)
			{
				_distanceStyle = new GUIStyle(GUI.skin.label);
				_distanceStyle.alignment = (TextAnchor)4;
				_distanceStyle.fontSize = 11;
				_distanceStyle.fontStyle = (FontStyle)1;
				_distanceStyle.clipping = (TextClipping)1;
				_nameStyle = new GUIStyle(GUI.skin.label);
				_nameStyle.alignment = (TextAnchor)4;
				_nameStyle.fontSize = 10;
				_nameStyle.fontStyle = (FontStyle)0;
				_nameStyle.clipping = (TextClipping)1;
			}
		}

		private void EnsureArt()
		{
			if ((Object)(object)_frameTexture == (Object)null)
			{
				_frameTexture = LoadEmbeddedRgba("JoeyBadManners.Wayfinder.Assets.wayfinder_compass_hq_frame_v3.rgba", 2059, 155, "Wayfinder HQ Compass Frame V3");
			}
			if ((Object)(object)_trackAccentTexture == (Object)null)
			{
				_trackAccentTexture = LoadEmbeddedRgba("JoeyBadManners.Wayfinder.Assets.wayfinder_compass_hq_track_accent.rgba", 32, 22, "Wayfinder HQ Track Accent");
			}
			if ((Object)(object)_cardNTexture == (Object)null)
			{
				_cardNTexture = LoadEmbeddedRgba("JoeyBadManners.Wayfinder.Assets.wayfinder_compass_hq_card_N.rgba", 112, 112, "Wayfinder HQ Cardinal N");
			}
			if ((Object)(object)_cardETexture == (Object)null)
			{
				_cardETexture = LoadEmbeddedRgba("JoeyBadManners.Wayfinder.Assets.wayfinder_compass_hq_card_E.rgba", 112, 112, "Wayfinder HQ Cardinal E");
			}
			if ((Object)(object)_cardSTexture == (Object)null)
			{
				_cardSTexture = LoadEmbeddedRgba("JoeyBadManners.Wayfinder.Assets.wayfinder_compass_hq_card_S.rgba", 112, 112, "Wayfinder HQ Cardinal S");
			}
			if ((Object)(object)_cardWTexture == (Object)null)
			{
				_cardWTexture = LoadEmbeddedRgba("JoeyBadManners.Wayfinder.Assets.wayfinder_compass_hq_card_W.rgba", 112, 112, "Wayfinder HQ Cardinal W");
			}
		}

		private Texture2D LoadEmbeddedRgba(string resourceName, int width, int height, string textureName)
		{
			//IL_0156: Unknown result type (might be due to invalid IL or missing references)
			//IL_015d: Expected O, but got Unknown
			//IL_0132: Unknown result type (might be due to invalid IL or missing references)
			//IL_0137: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				Assembly executingAssembly = Assembly.GetExecutingAssembly();
				using Stream stream = executingAssembly.GetManifestResourceStream(resourceName);
				if (stream == null)
				{
					if (_config.DebugLogging.Value)
					{
						_log.LogWarning((object)("Missing compass art resource: " + resourceName));
					}
					return null;
				}
				int num = width * height * 4;
				byte[] array = new byte[num];
				int i;
				int num2;
				for (i = 0; i < num; i += num2)
				{
					num2 = stream.Read(array, i, num - i);
					if (num2 <= 0)
					{
						break;
					}
				}
				if (i != num)
				{
					if (_config.DebugLogging.Value)
					{
						_log.LogWarning((object)("Compass art byte count mismatch for " + resourceName + ": " + i + "/" + num));
					}
					return null;
				}
				Color32[] array2 = (Color32[])(object)new Color32[width * height];
				for (int j = 0; j < height; j++)
				{
					int num3 = j * width * 4;
					int num4 = (height - 1 - j) * width;
					for (int k = 0; k < width; k++)
					{
						int num5 = num3 + k * 4;
						ref Color32 reference = ref array2[num4 + k];
						reference = new Color32(array[num5], array[num5 + 1], array[num5 + 2], array[num5 + 3]);
					}
				}
				Texture2D val = new Texture2D(width, height, (TextureFormat)4, false);
				((Object)val).name = textureName;
				((Texture)val).wrapMode = (TextureWrapMode)1;
				((Texture)val).filterMode = (FilterMode)1;
				val.SetPixels32(array2);
				val.Apply(false, false);
				return val;
			}
			catch (Exception ex)
			{
				if (_config.DebugLogging.Value)
				{
					_log.LogWarning((object)("Failed loading compass art " + resourceName + ": " + ex.Message));
				}
				return null;
			}
		}

		private static void DrawShadowLabel(Rect rect, string text, GUIStyle style, Color color)
		{
			//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_0027: 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_0032: 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_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_006f: Unknown result type (might be due to invalid IL or missing references)
			Color color2 = GUI.color;
			GUI.color = new Color(0f, 0f, 0f, Mathf.Clamp01(color.a * 0.96f));
			Rect val = rect;
			((Rect)(ref val)).x = ((Rect)(ref val)).x + 1f;
			((Rect)(ref val)).y = ((Rect)(ref val)).y + 1f;
			GUI.Label(val, text, style);
			GUI.color = color;
			GUI.Label(rect, text, style);
			GUI.color = color2;
		}

		private static Vector3 GetViewForward()
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: 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_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				Camera main = Camera.main;
				if ((Object)(object)main != (Object)null)
				{
					Vector3 forward = ((Component)main).transform.forward;
					forward.y = 0f;
					if (((Vector3)(ref forward)).sqrMagnitude > 0.0001f)
					{
						return ((Vector3)(ref forward)).normalized;
					}
				}
			}
			catch
			{
			}
			if ((Object)(object)Player.m_localPlayer != (Object)null)
			{
				Vector3 forward2 = ((Component)Player.m_localPlayer).transform.forward;
				forward2.y = 0f;
				if (((Vector3)(ref forward2)).sqrMagnitude > 0.0001f)
				{
					return ((Vector3)(ref forward2)).normalized;
				}
			}
			return Vector3.forward;
		}

		private static float BearingFromDirection(Vector3 direction)
		{
			direction.y = 0f;
			if (((Vector3)(ref direction)).sqrMagnitude < 0.0001f)
			{
				return 0f;
			}
			return Mathf.Repeat(Mathf.Atan2(direction.x, direction.z) * 57.29578f, 360f);
		}

		private static string GetRecordName(WayfinderPinRecord record)
		{
			if (record == null)
			{
				return "Tracked Pin";
			}
			if (!string.IsNullOrEmpty(record.displayName))
			{
				return record.displayName;
			}
			if (!string.IsNullOrEmpty(record.subtype))
			{
				return record.subtype;
			}
			return "Tracked Pin";
		}

		private static bool IsLargeMapOpen()
		{
			Minimap instance = Minimap.instance;
			if ((Object)(object)instance == (Object)null)
			{
				return false;
			}
			try
			{
				if (LargeRootField != null)
				{
					object? value = LargeRootField.GetValue(instance);
					GameObject val = (GameObject)((value is GameObject) ? value : null);
					if ((Object)(object)val != (Object)null)
					{
						return val.activeInHierarchy;
					}
				}
			}
			catch
			{
			}
			return false;
		}
	}
}
namespace JoeyBadManners.Wayfinder.Icons
{
	internal sealed class WayfinderIconEntry
	{
		internal string Key;

		internal string PrefabName;

		internal string RawName;

		internal Sprite Sprite;

		internal bool IsTrophy;

		internal string ItemTypeName;
	}
	internal sealed class RuntimeIconRegistry
	{
		private sealed class ScoredIcon
		{
			internal WayfinderIconEntry Entry;

			internal int Score;
		}

		private readonly ManualLogSource _log;

		private readonly WayfinderConfig _config;

		private readonly Dictionary<string, WayfinderIconEntry> _byKey = new Dictionary<string, WayfinderIconEntry>(StringComparer.OrdinalIgnoreCase);

		private readonly Dictionary<string, WayfinderIconEntry> _byPrefab = new Dictionary<string, WayfinderIconEntry>(StringComparer.OrdinalIgnoreCase);

		private readonly List<WayfinderIconEntry> _all = new List<WayfinderIconEntry>();

		private readonly List<WayfinderIconEntry> _trophies = new List<WayfinderIconEntry>();

		internal bool IsBuilt { get; private set; }

		internal bool IsDirty { get; private set; }

		internal IReadOnlyList<WayfinderIconEntry> All => _all;

		internal IReadOnlyList<WayfinderIconEntry> Trophies => _trophies;

		internal RuntimeIconRegistry(ManualLogSource log, WayfinderConfig config)
		{
			_log = log;
			_config = config;
			IsDirty = true;
		}

		internal void MarkDirty()
		{
			IsDirty = true;
		}

		internal void Build(ObjectDB objectDb)
		{
			//IL_0155: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)objectDb == (Object)null || objectDb.m_items == null)
			{
				return;
			}
			_byKey.Clear();
			_byPrefab.Clear();
			_all.Clear();
			_trophies.Clear();
			for (int i = 0; i < objectDb.m_items.Count; i++)
			{
				GameObject val = objectDb.m_items[i];
				if ((Object)(object)val == (Object)null)
				{
					continue;
				}
				ItemDrop component = val.GetComponent<ItemDrop>();
				if ((Object)(object)component == (Object)null || component.m_itemData == null || component.m_itemData.m_shared == null)
				{
					continue;
				}
				Sprite[] icons = component.m_itemData.m_shared.m_icons;
				if (icons != null && icons.Length != 0 && !((Object)(object)icons[0] == (Object)null))
				{
					string text = ((Object)val).name ?? string.Empty;
					string text2 = component.m_itemData.m_shared.m_name ?? text;
					bool flag = text.StartsWith("Trophy", StringComparison.OrdinalIgnoreCase) || text2.IndexOf("trophy", StringComparison.OrdinalIgnoreCase) >= 0;
					WayfinderIconEntry wayfinderIconEntry = new WayfinderIconEntry();
					wayfinderIconEntry.Key = "item:" + text;
					wayfinderIconEntry.PrefabName = text;
					wayfinderIconEntry.RawName = text2;
					wayfinderIconEntry.Sprite = icons[0];
					wayfinderIconEntry.IsTrophy = flag;
					wayfinderIconEntry.ItemTypeName = ((object)component.m_itemData.m_shared.m_itemType).ToString();
					WayfinderIconEntry wayfinderIconEntry2 = wayfinderIconEntry;
					_all.Add(wayfinderIconEntry2);
					_byKey[wayfinderIconEntry2.Key] = wayfinderIconEntry2;
					_byPrefab[text] = wayfinderIconEntry2;
					if (flag)
					{
						_trophies.Add(wayfinderIconEntry2);
					}
				}
			}
			RegisterEmbeddedRgbaIcon("wayfinder:dungeon", "JoeyBadManners.Wayfinder.Assets.wayfinder_dungeon.rgba", "Wayfinder Dungeon", 96, 96);
			RegisterEmbeddedRgbaIcon("wayfinder:poi", "JoeyBadManners.Wayfinder.Assets.wayfinder_poi.rgba", "Wayfinder POI", 96, 96);
			RegisterEmbeddedRgbaIcon("wayfinder:spawner", "JoeyBadManners.Wayfinder.Assets.wayfinder_spawner.rgba", "Wayfinder Spawner", 96, 96);
			RegisterEmbeddedRgbaIcon("wayfinder:structure", "JoeyBadManners.Wayfinder.Assets.wayfinder_structure.rgba", "Wayfinder Structure", 96, 96);
			RegisterEmbeddedRgbaIcon("wayfinder:runestone", "JoeyBadManners.Wayfinder.Assets.wayfinder_runestone.rgba", "Wayfinder Runestone", 96, 96);
			RegisterEmbeddedRgbaIcon("wayfinder:outpost", "JoeyBadManners.Wayfinder.Assets.wayfinder_outpost.rgba", "Wayfinder Outpost", 96, 96);
			RegisterEmbeddedRgbaIcon("wayfinder:farm", "JoeyBadManners.Wayfinder.Assets.wayfinder_farm.rgba", "Wayfinder Farm", 96, 96);
			RegisterEmbeddedRgbaIcon("wayfinder:dock", "JoeyBadManners.Wayfinder.Assets.wayfinder_dock.rgba", "Wayfinder Dock", 96, 96);
			RegisterEmbeddedRgbaIcon("wayfinder:road", "JoeyBadManners.Wayfinder.Assets.wayfinder_road.rgba", "Wayfinder Road", 96, 96);
			RegisterEmbeddedRgbaIcon("wayfinder:bridge", "JoeyBadManners.Wayfinder.Assets.wayfinder_bridge.rgba", "Wayfinder Bridge", 96, 96);
			RegisterEmbeddedRgbaIcon("wayfinder:camp", "JoeyBadManners.Wayfinder.Assets.wayfinder_camp.rgba", "Wayfinder Camp", 96, 96);
			RegisterEmbeddedRgbaIcon("wayfinder:storage", "JoeyBadManners.Wayfinder.Assets.wayfinder_storage.rgba", "Wayfinder Storage", 96, 96);
			RegisterEmbeddedRgbaIcon("wayfinder:portal", "JoeyBadManners.Wayfinder.Assets.wayfinder_portal.rgba", "Wayfinder Portal", 96, 96);
			RegisterEmbeddedRgbaIcon("wayfinder:vehicle", "JoeyBadManners.Wayfinder.Assets.wayfinder_vehicle.rgba", "Wayfinder Vehicle", 96, 96);
			RegisterEmbeddedRgbaIcon("wayfinder:boat", "JoeyBadManners.Wayfinder.Assets.wayfinder_boat.rgba", "Wayfinder Boat", 96, 96);
			RegisterEmbeddedRgbaIcon("wayfinder:cart", "JoeyBadManners.Wayfinder.Assets.wayfinder_cart.rgba", "Wayfinder Cart", 96, 96);
			RegisterEmbeddedRgbaIcon("wayfinder:trader", "JoeyBadManners.Wayfinder.Assets.wayfinder_trader.rgba", "Wayfinder Trader", 96, 96);
			RegisterEmbeddedRgbaIcon("wayfinder:habitat", "JoeyBadManners.Wayfinder.Assets.wayfinder_habitat.rgba", "Wayfinder Habitat", 96, 96);
			RegisterEmbeddedRgbaIcon("wayfinder:sighting", "JoeyBadManners.Wayfinder.Assets.wayfinder_sighting.rgba", "Wayfinder Sighting", 96, 96);
			RegisterEmbeddedRgbaIcon("wayfinder:creature", "JoeyBadManners.Wayfinder.Assets.wayfinder_creature.rgba", "Wayfinder Creature", 96, 96);
			RegisterEmbeddedRgbaIcon("wayfinder:danger", "JoeyBadManners.Wayfinder.Assets.wayfinder_danger.rgba", "Wayfinder Danger", 96, 96);
			RegisterEmbeddedRgbaIcon("wayfinder:gravestone", "JoeyBadManners.Wayfinder.Assets.wayfinder_gravestone.rgba", "Wayfinder Gravestone", 96, 96);
			RegisterEmbeddedRgbaIcon("wayfinder:custom", "JoeyBadManners.Wayfinder.Assets.wayfinder_custom.rgba", "Wayfinder Custom", 96, 96);
			RegisterEmbeddedRgbaIcon("wayfinder:resource", "JoeyBadManners.Wayfinder.Assets.wayfinder_resource.rgba", "Wayfinder Resource", 96, 96);
			RegisterEmbeddedRgbaIcon("wayfinder:active_waypoint", "JoeyBadManners.Wayfinder.Assets.wayfinder_active_waypoint.rgba", "Wayfinder Active Waypoint", 96, 96);
			IsBuilt = true;
			IsDirty = false;
			if (_config != null && _config.DebugLogging.Value && _config.VerboseRuntimeLogging.Value)
			{
				_log.LogInfo((object)("Wayfinder runtime icon registry built: " + _all.Count + " icons total, " + _trophies.Count + " trophy candidates (including embedded Wayfinder UI icons)."));
			}
		}

		internal bool TryGet(string key, out Sprite sprite)
		{
			sprite = null;
			if (string.IsNullOrEmpty(key))
			{
				return false;
			}
			if (_byKey.TryGetValue(key, out var value) && (Object)(object)value.Sprite != (Object)null)
			{
				sprite = value.Sprite;
				return true;
			}
			return false;
		}

		internal bool TryGetItem(string prefabName, out Sprite sprite)
		{
			sprite = null;
			if (!string.IsNullOrEmpty(prefabName) && _byPrefab.TryGetValue(prefabName, out var value) && (Object)(object)value.Sprite != (Object)null)
			{
				sprite = value.Sprite;
				return true;
			}
			return false;
		}

		private void RegisterEmbeddedRgbaIcon(string key, string resourceName, string displayName, int width, int height)
		{
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Expected O, but got Unknown
			//IL_0159: Unknown result type (might be due to invalid IL or missing references)
			//IL_0168: Unknown result type (might be due to invalid IL or missing references)
			//IL_0109: Unknown result type (might be due to invalid IL or missing references)
			//IL_010e: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				Assembly executingAssembly = Assembly.GetExecutingAssembly();
				using Stream stream = executingAssembly.GetManifestResourceStream(resourceName);
				if (stream == null)
				{
					_log.LogWarning((object)("Embedded Wayfinder icon was not found: " + resourceName));
					return;
				}
				int num = checked(width * height * 4);
				byte[] array = new byte[num];
				int i;
				int num2;
				for (i = 0; i < array.Length; i += num2)
				{
					num2 = stream.Read(array, i, array.Length - i);
					if (num2 <= 0)
					{
						break;
					}
				}
				if (i != num)
				{
					_log.LogWarning((object)("Embedded Wayfinder icon had unexpected RGBA byte length: " + resourceName));
					return;
				}
				Texture2D val = new Texture2D(width, height, (TextureFormat)4, false);
				((Object)val).name = displayName + " Texture";
				((Texture)val).wrapMode = (TextureWrapMode)1;
				((Texture)val).filterMode = (FilterMode)1;
				Color32[] array2 = (Color32[])(object)new Color32[width * height];
				for (int j = 0; j < height; j++)
				{
					int num3 = j * width * 4;
					int num4 = (height - 1 - j) * width;
					for (int k = 0; k < width; k++)
					{
						int num5 = num3 + k * 4;
						ref Color32 reference = ref array2[num4 + k];
						reference = new Color32(array[num5], array[num5 + 1], array[num5 + 2], array[num5 + 3]);
					}
				}
				val.SetPixels32(array2);
				val.Apply(false, false);
				Sprite val2 = Sprite.Create(val, new Rect(0f, 0f, (float)((Texture)val).width, (float)((Texture)val).height), new Vector2(0.5f, 0.5f), 100f);
				((Object)val2).name = displayName;
				WayfinderIconEntry wayfinderIconEntry = new WayfinderIconEntry();
				wayfinderIconEntry.Key = key;
				wayfinderIconEntry.PrefabName = key;
				wayfinderIconEntry.RawName = displayName;
				wayfinderIconEntry.Sprite = val2;
				wayfinderIconEntry.IsTrophy = false;
				wayfinderIconEntry.ItemTypeName = "Wayfinder";
				WayfinderIconEntry wayfinderIconEntry2 = wayfinderIconEntry;
				_byKey[key] = wayfinderIconEntry2;
				_all.Add(wayfinderIconEntry2);
			}
			catch (Exception ex)
			{
				_log.LogWarning((object)("Could not load embedded Wayfinder icon " + resourceName + ": " + ex.Message));
			}
		}

		internal WayfinderIconEntry FindBestItem(params string[] candidates)
		{
			if (candidates == null || candidates.Length == 0)
			{
				return null;
			}
			foreach (string text in candidates)
			{
				if (!string.IsNullOrEmpty(text) && _byPrefab.TryGetValue(text, out var value) && value != null && (Object)(object)value.Sprite != (Object)null)
				{
					return value;
				}
			}
			WayfinderIconEntry result = null;
			int num = int.MinValue;
			for (int j = 0; j < _all.Count; j++)
			{
				WayfinderIconEntry wayfinderIconEntry = _all[j];
				if (wayfinderIconEntry == null || (Object)(object)wayfinderIconEntry.Sprite == (Object)null || wayfinderIconEntry.IsTrophy)
				{
					continue;
				}
				string text2 = Normalize(wayfinderIconEntry.PrefabName);
				string text3 = Normalize(wayfinderIconEntry.RawName);
				string text4 = string.Empty;
				try
				{
					if (Localization.instance != null && !string.IsNullOrEmpty(wayfinderIconEntry.RawName))
					{
						text4 = Normalize(Localization.instance.Localize(wayfinderIconEntry.RawName));
					}
				}
				catch
				{
				}
				for (int k = 0; k < candidates.Length; k++)
				{
					string text5 = Normalize(candidates[k]);
					if (!string.IsNullOrEmpty(text5))
					{
						int num2 = 0;
						if (text2 == text5)
						{
							num2 += 2000;
						}
						if (text4 == text5)
						{
							num2 += 1900;
						}
						if (text3 == text5)
						{
							num2 += 1800;
						}
						if (text2.EndsWith(text5, StringComparison.Ordinal))
						{
							num2 += 700 + text5.Length;
						}
						if (text4.EndsWith(text5, StringComparison.Ordinal))
						{
							num2 += 650 + text5.Length;
						}
						if (text3.EndsWith(text5, StringComparison.Ordinal))
						{
							num2 += 600 + text5.Length;
						}
						if (text2.Contains(text5))
						{
							num2 += 300 + text5.Length;
						}
						if (text4.Contains(text5))
						{
							num2 += 280 + text5.Length;
						}
						if (text3.Contains(text5))
						{
							num2 += 260 + text5.Length;
						}
						if (num2 > num)
						{
							num = num2;
							result = wayfinderIconEntry;
						}
					}
				}
			}
			if (num <= 0)
			{
				return null;
			}
			return result;
		}

		internal string FindBestItemKey(params string[] candidates)
		{
			WayfinderIconEntry wayfinderIconEntry = FindBestItem(candidates);
			if (wayfinderIconEntry != null)
			{
				return wayfinderIconEntry.Key;
			}
			return string.Empty;
		}

		internal WayfinderIconEntry FindBestTrophy(string creaturePrefabName)
		{
			if (!string.IsNullOrEmpty(creaturePrefabName))
			{
				string text = Normalize(creaturePrefabName);
				if (text == "troll" || text.Contains("summonedtroll") || text.Contains("trollclone"))
				{
					WayfinderIconEntry wayfinderIconEntry = FindByPrefab("TrophyFrostTroll");
					if (wayfinderIconEntry != null)
					{
						return wayfinderIconEntry;
					}
				}
				if (text.Contains("greyling"))
				{
					WayfinderIconEntry wayfinderIconEntry2 = FindByPrefab("TrophyGreydwarf");
					if (wayfinderIconEntry2 != null)
					{
						return wayfinderIconEntry2;
					}
				}
				if (text.Contains("stonegolem") || text == "golem")
				{
					WayfinderIconEntry wayfinderIconEntry3 = FindByPrefab("TrophySGolem");
					if (wayfinderIconEntry3 != null)
					{
						return wayfinderIconEntry3;
					}
				}
				if (text.Contains("greydwarfbrute"))
				{
					WayfinderIconEntry wayfinderIconEntry4 = FindByPrefab("TrophyGreydwarfBrute");
					if (wayfinderIconEntry4 != null)
					{
						return wayfinderIconEntry4;
					}
				}
			}
			return FindBestTrophyInternal(creaturePrefabName, compareRawName: true);
		}

		internal WayfinderIconEntry FindBestBossTrophy(string bossPinName)
		{
			if (string.IsNullOrEmpty(bossPinName))
			{
				return null;
			}
			string text = bossPinName;
			try
			{
				if (Localization.instance != null)
				{
					text = Localization.instance.Localize(bossPinName);
				}
			}
			catch
			{
			}
			string text2 = Normalize(text + " " + bossPinName);
			WayfinderIconEntry wayfinderIconEntry = null;
			if (text2.Contains("eikthyr"))
			{
				wayfinderIconEntry = FindByPrefab("TrophyEikthyr");
			}
			else if (text2.Contains("elder") || text2.Contains("gdking"))
			{
				wayfinderIconEntry = FindByPrefab("TrophyTheElder");
			}
			else if (text2.Contains("bonemass"))
			{
				wayfinderIconEntry = FindByPrefab("TrophyBonemass");
			}
			else if (text2.Contains("moder") || text2.Contains("dragonqueen"))
			{
				wayfinderIconEntry = FindByPrefab("TrophyDragonQueen");
			}
			else if (text2.Contains("yagluth") || text2.Contains("goblinking"))
			{
				wayfinderIconEntry = FindByPrefab("TrophyGoblinKing");
			}
			else if (text2.Contains("queen") || text2.Contains("seekerqueen"))
			{
				wayfinderIconEntry = FindByPrefab("TrophySeekerQueen");
			}
			else if (text2.Contains("fader"))
			{
				wayfinderIconEntry = FindByPrefab("TrophyFader");
			}
			if (wayfinderIconEntry != null && (Object)(object)wayfinderIconEntry.Sprite != (Object)null)
			{
				return wayfinderIconEntry;
			}
			return FindBestTrophyInternal(text, compareRawName: true);
		}

		internal List<WayfinderIconEntry> Search(string query, int maxResults)
		{
			return Search(query, WayfinderPinCategory.Custom, maxResults);
		}

		internal List<WayfinderIconEntry> Search(string query, WayfinderPinCategory category, int maxResults)
		{
			List<ScoredIcon> list = new List<ScoredIcon>();
			if (_all.Count == 0)
			{
				return new List<WayfinderIconEntry>();
			}
			string text = Normalize(query ?? string.Empty);
			int num = ((maxResults <= 0) ? 40 : maxResults);
			for (int i = 0; i < _all.Count; i++)
			{
				WayfinderIconEntry wayfinderIconEntry = _all[i];
				if (wayfinderIconEntry == null || (Object)(object)wayfinderIconEntry.Sprite == (Object)null || !IsCompatibleWithCategory(wayfinderIconEntry, category))
				{
					continue;
				}
				string text2 = string.Empty;
				try
				{
					if (Localization.instance != null && !string.IsNullOrEmpty(wayfinderIconEntry.RawName))
					{
						text2 = Localization.instance.Localize(wayfinderIconEntry.RawName);
					}
				}
				catch
				{
				}
				string text3 = Normalize((wayfinderIconEntry.Key ?? string.Empty) + " " + (wayfinderIconEntry.PrefabName ?? string.Empty) + " " + (wayfinderIconEntry.RawName ?? string.Empty) + " " + text2 + " " + (wayfinderIconEntry.IsTrophy ? " trophy creature enemy boss" : " item resource icon"));
				if (!string.IsNullOrEmpty(text) && !text3.Contains(text))
				{
					continue;
				}
				int num2 = CategoryPriority(wayfinderIconEntry, category);
				if (!string.IsNullOrEmpty(text))
				{
					string text4 = Normalize(wayfinderIconEntry.PrefabName);
					string text5 = Normalize(wayfinderIconEntry.RawName);
					string text6 = Normalize(text2);
					if (text4 == text)
					{
						num2 += 5000;
					}
					if (text6 == text)
					{
						num2 += 4500;
					}
					if (text5 == text)
					{
						num2 += 4000;
					}
					if (text4.StartsWith(text, StringComparison.Ordinal))
					{
						num2 += 1200;
					}
					if (text6.StartsWith(text, StringComparison.Ordinal))
					{
						num2 += 1100;
					}
					if (text5.StartsWith(text, StringComparison.Ordinal))
					{
						num2 += 1000;
					}
				}
				list.Add(new ScoredIcon
				{
					Entry = wayfinderIconEntry,
					Score = num2
				});
			}
			list.Sort(delegate(ScoredIcon a, ScoredIcon b)
			{
				int num4 = b.Score.CompareTo(a.Score);
				return (num4 != 0) ? num4 : string.Compare((a.Entry == null) ? string.Empty : a.Entry.PrefabName, (b.Entry == null) ? string.Empty : b.Entry.PrefabName, StringComparison.OrdinalIgnoreCase);
			});
			List<WayfinderIconEntry> list2 = new List<WayfinderIconEntry>();
			for (int num3 = 0; num3 < list.Count; num3++)
			{
				if (list2.Count >= num)
				{
					break;
				}
				list2.Add(list[num3].Entry);
			}
			return list2;
		}

		internal bool IsCompatibleWithCategory(WayfinderIconEntry entry, WayfinderPinCategory category)
		{
			if (entry == null)
			{
				return false;
			}
			bool flag = !string.IsNullOrEmpty(entry.Key) && entry.Key.StartsWith("wayfinder:", StringComparison.OrdinalIgnoreCase);
			switch (category)
			{
			case WayfinderPinCategory.Boss:
				return IsBossTrophy(entry);
			case WayfinderPinCategory.Creature:
				if (!string.Equals(entry.Key, "wayfinder:creature", StringComparison.OrdinalIgnoreCase))
				{
					if (entry.IsTrophy)
					{
						return !IsBossTrophy(entry);
					}
					return false;
				}
				return true;
			case WayfinderPinCategory.Sighting:
				if (!string.Equals(entry.Key, "wayfinder:sighting", StringComparison.OrdinalIgnoreCase))
				{
					if (entry.IsTrophy)
					{
						return !IsBossTrophy(entry);
					}
					return false;
				}
				return true;
			case WayfinderPinCategory.Habitat:
				if (!string.Equals(entry.Key, "wayfinder:habitat", StringComparison.OrdinalIgnoreCase))
				{
					if (entry.IsTrophy)
					{
						return !IsBossTrophy(entry);
					}
					return false;
				}
				return true;
			case WayfinderPinCategory.Spawner:
				if (!string.Equals(entry.Key, "wayfinder:spawner", StringComparison.OrdinalIgnoreCase))
				{
					if (entry.IsTrophy)
					{
						return !IsBossTrophy(entry);
					}
					return false;
				}
				return true;
			case WayfinderPinCategory.Resource:
				if (!string.Equals(entry.Key, "wayfinder:resource", StringComparison.OrdinalIgnoreCase))
				{
					if (!entry.IsTrophy && !flag)
					{
						return IsResourceLikeItem(entry);
					}
					return false;
				}
				return true;
			case WayfinderPinCategory.Dungeon:
				return string.Equals(entry.Key, "wayfinder:dungeon", StringComparison.OrdinalIgnoreCase);
			case WayfinderPinCategory.PointOfInterest:
				if (!string.Equals(entry.Key, "wayfinder:structure", StringComparison.OrdinalIgnoreCase))
				{
					return string.Equals(entry.Key, "wayfinder:runestone", StringComparison.OrdinalIgnoreCase);
				}
				return true;
			case WayfinderPinCategory.Vehicle:
				if (!string.Equals(entry.Key, "wayfinder:vehicle", StringComparison.OrdinalIgnoreCase) && !string.Equals(entry.Key, "wayfinder:boat", StringComparison.OrdinalIgnoreCase) && !string.Equals(entry.Key, "wayfinder:cart", StringComparison.OrdinalIgnoreCase))
				{
					if (!entry.IsTrophy && !flag)
					{
						return EntryMatchesAny(entry, "boat", "ship", "raft", "karve", "longship", "drakkar", "cart");
					}
					return false;
				}
				return true;
			case WayfinderPinCategory.Trader:
				if (!string.Equals(entry.Key, "wayfinder:trader", StringComparison.OrdinalIgnoreCase))
				{
					if (!entry.IsTrophy && !flag)
					{
						return EntryMatchesAny(entry, "coin", "amber", "ruby", "silvernecklace", "gold");
					}
					return false;
				}
				return true;
			case WayfinderPinCategory.Portal:
				if (!string.Equals(entry.Key, "wayfinder:portal", StringComparison.OrdinalIgnoreCase))
				{
					if (!entry.IsTrophy && !flag)
					{
						return EntryMatchesAny(entry, "portal", "surtlingcore", "greydwarfeye");
					}
					return false;
				}
				return true;
			case WayfinderPinCategory.Base:
				if (!string.Equals(entry.Key, "wayfinder:structure", StringComparison.OrdinalIgnoreCase))
				{
					if (!entry.IsTrophy && !flag)
					{
						return EntryMatchesAny(entry, "hammer", "wood", "stone", "workbench", "bed", "fire", "chest", "banner");
					}
					return false;
				}
				return true;
			case WayfinderPinCategory.Outpost:
				if (!string.Equals(entry.Key, "wayfinder:outpost", StringComparison.OrdinalIgnoreCase))
				{
					if (!entry.IsTrophy && !flag)
					{
						return EntryMatchesAny(entry, "tower", "fort", "keep", "banner", "torch", "stone", "wood");
					}
					return false;
				}
				return true;
			case WayfinderPinCategory.Farm:
				if (!string.Equals(entry.Key, "wayfinder:farm", StringComparison.OrdinalIgnoreCase))
				{
					if (!entry.IsTrophy && !flag)
					{
						return EntryMatchesAny(entry, "seed", "carrot", "turnip", "onion", "barley", "flax", "cultivator", "hoe", "mushroom", "berry", "raspberry", "blueberry");
					}
					return false;
				}
				return true;
			case WayfinderPinCategory.Dock:
				if (!string.Equals(entry.Key, "wayfinder:dock", StringComparison.OrdinalIgnoreCase))
				{
					if (!entry.IsTrophy && !flag)
					{
						return EntryMatchesAny(entry, "anchor", "boat", "ship", "raft", "karve", "longship", "drakkar", "wood", "iron");
					}
					return false;
				}
				return true;
			case WayfinderPinCategory.Road:
				if (!string.Equals(entry.Key, "wayfinder:road", StringComparison.OrdinalIgnoreCase))
				{
					if (!entry.IsTrophy && !flag)
					{
						return EntryMatchesAny(entry, "hoe", "stone", "wood", "pickaxe");
					}
					return false;
				}
				return true;
			case WayfinderPinCategory.Bridge:
				if (!string.Equals(entry.Key, "wayfinder:bridge", StringComparison.OrdinalIgnoreCase))
				{
					if (!entry.IsTrophy && !flag)
					{
						return EntryMatchesAny(entry, "wood", "stone", "iron");
					}
					return false;
				}
				return true;
			case WayfinderPinCategory.Camp:
				if (!string.Equals(entry.Key, "wayfinder:camp", StringComparison.OrdinalIgnoreCase))
				{
					if (!entry.IsTrophy && !flag)
					{
						return EntryMatchesAny(entry, "fire", "torch", "bed", "wood", "tent", "banner");
					}
					return false;
				}
				return true;
			case WayfinderPinCategory.Storage:
				if (!string.Equals(entry.Key, "wayfinder:storage", StringComparison.OrdinalIgnoreCase))
				{
					if (!entry.IsTrophy && !flag)
					{
						return EntryMatchesAny(entry, "chest", "crate", "barrel", "box", "coin");
					}
					return false;
				}
				return true;
			case WayfinderPinCategory.Danger:
				if (!string.Equals(entry.Key, "wayfinder:danger", StringComparison.OrdinalIgnoreCase))
				{
					if (entry.IsTrophy)
					{
						return !IsBossTrophy(entry);
					}
					return false;
				}
				return true;
			default:
				return true;
			}
		}

		internal static bool IsBossTrophy(WayfinderIconEntry entry)
		{
			if (entry == null || !entry.IsTrophy)
			{
				return false;
			}
			string text = Normalize(entry.PrefabName);
			if (!(text == Normalize("TrophyEikthyr")) && !(text == Normalize("TrophyTheElder")) && !(text == Normalize("TrophyBonemass")) && !(text == Normalize("TrophyDragonQueen")) && !(text == Normalize("TrophyGoblinKing")) && !(text == Normalize("TrophySeekerQueen")))
			{
				return text == Normalize("TrophyFader");
			}
			return true;
		}

		private static bool IsResourceLikeItem(WayfinderIconEntry entry)
		{
			if (entry == null)
			{
				return false;
			}
			string text = Normalize(entry.ItemTypeName);
			if (string.IsNullOrEmpty(text))
			{
				return true;
			}
			if (text.Contains("weapon") || text.Contains("armor") || text.Contains("helmet") || text.Contains("chest") || text.Contains("legs") || text.Contains("hands") || text.Contains("shoulder") || text.Contains("shield") || text.Contains("bow") || text.Contains("tool") || text.Contains("torch") || text.Contains("ammo") || text.Contains("utility"))
			{
				return false;
			}
			return true;
		}

		private static bool EntryMatchesAny(WayfinderIconEntry entry, params string[] needles)
		{
			if (entry == null || needles == null || needles.Length == 0)
			{
				return false;
			}
			string text = string.Empty;
			try
			{
				if (Localization.instance != null && !string.IsNullOrEmpty(entry.RawName))
				{
					text = Localization.instance.Localize(entry.RawName);
				}
			}
			catch
			{
			}
			string text2 = Normalize((entry.Key ?? string.Empty) + " " + (entry.PrefabName ?? string.Empty) + " " + (entry.RawName ?? string.Empty) + " " + text);
			for (int i = 0; i < needles.Length; i++)
			{
				string value = Normalize(needles[i]);
				if (!string.IsNullOrEmpty(value) && text2.Contains(value))
				{
					return true;
				}
			}
			return false;
		}

		private static int CategoryPriority(WayfinderIconEntry entry, WayfinderPinCategory category)
		{
			if (entry == null)
			{
				return 0;
			}
			string text = string.Empty;
			switch (category)
			{
			case WayfinderPinCategory.Resource:
				text = "wayfinder:resource";
				break;
			case WayfinderPinCategory.Creature:
				text = "wayfinder:creature";
				break;
			case WayfinderPinCategory.Dungeon:
				text = "wayfinder:dungeon";
				break;
			case WayfinderPinCategory.PointOfInterest:
				text = "wayfinder:structure";
				break;
			case WayfinderPinCategory.Spawner:
				text = "wayfinder:spawner";
				break;
			case WayfinderPinCategory.Habitat:
				text = "wayfinder:habitat";
				break;
			case WayfinderPinCategory.Sighting:
				text = "wayfinder:sighting";
				break;
			case WayfinderPinCategory.Vehicle:
				text = "wayfinder:vehicle";
				break;
			case WayfinderPinCategory.Trader:
				text = "wayfinder:trader";
				break;
			case WayfinderPinCategory.Portal:
				text = "wayfinder:portal";
				break;
			case WayfinderPinCategory.Base:
				text = "wayfinder:structure";
				break;
			case WayfinderPinCategory.Outpost:
				text = "wayfinder:outpost";
				break;
			case WayfinderPinCategory.Farm:
				text = "wayfinder:farm";
				break;
			case WayfinderPinCategory.Dock:
				text = "wayfinder:dock";
				break;
			case WayfinderPinCategory.Road:
				text = "wayfinder:road";
				break;
			case WayfinderPinCategory.Bridge:
				text = "wayfinder:bridge";
				break;
			case WayfinderPinCategory.Camp:
				text = "wayfinder:camp";
				break;
			case WayfinderPinCategory.Storage:
				text = "wayfinder:storage";
				break;
			case WayfinderPinCategory.Danger:
				text = "wayfinder:danger";
				break;
			}
			if (!string.IsNullOrEmpty(text) && string.Equals(entry.Key, text, StringComparison.OrdinalIgnoreCase))
			{
				return 15000;
			}
			if (category == WayfinderPinCategory.PointOfInterest && string.Equals(entry.Key, "wayfinder:runestone", StringComparison.OrdinalIgnoreCase))
			{
				return 14000;
			}
			if (category == WayfinderPinCategory.Boss && IsBossTrophy(entry))
			{
				return 12000;
			}
			if (entry.IsTrophy && (category == WayfinderPinCategory.Creature || category == WayfinderPinCategory.Sighting || category == WayfinderPinCategory.Habitat || category == WayfinderPinCategory.Spawner || category == WayfinderPinCategory.Danger))
			{
				return 5000;
			}
			return 100;
		}

		private WayfinderIconEntry FindBestTrophyInternal(string creatureName, bool compareRawName)
		{
			if (string.IsNullOrEmpty(creatureName))
			{
				return null;
			}
			string text = Normalize(creatureName);
			WayfinderIconEntry result = null;
			int num = int.MinValue;
			for (int i = 0; i < _trophies.Count; i++)
			{
				WayfinderIconEntry wayfinderIconEntry = _trophies[i];
				string text2 = Normalize(wayfinderIconEntry.PrefabName.Replace("Trophy", string.Empty));
				string text3 = (compareRawName ? Normalize(wayfinderIconEntry.RawName) : string.Empty);
				string text4 = string.Empty;
				if (compareRawName)
				{
					try
					{
						if (Localization.instance != null && !string.IsNullOrEmpty(wayfinderIconEntry.RawName))
						{
							text4 = Normalize(Localization.instance.Localize(wayfinderIconEntry.RawName));
						}
					}
					catch
					{
					}
				}
				if (text2.Length != 0)
				{
					int num2 = 0;
					if (text2 == text)
					{
						num2 += 1000;
					}
					if (text.Contains(text2))
					{
						num2 += 200 + text2.Length;
					}
					if (text2.Contains(text))
					{
						num2 += 100 + text.Length;
					}
					if (compareRawName && text3.Contains(text))
					{
						num2 += 300 + text.Length;
					}
					if (compareRawName && text4.Contains(text))
					{
						num2 += 500 + text.Length;
					}
					if (compareRawName && text.Contains(text4) && text4.Length > 3)
					{
						num2 += 350 + text4.Length;
					}
					if (num2 > num)
					{
						num = num2;
						result = wayfinderIconEntry;
					}
				}
			}
			if (num <= 0)
			{
				return null;
			}
			return result;
		}

		private WayfinderIconEntry FindByPrefab(string prefabName)
		{
			if (!_byPrefab.TryGetValue(prefabName, out var value))
			{
				return null;
			}
			return value;
		}

		private static string Normalize(string value)
		{
			if (string.IsNullOrEmpty(value))
			{
				return string.Empty;
			}
			char[] array = new char[value.Length];
			int length = 0;
			for (int i = 0; i < value.Length; i++)
			{
				char c = char.ToLowerInvariant(value[i]);
				if (char.IsLetterOrDigit(c))
				{
					array[length++] = c;
				}
			}
			return new string(array, 0, length);
		}
	}
	internal static class WayfinderIconPolicy
	{
		internal static WayfinderPinCategory ClassifyGeneratedLocation(string prefabName)
		{
			string text = Normalize(prefabName);
			if (ContainsAny(text, "hildircave", "hildircrypt", "hildirplainsfortress", "mistlandsdvergrtownentrance"))
			{
				return WayfinderPinCategory.Dungeon;
			}
			if (text.Contains("tarpit"))
			{
				return WayfinderPinCategory.Danger;
			}
			if (IsDungeon(text))
			{
				return WayfinderPinCategory.Dungeon;
			}
			if (ContainsAny(text, "drakenest", "volturenest"))
			{
				return WayfinderPinCategory.Habitat;
			}
			if (ContainsAny(text, "watchtower", "tower", "outpost", "fort", "keep", "lighthouse"))
			{
				return WayfinderPinCategory.Outpost;
			}
			if (ContainsAny(text, "farm", "field", "barley", "flax"))
			{
				return WayfinderPinCategory.Farm;
			}
			if (ContainsAny(text, "dock", "harbor", "harbour", "pier", "shipyard"))
			{
				return WayfinderPinCategory.Dock;
			}
			if (text.Contains("bridge") || text.Contains("viaduct"))
			{
				return WayfinderPinCategory.Bridge;
			}
			if (ContainsAny(text, "road", "path", "causeway"))
			{
				return WayfinderPinCategory.Road;
			}
			if (ContainsAny(text, "camp", "campsite", "tent", "village", "settlement"))
			{
				return WayfinderPinCategory.Camp;
			}
			if (ContainsAny(text, "storage", "warehouse", "storehouse"))
			{
				return WayfinderPinCategory.Storage;
			}
			if (text.Contains("portal"))
			{
				return WayfinderPinCategory.Portal;
			}
			return WayfinderPinCategory.PointOfInterest;
		}

		internal static string GetGeneratedLocationIconKey(string prefabName, WayfinderPinCategory category)
		{
			string n = Normalize(prefabName);
			if (IsRunestone(n))
			{
				return "wayfinder:runestone";
			}
			return category switch
			{
				WayfinderPinCategory.Dungeon => "wayfinder:dungeon", 
				WayfinderPinCategory.Habitat => "wayfinder:habitat", 
				WayfinderPinCategory.Outpost => "wayfinder:outpost", 
				WayfinderPinCategory.Farm => "wayfinder:farm", 
				WayfinderPinCategory.Dock => "wayfinder:dock", 
				WayfinderPinCategory.Road => "wayfinder:road", 
				WayfinderPinCategory.Bridge => "wayfinder:bridge", 
				WayfinderPinCategory.Camp => "wayfinder:camp", 
				WayfinderPinCategory.Storage => "wayfinder:storage", 
				WayfinderPinCategory.Portal => "wayfinder:portal", 
				WayfinderPinCategory.Danger => "wayfinder:danger", 
				_ => "wayfinder:structure", 
			};
		}

		internal static string GetGeneratedLocationDisplayName(string prefabName)
		{
			string text = Normalize(prefabName);
			if (text.StartsWith("crypt"))
			{
				return "Burial Chamber";
			}
			if (text.StartsWith("trollcave"))
			{
				return "Troll Cave";
			}
			if (text.StartsWith("mountaincave"))
			{
				return "Frost Cave";
			}
			if (text.StartsWith("sunkencrypt"))
			{
				return "Sunken Crypt";
			}
			if (text.StartsWith("hildircave"))
			{
				return "Howling Caverns";
			}
			if (text.StartsWith("hildircrypt"))
			{
				return "Smouldering Tombs";
			}
			if (text.StartsWith("hildirplainsfortress"))
			{
				return "Sealed Tower";
			}
			if (text.StartsWith("mistlandsdvergrtownentrance"))
			{
				return "Infested Mine";
			}
			if (text.StartsWith("mistlandsdvergrbossentrance"))
			{
				return "Infested Citadel";
			}
			if (text.StartsWith("goblincamp"))
			{
				return "Fuling Village";
			}
			if (text.StartsWith("greydwarfcamp"))
			{
				return "Greydwarf Camp";
			}
			if (text.StartsWith("drakenest"))
			{
				return "Drake Nest";
			}
			if (text.StartsWith("volturenest"))
			{
				return "Volture Nest";
			}
			if (text.StartsWith("morgenhole"))
			{
				return "Morgen Cave";
			}
			if (text.StartsWith("mistlandsguardtower") && text.Contains("ruined"))
			{
				return "Ruined Dvergr Guard Tower";
			}
			if (text.StartsWith("mistlandsguardtower"))
			{
				return "Dvergr Guard Tower";
			}
			if (text.StartsWith("mistlandslighthouse"))
			{
				return "Dvergr Lighthouse";
			}
			if (text.StartsWith("mistlandsexcavation"))
			{
				return "Dvergr Excavation";
			}
			if (text.StartsWith("mistlandsstatuegroup") || text.StartsWith("mistlandsstatue"))
			{
				return "Mistlands Statue";
			}
			if (text.StartsWith("stonetowerruins"))
			{
				return "Ruined Stone Tower";
			}
			if (text.StartsWith("stonetower"))
			{
				return "Stone Tower";
			}
			if (text.StartsWith("stonehouse"))
			{
				return "Stone House";
			}
			if (text.StartsWith("woodhouse"))
			{
				return "Abandoned House";
			}
			if (text.StartsWith("abandonedlogcabin"))
			{
				return "Abandoned Cabin";
			}
			if (text.StartsWith("charredtowerruins"))
			{
				return "Ruined Charred Tower";
			}
			if (text.StartsWith("charredruins"))
			{
				return "Charred Ruins";
			}
			if (text.StartsWith("ashlandruins"))
			{
				return "Ashlands Ruins";
			}
			if (text.StartsWith("fortressruins"))
			{
				return "Fortress Ruins";
			}
			if (text.StartsWith("shipwreck"))
			{
				return "Shipwreck";
			}
			if (text.StartsWith("shipsetting"))
			{
				return "Viking Graveyard";
			}
			if (text.StartsWith("tarpit"))
			{
				return "Tar Pit";
			}
			if (text.StartsWith("dolmen"))
			{
				return "Dolmen";
			}
			if (text.StartsWith("stonecircle"))
			{
				return "Ancient Stone Circle";
			}
			if (text.StartsWith("mountaingrave"))
			{
				return "Mountain Grave";
			}
			if (text.StartsWith("swampwell") || text.StartsWith("mountainwell"))
			{
				return "Inverted Tower";
			}
			if (text.StartsWith("bigrockclearing"))
			{
				return "Big Rock Clearing";
			}
			if (text.StartsWith("mistlandsharbour"))
			{
				return "Dvergr Harbour";
			}
			if (text.StartsWith("mistlandsviaduct"))
			{
				return "Dvergr Viaduct";
			}
			if (text.StartsWith("mistlandsroadpost"))
			{
				return "Dvergr Road Post";
			}
			return HumanizePrefabName(prefabName);
		}

		internal static string GetEffectiveIconKey(WayfinderPinRecord record)
		{
			if (record == null)
			{
				return string.Empty;
			}
			if (record.iconOverride)
			{
				return record.iconOverrideKey ?? string.Empty;
			}
			return GetDefaultIconKey(record);
		}

		internal static string GetDefaultIconKey(WayfinderPinRecord record)
		{
			if (record == null)
			{
				return string.Empty;
			}
			if (record.source == WayfinderPinSource.Manual || record.source == WayfinderPinSource.Imported)
			{
				return record.iconKey ?? string.Empty;
			}
			string text = record.subtype ?? string.Empty;
			string text2 = record.displayName ?? string.Empty;
			string text3 = Normalize(text + " " + text2);
			if (record.category == WayfinderPinCategory.Habitat || ContainsAny(text3, "drakenest", "volturenest"))
			{
				return "wayfinder:habitat";
			}
			if (IsSpawnerLike(text3))
			{
				return "wayfinder:spawner";
			}
			if (string.Equals(record.iconKey, "wayfinder:runestone", StringComparison.OrdinalIgnoreCase))
			{
				return "wayfinder:runestone";
			}
			if (IsRunestone(text3))
			{
				return "wayfinder:runestone";
			}
			if (text3.Contains("portal"))
			{
				return "wayfinder:portal";
			}
			if (record.category == WayfinderPinCategory.Dungeon || IsDungeon(text3))
			{
				return "wayfinder:dungeon";
			}
			if (IsGeneratedLocationCategory(record.category))
			{
				return GetGeneratedLocationIconKey(text + " " + text2, record.category);
			}
			if (record.category != WayfinderPinCategory.Resource)
			{
				WayfinderPinCategory category = ClassifyGeneratedLocation(text + " " + text2);
				if (IsGeneratedLocationCategory(category) && LooksLikeGeneratedSite(text3))
				{
					return GetGeneratedLocationIconKey(text + " " + text2, category);
				}
			}
			if (record.category == WayfinderPinCategory.Resource)
			{
				string text4 = ResolveAutoResourceIconKey(text3, record.iconKey);
				if (!string.IsNullOrEmpty(text4))
				{
					return text4;
				}
			}
			if ((record.category == WayfinderPinCategory.Unknown || record.category == WayfinderPinCategory.Custom) && LooksLikeResource(text3))
			{
				string text5 = ResolveAutoResourceIconKey(text3, record.iconKey);
				if (!string.IsNullOrEmpty(text5))
				{
					return text5;
				}
			}
			if (record.category == WayfinderPinCategory.Vehicle)
			{
				if (ContainsAny(text3, "cart", "vagon", "wagon"))
				{
					return "wayfinder:cart";
				}
				if (ContainsAny(text3, "boat", "ship", "raft", "karve", "longship", "vikingship", "drakkar", "ashland"))
				{
					return "wayfinder:boat";
				}
				return "wayfinder:vehicle";
			}
			switch (record.category)
			{
			case WayfinderPinCategory.Spawner:
				return "wayfinder:spawner";
			case WayfinderPinCategory.Habitat:
				return "wayfinder:habitat";
			case WayfinderPinCategory.Sighting:
				if (!string.IsNullOrEmpty(record.iconKey))
				{
					return record.iconKey;
				}
				return "wayfinder:sighting";
			case WayfinderPinCategory.Trader:
				return "wayfinder:trader";
			case WayfinderPinCategory.Danger:
				return "wayfinder:danger";
			case WayfinderPinCategory.Base:
				return "wayfinder:structure";
			case WayfinderPinCategory.Custom:
				if (!string.IsNullOrEmpty(record.iconKey))
				{
					return record.iconKey;
				}
				return "wayfinder:custom";
			default:
				return record.iconKey ?? string.Empty;
			}
		}

		internal static float GetVisualScale(WayfinderPinRecord record, string effectiveIconKey)
		{
			float num = ((record == null) ? 1f : Mathf.Max(0.25f, record.scale));
			if (string.IsNullOrEmpty(effectiveIconKey) || !effectiveIconKey.StartsWith("wayfinder:", StringComparison.OrdinalIgnoreCase))
			{
				return num;
			}
			switch (effectiveIconKey)
			{
			case "wayfinder:dungeon":
				return Mathf.Max(num, 1.2f);
			case "wayfinder:spawner":
				return Mathf.Max(num, 1.18f);
			case "wayfinder:runestone":
				return Mathf.Max(num, 1.15f);
			case "wayfinder:boat":
			case "wayfinder:cart":
				return Mathf.Max(num, 1.14f);
			case "wayfinder:structure":
			case "wayfinder:outpost":
			case "wayfinder:farm":
			case "wayfinder:dock":
			case "wayfinder:road":
			case "wayfinder:bridge":
			case "wayfinder:camp":
			case "wayfinder:storage":
			case "wayfinder:portal":
				return Mathf.Max(num, 1.16f);
			default:
				return num;
			}
		}

		internal static bool IsGeneratedLocationCategory(WayfinderPinCategory category)
		{
			if (category != WayfinderPinCategory.Dungeon && category != WayfinderPinCategory.PointOfInterest && category != WayfinderPinCategory.Outpost && category != WayfinderPinCategory.Farm && category != WayfinderPinCategory.Dock && category != WayfinderPinCategory.Road && category != WayfinderPinCategory.Bridge && category != WayfinderPinCategory.Camp && category != WayfinderPinCategory.Storage)
			{
				return category == WayfinderPinCategory.Portal;
			}
			return true;
		}

		internal static bool IsRunestoneName(string name)
		{
			return IsRunestone(Normalize(name));
		}

		internal static bool IsVegvisirName(string name)
		{
			string text = Normalize(name);
			if (!string.IsNullOrEmpty(text))
			{
				return text.Contains("vegvisir");
			}
			return false;
		}

		internal static bool IsBossGuidanceRunestoneName(string name)
		{
			string text = Normalize(name);
			if (string.IsNullOrEmpty(text))
			{
				return false;
			}
			if (ContainsAny(text, "starttemple", "sacrificial", "bossstone", "bossrune", "bossrunestone"))
			{
				return true;
			}
			if (text.Contains("vegvisir"))
			{
				return text.Contains("eikthyr");
			}
			return false;
		}

		private static bool IsRunestone(string n)
		{
			return ContainsAny(n, "runestone", "lorestone", "rune", "vegvisir");
		}

		private static bool IsDungeon(string n)
		{
			return ContainsAny(n, "crypt", "burial", "chamber", "cave", "mine", "tomb", "dungeon", "citadel", "sealedtower", "howlingcavern", "smoulderingtomb", "putridhole", "morgenhole");
		}

		private static bool LooksLikeGeneratedSite(string n)
		{
			return ContainsAny(n, "hut", "house", "tower", "watchtower", "lighthouse", "outpost", "camp", "village", "settlement", "cabin", "farm", "fort", "keep", "ruin", "hall", "bridge", "viaduct", "dock", "harbor", "harbour", "pier", "shipwreck", "building", "structure", "road", "path", "causeway", "portal", "warehouse", "storehouse", "excavation", "grave", "well", "dolmen", "statue");
		}

		private static string HumanizePrefabName(string prefabName)
		{
			if (string.IsNullOrEmpty(prefabName))
			{
				return "Point of Interest";
			}
			string text = prefabName.Replace("(Clone)", string.Empty).Replace('_', ' ').Trim();
			StringBuilder stringBuilder = new StringBuilder(text.Length + 8);
			char c = '\0';
			for (int i = 0; i < text.Length; i++)
			{
				char c2 = text[i];
				if (i > 0 && c2 != ' ' && c != ' ' && ((char.IsUpper(c2) && char.IsLower(c)) || (char.IsDigit(c2) && !char.IsDigit(c))))
				{
					stringBuilder.Append(' ');
				}
				stringBuilder.Append(c2);
				c = c2;
			}
			return stringBuilder.ToString().Trim();
		}

		private static bool LooksLikeResource(string n)
		{
			return ContainsAny(n, "copper", "tin", "obsidian", "silver", "ironscrap", "scrapiron", "muddy", "flametal", "blackmarble", "softtissue", "crystal", "guck", "branch", "wood", "flint", "stone", "dandelion", "raspberries", "blueberries", "thistle", "mushroom");
		}

		private static string ResolveAutoResourceIconKey(string n, string existingKey)
		{
			if (string.IsNullOrEmpty(n))
			{
				if (!string.IsNullOrEmpty(existingKey) && existingKey.StartsWith("item:", StringComparison.OrdinalIgnoreCase))
				{
					return existingKey;
				}
				return "wayfinder:resource";
			}
			if (n.Contains("copper"))
			{
				return "item:CopperOre";
			}
			if (n.Contains("tin"))
			{
				return "item:TinOre";
			}
			if (n.Contains("obsidian"))
			{
				return "item:Obsidian";
			}
			if (n.Contains("silver"))
			{
				return "item:SilverOre";
			}
			if (n.Contains("ironscrap") || n.Contains("scrapiron") || n.Contains("muddy"))
			{
				return "item:IronScrap";
			}
			if (n.Contains("flametal"))
			{
				return "item:FlametalOreNew";
			}
			if (n.Contains("blackmarble"))
			{
				return "item:BlackMarble";
			}
			if (n.Contains("softtissue"))
			{
				return "item:SoftTissue";
			}
			if (n.Contains("crystal"))
			{
				return "item:Crystal";
			}
			if (n.Contains("guck"))
			{
				return "item:Guck";
			}
			if (n.Contains("wood") || n.Contains("branch"))
			{
				return "item:Wood";
			}
			if (n.Contains("flint"))
			{
				return "item:Flint";
			}
			if (n.Contains("stone"))
			{
				return "item:Stone";
			}
			if (n.Contains("dandelion"))
			{
				return "item:Dandelion";
			}
			if (n.Contains("raspberr"))
			{
				return "item:Raspberry";
			}
			if (n.Contains("blueberr"))
			{
				return "item:Blueberries";
			}
			if (n.Contains("thistle"))
			{
				return "item:Thistle";
			}
			if (n.Contains("mushroom"))
			{
				return "item:Mushroom";
			}
			if (!string.IsNullOrEmpty(existingKey) && existingKey.StartsWith("item:", StringComparison.OrdinalIgnoreCase))
			{
				return existingKey;
			}
			return "wayfinder:resource";
		}

		private static bool IsSpawnerLike(string n)
		{
			return ContainsAny(n, "spawner", "greydwarfnest", "bonepile", "bodypile", "monumentoftorment", "effigyofmalice", "firehole", "surtling", "nest");
		}

		private static bool ContainsAny(string value, params string[] needles)
		{
			if (string.IsNullOrEmpty(value) || needles == null)
			{
				return false;
			}
			for (int i = 0; i < needles.Length; i++)
			{
				if (!string.IsNullOrEmpty(needles[i]) && value.Contains(needles[i]))
				{
					return true;
				}
			}
			return false;
		}

		internal static string Normalize(string value)
		{
			if (string.IsNullOrEmpty(value))
			{
				return string.Empty;
			}
			char[] array = new char[value.Length];
			int length = 0;
			for (int i = 0; i < value.Length; i++)
			{
				char c = char.ToLowerInvariant(value[i]);
				if (char.IsLetterOrDigit(c))
				{
					array[length++] = c;
				}
			}
			return new string(array, 0, length);
		}
	}
}
namespace JoeyBadManners.Wayfinder.Management
{
	internal static class WayfinderBossNaming
	{
		private static readonly string[] _keys = new string[7] { "Eikthyr", "TheElder", "Bonemass", "Moder", "Yagluth", "Queen", "Fader" };

		internal static string[] KnownKeys => _keys;

		internal static string IdentifyBossKey(string sourceName)
		{
			if (string.IsNullOrEmpty(sourceName))
			{
				return string.Empty;
			}
			string text = sourceName;
			try
			{
				if (Localization.instance != null)
				{
					text = Localization.instance.Localize(sourceName);
				}
			}
			catch
			{
			}
			string text2 = Normalize(text + " " + sourceName);
			if (text2.Contains("eikthyr"))
			{
				return "Eikthyr";
			}
			if (text2.Contains("elder") || text2.Contains("gdking"))
			{
				return "TheElder";
			}
			if (text2.Contains("bonemass"))
			{
				return "Bonemass";
			}
			if (text2.Contains("moder") || text2.Contains("dragonqueen"))
			{
				return "Moder";
			}
			if (text2.Contains("yagluth") || text2.Contains("goblinking"))
			{
				return "Yagluth";
			}
			if (text2.Contains("seekerqueen") || text2 == "queen" || text2.Contains("thequeen"))
			{
				return "Queen";
			}
			if (text2.Contains("fader"))
			{
				return "Fader";
			}
			return string.Empty;
		}

		internal static string DefaultDisplayName(string key)
		{
			switch (key)
			{
			case "Eikthyr":
				return "Eikthyr";
			case "TheElder":
				return "The Elder";
			case "Bonemass":
				return "Bonemass";
			case "Moder":
				return "Moder";
			case "Yagluth":
				return "Yagluth";
			case "Queen":
				return "The Queen";
			case "Fader":
				return "Fader";
			default:
				if (!string.IsNullOrEmpty(key))
				{
					return key;
				}
				return "Boss";
			}
		}

		internal static string GetDisplayName(WayfinderConfig config, string key)
		{
			if (string.IsNullOrEmpty(key))
			{
				return string.Empty;
			}
			Dictionary<string, string> dictionary = Parse(config);
			if (dictionary.TryGetValue(key, out var value) && !string.IsNullOrEmpty(value))
			{
				return value;
			}
			return DefaultDisplayName(key);
		}

		internal static void SetDisplayName(WayfinderConfig config, string key, string value)
		{
			if (config == null || string.IsNullOrEmpty(key))
			{
				return;
			}
			Dictionary<string, string> dictionary = Parse(config);
			string text = (string.IsNullOrEmpty(value) ? string.Empty : value.Trim());
			dictionary[key] = (string.IsNullOrEmpty(text) ? DefaultDisplayName(key) : text);
			List<string> list = new List<string>();
			for (int i = 0; i < _keys.Length; i++)
			{
				string text2 = _keys[i];
				if (!dictionary.TryGetValue(text2, out var value2) || string.IsNullOrEmpty(value2))
				{
					value2 = DefaultDisplayName(text2);
				}
				value2 = value2.Replace(";", " ").Replace("=", " ");
				list.Add(text2 + "=" + value2);
			}
			config.BossNameOverrides.Value = string.Join(";", list.ToArray());
		}

		private static Dictionary<string, string> Parse(WayfinderConfig config)
		{
			Dictionary<string, string> dictionary = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
			if (config == null)
			{
				return dictionary;
			}
			string text = config.BossNameOverrides.Value ?? string.Empty;
			string[] array = text.Split(new char[1] { ';' }, StringSplitOptions.RemoveEmptyEntries);
			for (int i = 0; i < array.Length; i++)
			{
				int num = array[i].IndexOf('=');
				if (num > 0)
				{
					string text2 = array[i].Substring(0, num).Trim();
					string value = array[i].Substring(num + 1).Trim();
					if (!string.IsNullOrEmpty(text2))
					{
						dictionary[text2] = value;
					}
				}
			}
			return dictionary;
		}

		private static string Normalize(string value)
		{
			if (string.IsNullOrEmpty(value))
			{
				return string.Empty;
			}
			char[] array = new char[value.Length];
			int length = 0;
			for (int i = 0; i < value.Length; i++)
			{
				char c = char.ToLowerInvariant(value[i]);
				if (char.IsLetterOrDigit(c))
				{
					array[length++] = c;
				}
			}
			return new string(array, 0, length);
		}
	}
	internal sealed class WayfinderPinManagementService
	{
		private readonly WayfinderConfig _config;

		private readonly WayfinderPinDatabase _database;

		private readonly HashSet<WayfinderPinCategory> _hidden = new HashSet<WayfinderPinCategory>();

		private string _lastHiddenValue;

		internal IReadOnlyList<WayfinderPinRecord> Records => _database.Records;

		internal int MaxTrackedPins => Mathf.Clamp(_config.MaxTrackedPins.Value, 1, 5);

		internal int TrackedCount
		{
			get
			{
				EnsureTrackedSlots();
				int num = 0;
				IReadOnlyList<WayfinderPinRecord> records = _database.Records;
				for (int i = 0; i < records.Count; i++)
				{
					WayfinderPinRecord wayfinderPinRecord = records[i];
					if (wayfinderPinRecord != null && wayfinderPinRecord.tracked)
					{
						num++;
					}
				}
				return num;
			}
		}

		internal WayfinderPinManagementService(WayfinderConfig config, WayfinderPinDatabase database)
		{
			_config = config;
			_database = database;
		}

		internal bool IsCategoryVisible(WayfinderPinCategory category)
		{
			RefreshHiddenCache();
			return !_hidden.Contains(category);
		}

		internal void SetCategoryVisible(WayfinderPinCategory category, bool visible)
		{
			RefreshHiddenCache();
			if (visible)
			{
				_hidden.Remove(category);
			}
			else
			{
				_hidden.Add(category);
			}
			PersistHiddenCategories();
		}

		internal List<WayfinderPinRecord> Search(string query, bool favoritesOnly, int maxResults)
		{
			return Search(query, favoritesOnly, null, maxResults);
		}

		internal List<WayfinderPinRecord> Search(string query, bool favoritesOnly, WayfinderPinCategory? categoryOnly, int maxResults)
		{
			List<WayfinderPinRecord> list = new List<WayfinderPinRecord>();
			string value = (string.IsNullOrEmpty(query) ? string.Empty : query.Trim().ToLowerInvariant());
			IReadOnlyList<WayfinderPinRecord> records = _database.Records;
			for (int i = 0; i < records.Count; i++)
			{
				WayfinderPinRecord wayfinderPinRecord = records[i];
				if (wayfinderPinRecord == null || (favoritesOnly && !wayfinderPinRecord.favorite) || (categoryOnly.HasValue && wayfinderPinRecord.category != categoryOnly.Value))
				{
					continue;
				}
				if (!string.IsNullOrEmpty(value))
				{
					string text = (wayfinderPinRecord.displayName ?? string.Empty).ToLowerInvariant();
					string text2 = (wayfinderPinRecord.subtype ?? string.Empty).ToLowerInvariant();
					string text3 = wayfinderPinRecord.category.ToString().ToLowerInvariant();
					string text4 = (wayfinderPinRecord.portalTag ?? string.Empty).ToLowerInvariant();
					if (!text.Contains(value) && !text2.Contains(value) && !text3.Contains(value) && !text4.Contains(value))
					{
						continue;
					}
				}
				list.Add(wayfinderPinRecord);
			}
			list.Sort(CompareRecords);
			if (maxResults > 0 && list.Count > maxResults)
			{
				list.RemoveRange(maxResults, list.Count - maxResults);
			}
			return list;
		}

		internal int CountOtherPortalsWithTag(WayfinderPinRecord portal)
		{
			if (portal == null || portal.category != WayfinderPinCategory.Portal || string.IsNullOrEmpty(portal.portalTag))
			{
				return 0;
			}
			int num = 0;
			IReadOnlyList<WayfinderPinRecord> records = _database.Records;
			for (int i = 0; i < records.Count; i++)
			{
				WayfinderPinRecord wayfinderPinRecord = records[i];
				if (wayfinderPinRecord != null && !object.ReferenceEquals(wayfinderPinRecord, portal) && wayfinderPinRecord.category == WayfinderPinCategory.Portal && string.Equals(wayfinderPinRecord.portalTag ?? string.Empty, portal.portalTag, StringComparison.OrdinalIgnoreCase))
				{
					num++;
				}
			}
			return num;
		}

		internal WayfinderPinRecord FindNearestPortalTagPartner(WayfinderPinRecord portal)
		{
			//IL_0079: 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_0093: 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)
			if (portal == null || portal.category != WayfinderPinCategory.Portal || string.IsNullOrEmpty(portal.portalTag))
			{
				return null;
			}
			WayfinderPinRecord result = null;
			float num = float.MaxValue;
			IReadOnlyList<WayfinderPinRecord> records = _database.Records;
			for (int i = 0; i < records.Count; i++)
			{
				WayfinderPinRecord wayfinderPinRecord = records[i];
				if (wayfinderPinRecord != null && !object.ReferenceEquals(wayfinderPinRecord, portal) && wayfinderPinRecord.category == WayfinderPinCategory.Portal && string.Equals(wayfinderPinRecord.portalTag ?? string.Empty, portal.portalTag, StringComparison.OrdinalIgnoreCase))
				{
					float num2 = wayfinderPinRecord.Position.x - portal.Position.x;
					float num3 = wayfinderPinRecord.Position.z - portal.Position.z;
					float num4 = num2 * num2 + num3 * num3;
					if (num4 < num)
					{
						num = num4;
						result = wayfinderPinRecord;
					}
				}
			}
			return result;
		}

		internal WayfinderPinRecord Find(string id)
		{
			if (string.IsNullOrEmpty(id))
			{
				return null;
			}
			IReadOnlyList<WayfinderPinRecord> records = _database.Records;
			for (int i = 0; i < records.Count; i++)
			{
				WayfinderPinRecord wayfinderPinRecord = records[i];
				if (wayfinderPinRecord != null && wayfinderPinRecord.id == id)
				{
					return wayfinderPinRecord;
				}
			}
			return null;
		}

		internal bool Rename(string id, string newName)
		{
			WayfinderPinRecord wayfinderPinRecord = Find(id);
			if (wayfinderPinRecord == null)
			{
				return false;
			}
			string text = (string.IsNullOrEmpty(newName) ? string.Empty : newName.Trim());
			if (wayfinderPinRecord.category == WayfinderPinCategory.Portal)
			{
				wayfinderPinRecord.portalNameOverride = true;
				wayfinderPinRecord.displayName = (string.IsNullOrEmpty(text) ? "Portal" : text);
			}
			else if (wayfinderPinRecord.category == WayfinderPinCategory.Vehicle && wayfinderPinRecord.source == WayfinderPinSource.Dynamic)
			{
				wayfinderPinRecord.vehicleNameOverride = true;
				wayfinderPinRecord.displayName = (string.IsNullOrEmpty(text) ? WayfinderVehicleNaming.GetAutomaticDisplayName(wayfinderPinRecord) : text);
			}
			else
			{
				wayfinderPinRecord.displayName = (string.IsNullOrEmpty(text) ? wayfinderPinRecord.subtype : text);
			}
			_database.AddOrUpdate(wayfinderPinRecord);
			return true;
		}

		internal bool UsePortalTagName(string id)
		{
			WayfinderPinRecord wayfinderPinRecord = Find(id);
			if (wayfinderPinRecord == null || wayfinderPinRecord.category != WayfinderPinCategory.Portal)
			{
				return false;
			}
			wayfinderPinRecord.portalNameOverride = false;
			wayfinderPinRecord.displayName = (string.IsNullOrEmpty(wayfinderPinRecord.portalTag) ? "Portal" : wayfinderPinRecord.portalTag);
			_database.AddOrUpdate(wayfinderPinRecord);
			return true;
		}

		internal bool UseVehicleTypeName(string id)
		{
			WayfinderPinRecord wayfinderPinRecord = Find(id);
			if (wayfinderPinRecord == null || wayfinderPinRecord.category != WayfinderPinCategory.Vehicle || wayfinderPinRecord.source != WayfinderPinSource.Dynamic)
			{
				return false;
			}
			wayfinderPinRecord.vehicleNameOverride = false;
			wayfinderPinRecord.displayName = WayfinderVehicleNaming.GetAutomaticDisplayName(wayfinderPinRecord);
			_database.AddOrUpdate(wayfinderPinRecord);
			return true;
		}

		internal List<WayfinderPinRecord> GetTrackedPins()
		{
			EnsureTrackedSlots();
			List<WayfinderPinRecord> list = new List<WayfinderPinRecord>();
			IReadOnlyList<WayfinderPinRecord> records = _database.Records;
			for (int i = 0; i < records.Count; i++)
			{
				WayfinderPinRecord wayfinderPinRecord = records[i];
				if (wayfinderPinRecord != null && wayfinderPinRecord.tracked)
				{
					list.Add(wayfinderPinRecord);
				}
			}
			list.Sort(delegate(WayfinderPinRecord a, WayfinderPinRecord b)
			{
				int num = a?.trackSlot ?? 999;
				int value = b?.trackSlot ?? 999;
				int num2 = num.CompareTo(value);
				return (num2 == 0) ? CompareRecords(a, b) : num2;
			});
			return list;
		}

		internal bool SetTracked(string id, bool tracked)
		{
			EnsureTrackedSlots();
			WayfinderPinRecord wayfinderPinRecord = Find(id);
			if (wayfinderPinRecord == null)
			{
				return false;
			}
			if (!tracked)
			{
				wayfinderPinRecord.tracked = false;
				wayfinderPinRecord.trackSlot = -1;
				_database.MarkMetadataChanged();
				return true;
			}
			if (wayfinderPinRecord.tracked)
			{
				return true;
			}
			if (TrackedCount >= MaxTrackedPins)
			{
				return false;
			}
			int num = FindFirstFreeTrackSlot();
			if (num < 0)
			{
				return false;
			}
			wayfinderPinRecord.tracked = true;
			wayfinderPinRecord.trackSlot = num;
			_database.MarkMetadataChanged();
			return true;
		}

		private int FindFirstFreeTrackSlot()
		{
			bool[] array = new bool[5];
			IReadOnlyList<WayfinderPinRecord> records = _database.Records;
			for (int i = 0; i < records.Count; i++)
			{
				WayfinderPinRecord wayfinderPinRecord = records[i];
				if (wayfinderPinRecord != null && wayfinderPinRecord.tracked && wayfinderPinRecord.trackSlot >= 0 && wayfinderPinRecord.trackSlot < array.Length)
				{
					array[wayfinderPinRecord.trackSlot] = true;
				}
			}
			int num = Mathf.Min(MaxTrackedPins, array.Length);
			for (int j = 0; j < num; j++)
			{
				if (!array[j])
				{
					return j;
				}
			}
			return -1;
		}

		private void EnsureTrackedSlots()
		{
			IReadOnlyList<WayfinderPinRecord> records = _database.Records;
			if (records == null)
			{
				return;
			}
			List<WayfinderPinRecord> list = new List<WayfinderPinRecord>();
			bool flag = false;
			for (int i = 0; i < records.Count; i++)
			{
				WayfinderPinRecord wayfinderPinRecord = records[i];
				if (wayfinderPinRecord == null)
				{
					continue;
				}
				if (!wayfinderPinRecord.tracked)
				{
					if (wayfinderPinRecord.trackSlot != -1)
					{
						wayfinderPinRecord.trackSlot = -1;
						flag = true;
					}
				}
				else
				{
					list.Add(wayfinderPinRecord);
				}
			}
			list.Sort(delegate(WayfinderPinRecord a, WayfinderPinRecord b)
			{
				bool flag2 = a != null && a.trackSlot >= 0 && a.trackSlot < MaxTrackedPins;
				bool flag3 = b != null && b.trackSlot >= 0 && b.trackSlot < MaxTrackedPins;
				if (flag2 != flag3)
				{
					if (!flag2)
					{
						return 1;
					}
					return -1;
				}
				return (flag2 && flag3 && a.trackSlot != b.trackSlot) ? a.trackSlot.CompareTo(b.trackSlot) : CompareRecords(a, b);
			});
			bool[] array = new bool[5];
			for (int num = 0; num < list.Count; num++)
			{
				WayfinderPinRecord wayfinderPinRecord2 = list[num];
				if (wayfinderPinRecord2 == null)
				{
					continue;
				}
				int num2 = wayfinderPinRecord2.trackSlot;
				if (num2 < 0 || num2 >= MaxTrackedPins || num2 >= array.Length || array[num2])
				{
					num2 = -1;
					int num3 = Mathf.Min(MaxTrackedPins, array.Length);
					for (int num4 = 0; num4 < num3; num4++)
					{
						if (!array[num4])
						{
							num2 = num4;
							break;
						}
					}
					if (num2 < 0)
					{
						wayfinderPinRecord2.tracked = false;
						wayfinderPinRecord2.trackSlot = -1;
						flag = true;
						continue;
					}
					if (wayfinderPinRecord2.trackSlot != num2)
					{
						wayfinderPinRecord2.trackSlot = num2;
						flag = true;
					}
				}
				array[num2] = true;
			}
			if (flag)
			{
				_database.MarkMetadataChanged();
			}
		}

		internal bool SetFavorite(string id, bool favorite)
		{
			WayfinderPinRecord wayfinderPinRecord = Find(id);
			if (wayfinderPinRecord == null)
			{
				return false;
			}
			wayfinderPinRecord.favorite = favorite;
			_database.AddOrUpdate(wayfinderPinRecord);
			return true;
		}

		internal bool SetScale(string id, float scale)
		{
			WayfinderPinRecord wayfinderPinRecord = Find(id);
			if (wayfinderPinRecord == null)
			{
				return false;
			}
			wayfinderPinRecord.scale = Mathf.Clamp(scale, 0.5f, 2.5f);
			_database.AddOrUpdate(wayfinderPinRecord);
			return true;
		}

		internal bool SetCategory(string id, WayfinderPinCategory category)
		{
			WayfinderPinRecord wayfinderPinRecord = Find(id);
			if (wayfinderPinRecord == null)
			{
				return false;
			}
			wayfinderPinRecord.category = category;
			_database.AddOrUpdate(wayfinderPinRecord);
			return true;
		}

		internal bool SetColor(string id, Color color)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			WayfinderPinRecord wayfinderPinRecord = Find(id);
			if (wayfinderPinRecord == null)
			{
				return false;
			}
			wayfinderPinRecord.Color = color;
			_database.AddOrUpdate(wayfinderPinRecord);
			return true;
		}

		internal bool ResetColorToDefault(string id)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			WayfinderPinRecord wayfinderPinRecord = Find(id);
			if (wayfinderPinRecord == null)
			{
				return false;
			}
			wayfinderPinRecord.Color = Color.white;
			_database.AddOrUpdate(wayfinderPinRecord);
			return true;
		}

		internal bool SetIcon(string id, string iconKey)
		{
			WayfinderPinRecord wayfinderPinRecord = Find(id);
			if (wayfinderPinRecord == null)
			{
				return false;
			}
			string iconOverrideKey = iconKey ?? string.Empty;
			wayfinderPinRecord.iconOverride = true;
			wayfinderPinRecord.iconOverrideKey = iconOverrideKey;
			_database.AddOrUpdate(wayfinderPinRecord);
			return true;
		}

		internal bool ResetIconToDefault(string id)
		{
			WayfinderPinRecord wayfinderPinRecord = Find(id);
			if (wayfinderPinRecord == null)
			{
				return false;
			}
			wayfinderPinRecord.iconOverride = false;
			wayfinderPinRecord.iconOverrideKey = string.Empty;
			_database.AddOrUpdate(wayfinderPinRecord);
			return true;
		}

		internal WayfinderPinRecord CreateManualPin(string displayName, WayfinderPinCategory category, Vector3 position, string iconKey)
		{
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			string text = (string.IsNullOrEmpty(displayName) ? "Wayfinder Pin" : displayName.Trim());
			WayfinderPinRecord wayfinderPinRecord = new WayfinderPinRecord();
			wayfinderPinRecord.id = Guid.NewGuid().ToString("N");
			wayfinderPinRecord.displayName = (string.IsNullOrEmpty(text) ? "Wayfinder Pin" : text);
			wayfinderPinRecord.subtype = "manual:" + category.ToString().ToLowerInvariant();
			wayfinderPinRecord.iconKey = iconKey ?? string.Empty;
			wayfinderPinRecord.category = category;
			wayfinderPinRecord.source = WayfinderPinSource.Manual;
			wayfinderPinRecord.Position = position;
			wayfinderPinRecord.count = 1;
			wayfinderPinRecord.isCluster = false;
			wayfinderPinRecord.scale = 1f;
			wayfinderPinRecord.favorite = false;
			wayfinderPinRecord.tracked = false;
			wayfinderPinRecord.trackSlot = -1;
			WayfinderPinRecord wayfinderPinRecord2 = wayfinderPinRecord;
			wayfinderPinRecord2.members.Add(new WayfinderClusterMember("manual:" + wayfinderPinRecord2.id, position));
			_database.AddOrUpdate(wayfinderPinRecord2);
			return wayfinderPinRecord2;
		}

		internal bool Delete(string id)
		{
			return _database.Remove(id);
		}

		private void RefreshHiddenCache()
		{
			string text = _config.HiddenCategories.Value ?? string.Empty;
			if (string.Equals(text, _lastHiddenValue, StringComparison.Ordinal))
			{
				return;
			}
			_lastHiddenValue = text;
			_hidden.Clear();
			string[] array = text.Split(new char[2] { ',', ';' }, StringSplitOptions.RemoveEmptyEntries);
			for (int i = 0; i < array.Length; i++)
			{
				if (Enum.TryParse<WayfinderPinCategory>(array[i].Trim(), ignoreCase: true, out var result))
				{
					_hidden.Add(result);
				}
			}
		}

		private void PersistHiddenCategories()
		{
			List<string> list = new List<string>();
			foreach (WayfinderPinCategory item in _hidden)
			{
				list.Add(item.ToString());
			}
			list.Sort(StringComparer.OrdinalIgnoreCase);
			_config.HiddenCategories.Value = string.Join(",", list.ToArray());
			_lastHiddenValue = _config.HiddenCategories.Value ?? string.Empty;
		}

		private static int CompareRecords(WayfinderPinRecord a, WayfinderPinRecord b)
		{
			if (object.ReferenceEquals(a, b))
			{
				return 0;
			}
			if (a == null)
			{
				return 1;
			}
			if (b == null)
			{
				return -1;
			}
			if (a.favorite != b.favorite)
			{
				if (!a.favorite)
				{
					return 1;
				}
				return -1;
			}
			string strA = (string.IsNullOrEmpty(a.displayName) ? a.subtype : a.displayName);
			string strB = (string.IsNullOrEmpty(b.displayName) ? b.subtype : b.displayName);
			int num = string.Compare(strA, strB, StringComparison.OrdinalIgnoreCase);
			if (num != 0)
			{
				return num;
			}
			return string.Compare(a.id, b.id, StringComparison.Ordinal);
		}
	}
	internal sealed class WayfinderPinManagerUI
	{
		private enum ManagerView
		{
			Full,
			Create,
			Pins,
			Visibility,
			Tracking
		}

		private enum ControlGlyph
		{
			Create,
			Pins,
			Visibility,
			Tracking
		}

		private const float MapPlacementDragThresholdPixels = 8f;

		private static readonly FieldInfo LargeRootField = AccessTools.Field(typeof(Minimap), "m_largeRoot");

		private static readonly MethodInfo[] MinimapMethods = typeof(Minimap).GetMethods(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);

		private readonly ManualLogSource _log;

		private readonly WayfinderConfig _config;

		private readonly WayfinderPinManagementService _manager;

		private readonly RuntimeIconRegistry _icons;

		private Rect _windowRect = new Rect(80f, 70f, 820f, 720f);

		private Vector2 _pinScroll;

		private Vector2 _contentScroll;

		private string _search = string.Empty;

		private bool _favoritesOnly;

		private bool _portalsOnly;

		private string _selectedId = string.Empty;

		private WayfinderPinCategory _selectedCategory = WayfinderPinCategory.Unknown;

		private Vector3 _selectedPosition;

		private string _renameBuffer = string.Empty;

		private float _scaleBuffer = 1f;

		private string _newPinName = "New Wayfinder Pin";

		private WayfinderPinCategory _newPinCategory = WayfinderPinCategory.Custom;

		private string _deleteArmedId = string.Empty;

		private string _typeSearch = string.Empty;

		private string _iconSearch = string.Empty;

		private string _selectedIconKey = string.Empty;

		private string _selectedIconLabel = "Category default";

		private Vector2 _typeScroll;

		private Vector2 _iconScroll;

		private string _editIconSearch = string.Empty;

		private Vector2 _editIconScroll;

		private string _cachedEditIconQuery;

		private int _cachedEditIconRegistryCount = -1;

		private WayfinderPinCategory _cachedEditIconCategory = (WayfinderPinCategory)(-1);

		private List<WayfinderIconEntry> _cachedEditIconResults = new List<WayfinderIconEntry>();

		private string _cachedIconQuery;

		private int _cachedIconRegistryCount = -1;

		private WayfinderPinCategory _cachedIconCategory = (WayfinderPinCategory)(-1);

		private int _bossNameIndex;

		private string _bossNameBuffer = string.Empty;

		private string _trackingStatus = string.Empty;

		private List<WayfinderIconEntry> _cachedIconResults = new List<WayfinderIconEntry>();

		private float _openedFromMapGraceUntil;

		private float _ignoreUiMouseUntil;

		private bool _placeOnMapArmed;

		private bool _textInputFocused;

		private bool _textFieldHitThisMouseDown;

		private float _nextMapKeyDebugLogTime;

		private bool _mapPrimaryPointerDown;

		private Vector2 _mapPrimaryDownScreenPosition;

		private Rect _toolbarHitRect;

		private bool _toolbarHitRectValid;

		private Texture2D _jwButtonTexture;

		private Texture2D _createControlTexture;

		private Texture2D _pinsControlTexture;

		private Texture2D _visibilityControlTexture;

		private Texture2D _trackingControlTexture;

		private Texture2D _panelTexture;

		private Texture2D _buttonTexture;

		private Texture2D _buttonHoverTexture;

		private Texture2D _fieldTexture;

		private Texture2D _sectionTexture;

		private GUIStyle _windowStyle;

		private GUIStyle _buttonStyle;

		private GUIStyle _textFieldStyle;

		private GUIStyle _labelStyle;

		private GUIStyle _toggleStyle;

		private GUIStyle _sectionStyle;

		private GUIStyle _mapButtonStyle;

		private GUIStyle _titleStyle;

		private GUIStyle _subtitleStyle;

		private GUIStyle _toolbarButtonStyle;

		private string _toolbarTooltip = string.Empty;

		private float _toolbarTooltipY;

		private ManagerView _view;

		internal bool Visible { get; private set; }

		internal WayfinderPinManagerUI(ManualLogSource log, WayfinderConfig config, WayfinderPinManagementService manager, RuntimeIconRegistry icons)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			_log = log;
			_config = config;
			_manager = manager;
			_icons = icons;
		}

		internal void TickInput()
		{
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)Player.m_localPlayer == (Object)null || (Object)(object)Minimap.instance == (Object)null)
			{
				Visible = false;
				_textInputFocused = false;
				_placeOnMapArmed = false;
				ResetMapPrimaryGesture();
				_toolbarHitRectValid = false;
				return;
			}
			if (!IsLargeMapOpen())
			{
				if (!Visible || !(Time.unscaledTime < _openedFromMapGraceUntil))
				{
					Visible = false;
					_textInputFocused = false;
					_placeOnMapArmed = false;
					ResetMapPrimaryGesture();
					_toolbarHitRectValid = false;
				}
				return;
			}
			try
			{
				KeyboardShortcut value = _config.PinManagerToggleKey.Value;
				if (((KeyboardShortcut)(ref value)).IsDown())
				{
					if (Visible && _view == ManagerView.Full)
					{
						Visible = false;
						CancelMapPlacement();
					}
					else
					{
						OpenView(ManagerView.Full);
					}
				}
			}
			catch
			{
			}
		}

		internal void DrawMapButton()
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0118: 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_0119: Unknown result type (might be due to invalid IL or missing references)
			//IL_013f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0144: Unknown result type (might be due to invalid IL or missing references)
			//IL_0150: Unknown result type (might be due to invalid IL or missing references)
			//IL_0168: Unknown result type (might be due to invalid IL or missing references)
			//IL_019a: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0230: Unknown result type (might be due to invalid IL or missing references)
			//IL_029f: Unknown result type (might be due to invalid IL or missing references)
			//IL_028c: Unknown result type (might be due to invalid IL or missing references)
			if (!_config.ShowPinManagerMapButton.Value || !IsLargeMapOpen())
			{
				_toolbarHitRectValid = false;
				return;
			}
			EnsureTheme();
			float num = 44f;
			Rect rect = default(Rect);
			bool flag = WayfinderPlugin.Map != null && WayfinderPlugin.Map.TryGetPersistentPinPanelGuiRect(out rect);
			if (flag)
			{
				num = Mathf.Clamp(((Rect)(ref rect)).width - 18f, 36f, 46f);
			}
			float num2 = num * 5f + 16f;
			float num3;
			float num4;
			if (flag)
			{
				num3 = ((Rect)(ref rect)).x + (((Rect)(ref rect)).width - num) * 0.5f;
				num4 = ((Rect)(ref rect)).y + Mathf.Max(4f, (((Rect)(ref rect)).height - num2) * 0.5f);
			}
			else
			{
				num3 = Mathf.Max(12f, (float)Screen.width - num - 128f);
				num4 = Mathf.Max(70f, (float)Screen.height - num2 - 108f);
			}
			_toolbarHitRect = (Rect)(flag ? rect : new Rect(num3 - 4f, num4 - 4f, num + 8f, num2 + 8f));
			_toolbarHitRectValid = true;
			_toolbarTooltip = string.Empty;
			_toolbarTooltipY = num4;
			int depth = GUI.depth;
			Color color = GUI.color;
			GUI.depth = -700;
			GUI.color = Color.white;
			Rect rect2 = default(Rect);
			((Rect)(ref rect2))..ctor(num3, num4, num, num);
			if (DrawToolbarIconButton(rect2, _jwButtonTexture, ManagerView.Full, "Wayfinder"))
			{
				ToggleView(ManagerView.Full);
			}
			((Rect)(ref rect2)).y = ((Rect)(ref rect2)).y + (num + 4f);
			if (DrawToolbarIconButton(rect2, _createControlTexture, ManagerView.Create, "Add Pin"))
			{
				ToggleView(ManagerView.Create);
			}
			((Rect)(ref rect2)).y = ((Rect)(ref rect2)).y + (num + 4f);
			if (DrawToolbarIconButton(rect2, _pinsControlTexture, ManagerView.Pins, "Pins"))
			{
				ToggleView(ManagerView.Pins);
			}
			((Rect)(ref rect2)).y = ((Rect)(ref rect2)).y + (num + 4f);
			if (DrawToolbarIconButton(rect2, _visibilityControlTexture, ManagerView.Visibility, "Visibility"))
			{
				ToggleView(ManagerView.Visibility);
			}
			((Rect)(ref rect2)).y = ((Rect)(ref rect2)).y + (num + 4f);
			if (DrawToolbarIconButton(rect2, _trackingControlTexture, ManagerView.Tracking, "Track / Travel"))
			{
				ToggleView(ManagerView.Tracking);
			}
			if (!string.IsNullOrEmpty(_toolbarTooltip))
			{
				Rect val = default(Rect);
				((Rect)(ref val))..ctor(num3 - 128f - 8f, _toolbarTooltipY + (num - 28f) * 0.5f, 128f, 28f);
				GUI.Box(val, _toolbarTooltip, _sectionStyle);
			}
			GUI.color = color;
			GUI.depth = depth;
		}

		private bool DrawToolbarIconButton(Rect rect, Texture2D icon, ManagerView view, string tooltip)
		{
			//IL_0000: 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_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			bool result = GUI.Button(rect, GUIContent.none, _toolbarButtonStyle);
			if ((Object)(object)icon != (Object)null)
			{
				GUI.DrawTexture(new Rect(((Rect)(ref rect)).x + 7f, ((Rect)(ref rect)).y + 7f, ((Rect)(ref rect)).width - 14f, ((Rect)(ref rect)).height - 14f), (Texture)(object)icon, (ScaleMode)2, true);
			}
			if (Visible && _view == view)
			{
				DrawBronzeRect(rect, 2f);
			}
			Event current = Event.current;
			if (current != null && ((Rect)(ref rect)).Contains(current.mousePosition))
			{
				_toolbarTooltip = tooltip ?? string.Empty;
				_toolbarTooltipY = ((Rect)(ref rect)).y;
			}
			return result;
		}

		private void ToggleView(ManagerView view)
		{
			if (Visible && _view == view)
			{
				Visible = false;
				CancelMapPlacement();
			}
			else
			{
				OpenView(view);
			}
		}

		private void OpenView(ManagerView view)
		{
			if (view != ManagerView.Create)
			{
				CancelMapPlacement();
			}
			_view = view;
			Visible = true;
			_openedFromMapGraceUntil = Time.unscaledTime + 0.25f;
			_ignoreUiMouseUntil = Time.unscaledTime + 0.12f;
		}

		internal void Draw()
		{
			//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_00e6: 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_0107: Expected O, but got Unknown
			//IL_0102: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Unknown result type (might be due to invalid IL or missing references)
			if (Visible && IsLargeMapOpen())
			{
				EnsureTheme();
				Vector2 desiredWindowSize = GetDesiredWindowSize();
				float num = Mathf.Min(desiredWindowSize.x, Mathf.Max(520f, (float)Screen.width - 80f));
				float num2 = Mathf.Min(desiredWindowSize.y, Mathf.Max(380f, (float)Screen.height - 80f));
				((Rect)(ref _windowRect)).width = num;
				((Rect)(ref _windowRect)).height = num2;
				((Rect)(ref _windowRect)).x = Mathf.Clamp(((Rect)(ref _windowRect)).x, 0f, Mathf.Max(0f, (float)Screen.width - num));
				((Rect)(ref _windowRect)).y = Mathf.Clamp(((Rect)(ref _windowRect)).y, 0f, Mathf.Max(0f, (float)Screen.height - num2));
				_windowRect = GUI.Window(913701, _windowRect, new WindowFunction(DrawWindow), string.Empty, _windowStyle);
			}
		}

		private void DrawWindow(int windowId)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0199: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e7: Unknown result type (might be due to invalid IL or missing references)
			Event current = Event.current;
			if (current != null && (int)current.type == 0)
			{
				_textFieldHitThisMouseDown = false;
			}
			if (current != null && current.isMouse && Time.unscaledTime < _ignoreUiMouseUntil)
			{
				current.Use();
			}
			GUIStyle button = GUI.skin.button;
			GUIStyle label = GUI.skin.label;
			GUIStyle textField = GUI.skin.textField;
			GUIStyle toggle = GUI.skin.toggle;
			GUIStyle box = GUI.skin.box;
			GUI.skin.button = _buttonStyle;
			GUI.skin.label = _labelStyle;
			GUI.skin.textField = _textFieldStyle;
			GUI.skin.toggle = _toggleStyle;
			GUI.skin.box = _sectionStyle;
			try
			{
				DrawPanelBorder(new Rect(0f, 0f, ((Rect)(ref _windowRect)).width, ((Rect)(ref _windowRect)).height));
				GUILayout.BeginVertical((GUILayoutOption[])(object)new GUILayoutOption[0]);
				DrawManagerHeader();
				DrawHorizontalRule();
				if (_view == ManagerView.Pins || _view == ManagerView.Tracking || _view == ManagerView.Full)
				{
					DrawSearchBar();
					if (_view == ManagerView.Pins)
					{
						GUILayout.Label("Nearby discoveries stay easy to browse. Search a name to find remembered matches anywhere.", _subtitleStyle, (GUILayoutOption[])(object)new GUILayoutOption[0]);
					}
					else if (_view == ManagerView.Tracking)
					{
						GUILayout.Label("Tracked pins plus your remembered portals and vehicles.", _subtitleStyle, (GUILayoutOption[])(object)new GUILayoutOption[0]);
					}
					GUILayout.Space(5f);
				}
				float num = Mathf.Max(240f, ((Rect)(ref _windowRect)).height - ((_view == ManagerView.Full) ? 132f : 98f));
				_contentScroll = GUILayout.BeginScrollView(_contentScroll, false, true, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(num) });
				if (_view == ManagerView.Full)
				{
					DrawVisibilitySection();
					GUILayout.Space(6f);
					DrawBossSection();
					GUILayout.Space(6f);
					DrawCreateSection();
					GUILayout.Space(8f);
					DrawPinsEditorSection();
				}
				else if (_view == ManagerView.Create)
				{
					DrawCreateSection();
					GUILayout.Space(8f);
					GUILayout.BeginVertical(_sectionStyle, (GUILayoutOption[])(object)new GUILayoutOption[0]);
					GUILayout.Label("QUICK HELP", _subtitleStyle, (GUILayoutOption[])(object)new GUILayoutOption[0]);
					GUILayout.Label("Choose a type/icon, arm Place on Map, then click once outside this panel.", (GUILayoutOption[])(object)new GUILayoutOption[0]);
					GUILayout.Label("The full JW manager is still available from the medallion button.", (GUILayoutOption[])(object)new GUILayoutOption[0]);
					GUILayout.EndVertical();
				}
				else if (_view == ManagerView.Visibility)
				{
					DrawVisibilitySection();
				}
				else
				{
					DrawPinsEditorSection();
				}
				GUILayout.Space(12f);
				GUILayout.EndScrollView();
				GUILayout.EndVertical();
				RefreshTextInputFocusFromGui();
			}
			finally
			{
				GUI.skin.button = button;
				GUI.skin.label = label;
				GUI.skin.textField = textField;
				GUI.skin.toggle = toggle;
				GUI.skin.box = box;
			}
			GUI.DragWindow(new Rect(0f, 0f, 10000f, 42f));
		}

		private void DrawManagerHeader()
		{
			GUILayout.BeginHorizontal((GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(36f) });
			if ((Object)(object)_jwButtonTexture != (Object)null)
			{
				GUILayout.Label((Texture)(object)_jwButtonTexture, (GUILayoutOption[])(object)new GUILayoutOption[2]
				{
					GUILayout.Width(27f),
					GUILayout.Height(27f)
				});
			}
			GUILayout.BeginVertical((GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(260f) });
			GUILayout.Label("JOEY'S WAYFINDER", _titleStyle, (GUILayoutOption[])(object)new GUILayoutOption[0]);
			GUILayout.Label(GetViewTitle(), _subtitleStyle, (GUILayoutOption[])(object)new GUILayoutOption[0]);
			GUILayout.EndVertical();
			GUILayout.FlexibleSpace();
			if (_view != ManagerView.Full && GUILayout.Button("FULL", (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.Width(54f),
				GUILayout.Height(27f)
			}))
			{
				CancelMapPlacement();
				_view = ManagerView.Full;
			}
			if (GUILayout.Button("X", (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.Width(34f),
				GUILayout.Height(27f)
			}))
			{
				Visible = false;
				CancelMapPlacement();
			}
			GUILayout.EndHorizontal();
		}

		private void DrawSearchBar()
		{
			GUILayout.BeginHorizontal((GUILayoutOption[])(object)new GUILayoutOption[0]);
			GUILayout.Label((_view == ManagerView.Tracking) ? "Tracked" : "Search", _subtitleStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(52f) });
			_search = DrawNamedTextField("pin_search", _search ?? string.Empty, GUILayout.ExpandWidth(true));
			if (_view != ManagerView.Tracking)
			{
				_favoritesOnly = GUILayout.Toggle(_favoritesOnly, "Favorites", (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(92f) });
				_portalsOnly = GUILayout.Toggle(_portalsOnly, "Portals", (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(78f) });
			}
			GUILayout.EndHorizontal();
		}

		private void DrawVisibilitySection()
		{
			GUILayout.BeginVertical(_sectionStyle, (GUILayoutOption[])(object)new GUILayoutOption[0]);
			GUILayout.Label("VISIBILITY", _subtitleStyle, (GUILayoutOption[])(object)new GUILayoutOption[0]);
			DrawCategoryVisibility();
			GUILayout.EndVertical();
		}

		private void DrawBossSection()
		{
			GUILayout.BeginVertical(_sectionStyle, (GUILayoutOption[])(object)new GUILayoutOption[0]);
			GUILayout.Label("BOSS LABELS", _subtitleStyle, (GUILayoutOption[])(object)new GUILayoutOption[0]);
			DrawBossNamingControls();
			GUILayout.EndVertical();
		}

		private void DrawCreateSection()
		{
			GUILayout.BeginVertical(_sectionStyle, (GUILayoutOption[])(object)new GUILayoutOption[0]);
			GUILayout.Label("CREATE PIN", _subtitleStyle, (GUILayoutOption[])(object)new GUILayoutOption[0]);
			DrawPlacementPalette();
			GUILayout.EndVertical();
		}

		private void DrawPinsEditorSection()
		{
			GUILayout.BeginHorizontal((GUILayoutOption[])(object)new GUILayoutOption[0]);
			GUILayout.BeginVertical(_sectionStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width((_view == ManagerView.Full) ? 370f : 330f) });
			DrawPinList();
			GUILayout.EndVertical();
			GUILayout.Space(7f);
			GUILayout.BeginVertical(_sectionStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.ExpandWidth(true) });
			if (_view == ManagerView.Full)
			{
				DrawEditor();
			}
			else
			{
				DrawCompactEditor();
			}
			GUILayout.EndVertical();
			GUILayout.EndHorizontal();
		}

		private string GetViewTitle()
		{
			return _view switch
			{
				ManagerView.Create => "ADD PIN", 
				ManagerView.Pins => "PINS", 
				ManagerView.Visibility => "VISIBILITY", 
				ManagerView.Tracking => "TRACKED", 
				_ => "PIN MANAGER", 
			};
		}

		private Vector2 GetDesiredWindowSize()
		{
			//IL_002b: 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_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			return (Vector2)(_view switch
			{
				ManagerView.Create => new Vector2(680f, 540f), 
				ManagerView.Visibility => new Vector2(760f, 440f), 
				ManagerView.Pins => new Vector2(820f, 620f), 
				ManagerView.Tracking => new Vector2(760f, 560f), 
				_ => new Vector2(900f, 760f), 
			});
		}

		private void DrawCategoryVisibility()
		{
			Array values = Enum.GetValues(typeof(WayfinderPinCategory));
			int num = 4;
			for (int i = 0; i < values.Length; i += num)
			{
				GUILayout.BeginHorizontal((GUILayoutOption[])(object)new GUILayoutOption[0]);
				for (int j = 0; j < num && i + j < values.Length; j++)
				{
					WayfinderPinCategory category = (WayfinderPinCategory)values.GetValue(i + j);
					bool flag = _manager.IsCategoryVisible(category);
					string text = (flag ? "[ON] " : "[OFF] ") + FriendlyCategoryName(category);
					if (GUILayout.Button(text, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(170f) }))
					{
						_manager.SetCategoryVisible(category, !flag);
						ForceMapRefresh();
					}
				}
				GUILayout.EndHorizontal();
			}
		}

		private void DrawPinList()
		{
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: 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_020c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0211: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02fd: Unknown result type (might be due to invalid IL or missing references)
			GUILayout.BeginVertical((GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(350f) });
			List<WayfinderPinRecord> list = _manager.Search(_search, _favoritesOnly, _portalsOnly ? new WayfinderPinCategory?(WayfinderPinCategory.Portal) : ((WayfinderPinCategory?)null), 0);
			bool flag = !string.IsNullOrEmpty((_search ?? string.Empty).Trim());
			Vector3 playerPosition = (((Object)(object)Player.m_localPlayer == (Object)null) ? Vector3.zero : ((Component)Player.m_localPlayer).transform.position);
			bool flag2 = (Object)(object)Player.m_localPlayer != (Object)null;
			if (_view == ManagerView.Tracking)
			{
				list.RemoveAll((WayfinderPinRecord record) => record == null || (!record.tracked && record.category != WayfinderPinCategory.Vehicle && record.category != WayfinderPinCategory.Portal));
			}
			else if (_view == ManagerView.Pins && !flag && flag2)
			{
				float num = Mathf.Max(25f, _config.NearbyDiscoveryListRadius.Value);
				float radiusSq = num * num;
				list.RemoveAll(delegate(WayfinderPinRecord record)
				{
					//IL_000e: Unknown result type (might be due to invalid IL or missing references)
					//IL_002b: Unknown result type (might be due to invalid IL or missing references)
					if (record == null || !IsDenseDiscoveryListCategory(record))
					{
						return false;
					}
					float num4 = record.Position.x - playerPosition.x;
					float num5 = record.Position.z - playerPosition.z;
					return num4 * num4 + num5 * num5 > radiusSq;
				});
			}
			if (flag2)
			{
				list.Sort(delegate(WayfinderPinRecord a, WayfinderPinRecord b)
				{
					//IL_0035: Unknown result type (might be due to invalid IL or missing references)
					//IL_0042: Unknown result type (might be due to invalid IL or missing references)
					if (_view == ManagerView.Tracking)
					{
						bool flag3 = a?.tracked ?? false;
						bool flag4 = b?.tracked ?? false;
						if (flag3 != flag4)
						{
							if (!flag3)
							{
								return 1;
							}
							return -1;
						}
					}
					float num4 = HorizontalDistanceSq(a, playerPosition);
					float value = HorizontalDistanceSq(b, playerPosition);
					int num5 = num4.CompareTo(value);
					return (num5 != 0) ? num5 : string.Compare((a == null) ? string.Empty : a.displayName, (b == null) ? string.Empty : b.displayName, StringComparison.OrdinalIgnoreCase);
				});
			}
			int num2 = Mathf.Min(120, list.Count);
			GUILayout.Label(((_view == ManagerView.Tracking) ? "Travel / Track (" : "Pins (") + num2 + ((list.Count > num2) ? "+" : "") + ")", (GUILayoutOption[])(object)new GUILayoutOption[0]);
			if (_view == ManagerView.Pins && !flag)
			{
				GUILayout.Label("Resources, sightings and habitats: nearby only in this list.", _subtitleStyle, (GUILayoutOption[])(object)new GUILayoutOption[0]);
			}
			_pinScroll = GUILayout.BeginScrollView(_pinScroll, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(260f) });
			for (int num3 = 0; num3 < list.Count && num3 < 120; num3++)
			{
				WayfinderPinRecord wayfinderPinRecord = list[num3];
				if (wayfinderPinRecord != null)
				{
					string text = (string.IsNullOrEmpty(wayfinderPinRecord.displayName) ? wayfinderPinRecord.subtype : wayfinderPinRecord.displayName);
					string text2 = ((wayfinderPinRecord.tracked && wayfinderPinRecord.trackSlot >= 0) ? ("T" + (wayfinderPinRecord.trackSlot + 1) + " • ") : string.Empty);
					string text3 = string.Empty;
					if (WayfinderDynamicState.IsDynamicVehicle(wayfinderPinRecord))
					{
						text3 = (wayfinderPinRecord.dynamicLive ? "LIVE • " : "LAST • ");
					}
					else if (wayfinderPinRecord.category == WayfinderPinCategory.Portal && wayfinderPinRecord.portalLive && wayfinderPinRecord.portalConnectionKnown)
					{
						text3 = (wayfinderPinRecord.portalConnected ? "LINK • " : "OPEN • ");
					}
					string text4 = (flag2 ? ("  •  " + FormatRelativeLocation(playerPosition, wayfinderPinRecord.Position)) : string.Empty);
					string text5 = text2 + text3 + (wayfinderPinRecord.favorite ? "★ " : string.Empty) + text + "  [" + FriendlyCategoryName(wayfinderPinRecord.category) + "]" + text4;
					if (wayfinderPinRecord.count > 1)
					{
						text5 = text5 + " x" + wayfinderPinRecord.count;
					}
					if (!_manager.IsCategoryVisible(wayfinderPinRecord.category))
					{
						text5 += "  (map hidden)";
					}
					if (GUILayout.Button(text5, (GUILayoutOption[])(object)new GUILayoutOption[0]))
					{
						Select(wayfinderPinRecord);
					}
				}
			}
			GUILayout.EndScrollView();
			GUILayout.EndVertical();
		}

		private static bool IsDenseDiscoveryListCategory(WayfinderPinRecord record)
		{
			if (record == null || record.source == WayfinderPinSource.Manual || record.source == WayfinderPinSource.Imported)
			{
				return false;
			}
			if (record.category != WayfinderPinCategory.Resource && record.category != WayfinderPinCategory.Sighting)
			{
				return record.category == WayfinderPinCategory.Habitat;
			}
			return true;
		}

		private static float HorizontalDistanceSq(WayfinderPinRecord record, Vector3 position)
		{
			//IL_000a: 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)
			if (record == null)
			{
				return float.MaxValue;
			}
			float num = record.Position.x - position.x;
			float num2 = record.Position.z - position.z;
			return num * num + num2 * num2;
		}

		private static string FormatRelativeLocation(Vector3 from, Vector3 to)
		{
			float num = to.x - from.x;
			float num2 = to.z - from.z;
			float num3 = Mathf.Sqrt(num * num + num2 * num2);
			string text = CardinalDirection(num, num2);
			return num3.ToString("0") + "m " + text;
		}

		private static string CardinalDirection(float dx, float dz)
		{
			if (Mathf.Abs(dx) < 0.001f && Mathf.Abs(dz) < 0.001f)
			{
				return "HERE";
			}
			float num = Mathf.Atan2(dx, dz) * 57.29578f;
			if (num < 0f)
			{
				num += 360f;
			}
			string[] array = new string[8] { "N", "NE", "E", "SE", "S", "SW", "W", "NW" };
			int num2 = Mathf.RoundToInt(num / 45f) % 8;
			return array[num2];
		}

		private void DrawCompactEditor()
		{
			//IL_049d: Unknown result type (might be due to invalid IL or missing references)
			//IL_04d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_050b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0542: Unknown result type (might be due to invalid IL or missing references)
			//IL_0579: Unknown result type (might be due to invalid IL or missing references)
			GUILayout.BeginVertical((GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.ExpandWidth(true) });
			WayfinderPinRecord wayfinderPinRecord = _manager.Find(_selectedId);
			if (wayfinderPinRecord == null && !string.IsNullOrEmpty(_selectedId))
			{
				wayfinderPinRecord = RecoverSelectedRecord();
				if (wayfinderPinRecord != null)
				{
					Select(wayfinderPinRecord);
				}
			}
			if (wayfinderPinRecord == null)
			{
				GUILayout.Label((_view == ManagerView.Tracking) ? "Select a tracked pin, portal, or vehicle." : "Select a pin.", (GUILayoutOption[])(object)new GUILayoutOption[0]);
				GUILayout.Space(8f);
				GUILayout.Label("The JW button opens the full advanced manager.", _subtitleStyle, (GUILayoutOption[])(object)new GUILayoutOption[0]);
				GUILayout.EndVertical();
				return;
			}
			string text = (string.IsNullOrEmpty(wayfinderPinRecord.displayName) ? wayfinderPinRecord.subtype : wayfinderPinRecord.displayName);
			GUILayout.Label(text, _titleStyle, (GUILayoutOption[])(object)new GUILayoutOption[0]);
			GUILayout.Label(FriendlyCategoryName(wayfinderPinRecord.category), _subtitleStyle, (GUILayoutOption[])(object)new GUILayoutOption[0]);
			if (WayfinderDynamicState.IsDynamicVehicle(wayfinderPinRecord))
			{
				GUILayout.Label(wayfinderPinRecord.dynamicLive ? "Vehicle • Live" : ("Vehicle • Last known " + WayfinderDynamicState.FormatLastSeen(wayfinderPinRecord)), (GUILayoutOption[])(object)new GUILayoutOption[0]);
				GUILayout.Label("Label source: " + (wayfinderPinRecord.vehicleNameOverride ? "Custom Wayfinder label" : "Vehicle type"), (GUILayoutOption[])(object)new GUILayoutOption[0]);
			}
			if (wayfinderPinRecord.category == WayfinderPinCategory.Portal)
			{
				GUILayout.Label("Portal tag: " + WayfinderPortalState.GetTagLabel(wayfinderPinRecord), (GUILayoutOption[])(object)new GUILayoutOption[0]);
				GUILayout.Label("Connection: " + WayfinderPortalState.GetConnectionLabel(wayfinderPinRecord), (GUILayoutOption[])(object)new GUILayoutOption[0]);
				GUILayout.Label(wayfinderPinRecord.portalNameOverride ? "Wayfinder label override; Valheim portal tag is unchanged." : "Wayfinder label follows the Valheim portal tag.", (GUILayoutOption[])(object)new GUILayoutOption[0]);
			}
			GUILayout.Space(6f);
			GUILayout.BeginHorizontal((GUILayoutOption[])(object)new GUILayoutOption[0]);
			GUILayout.Label("Label", (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(45f) });
			_renameBuffer = DrawNamedTextField("rename_compact", _renameBuffer ?? string.Empty, GUILayout.ExpandWidth(true));
			if (GUILayout.Button("Apply", (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(62f) }))
			{
				_manager.Rename(wayfinderPinRecord.id, _renameBuffer);
				ForceMapRefresh();
			}
			GUILayout.EndHorizontal();
			if (wayfinderPinRecord.category == WayfinderPinCategory.Portal && wayfinderPinRecord.portalNameOverride)
			{
				if (GUILayout.Button("Use Portal Tag as Label", (GUILayoutOption[])(object)new GUILayoutOption[0]))
				{
					_manager.UsePortalTagName(wayfinderPinRecord.id);
					WayfinderPinRecord wayfinderPinRecord2 = _manager.Find(wayfinderPinRecord.id);
					_renameBuffer = ((wayfinderPinRecord2 == null) ? string.Empty : wayfinderPinRecord2.displayName);
					ForceMapRefresh();
				}
			}
			else if (WayfinderDynamicState.IsDynamicVehicle(wayfinderPinRecord) && wayfinderPinRecord.vehicleNameOverride && GUILayout.Button("Use Vehicle Type as Label", (GUILayoutOption[])(object)new GUILayoutOption[0]))
			{
				_manager.UseVehicleTypeName(wayfinderPinRecord.id);
				WayfinderPinRecord wayfinderPinRecord3 = _manager.Find(wayfinderPinRecord.id);
				_renameBuffer = ((wayfinderPinRecord3 == null) ? string.Empty : wayfinderPinRecord3.displayName);
				ForceMapRefresh();
			}
			GUILayout.Space(5f);
			GUILayout.BeginHorizontal((GUILayoutOption[])(object)new GUILayoutOption[0]);
			if (GUILayout.Button(wayfinderPinRecord.favorite ? "★ Favorite" : "☆ Favorite", (GUILayoutOption[])(object)new GUILayoutOption[0]))
			{
				_manager.SetFavorite(wayfinderPinRecord.id, !wayfinderPinRecord.favorite);
				ForceMapRefresh();
			}
			if (GUILayout.Button(wayfinderPinRecord.tracked ? "Stop Tracking" : "Track", (GUILayoutOption[])(object)new GUILayoutOption[0]))
			{
				bool tracked = wayfinderPinRecord.tracked;
				bool flag = _manager.SetTracked(wayfinderPinRecord.id, !tracked);
				_trackingStatus = ((!flag) ? "All tracking slots are in use." : (tracked ? "Tracking stopped." : ("Tracking as T" + (wayfinderPinRecord.trackSlot + 1) + ".")));
				if (WayfinderPlugin.Map != null)
				{
					WayfinderPlugin.Map.RefreshTrackedOverlays();
				}
			}
			GUILayout.EndHorizontal();
			if (!string.IsNullOrEmpty(_trackingStatus))
			{
				GUILayout.Label(_trackingStatus, _subtitleStyle, (GUILayoutOption[])(object)new GUILayoutOption[0]);
			}
			if (!HasInGameIcon(wayfinderPinRecord))
			{
				GUILayout.Space(5f);
				GUILayout.Label("Color", _subtitleStyle, (GUILayoutOption[])(object)new GUILayoutOption[0]);
				GUILayout.BeginHorizontal((GUILayoutOption[])(object)new GUILayoutOption[0]);
				if (GUILayout.Button("Default", (GUILayoutOption[])(object)new GUILayoutOption[0]))
				{
					ResetColorToDefault(wayfinderPinRecord.id);
				}
				if (GUILayout.Button("Red", (GUILayoutOption[])(object)new GUILayoutOption[0]))
				{
					ApplyColor(wayfinderPinRecord.id, new Color(0.95f, 0.28f, 0.25f, 1f));
				}
				if (GUILayout.Button("Gold", (GUILayoutOption[])(object)new GUILayoutOption[0]))
				{
					ApplyColor(wayfinderPinRecord.id, new Color(0.95f, 0.72f, 0.22f, 1f));
				}
				if (GUILayout.Button("Green", (GUILayoutOption[])(object)new GUILayoutOption[0]))
				{
					ApplyColor(wayfinderPinRecord.id, new Color(0.35f, 0.78f, 0.38f, 1f));
				}
				if (GUILayout.Button("Blue", (GUILayoutOption[])(object)new GUILayoutOption[0]))
				{
					ApplyColor(wayfinderPinRecord.id, new Color(0.3f, 0.62f, 0.95f, 1f));
				}
				if (GUILayout.Button("Purple", (GUILayoutOption[])(object)new GUILayoutOption[0]))
				{
					ApplyColor(wayfinderPinRecord.id, new Color(0.68f, 0.42f, 0.92f, 1f));
				}
				GUILayout.EndHorizontal();
			}
			GUILayout.Space(8f);
			if (GUILayout.Button("Advanced…", (GUILayoutOption[])(object)new GUILayoutOption[0]))
			{
				_view = ManagerView.Full;
			}
			GUILayout.EndVertical();
		}

		private void DrawEditor()
		{
			//IL_02e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_02fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0307: Unknown result type (might be due to invalid IL or missing references)
			//IL_08a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_08df: Unknown result type (might be due to invalid IL or missing references)
			//IL_0916: Unknown result type (might be due to invalid IL or missing references)
			//IL_094d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0984: Unknown result type (might be due to invalid IL or missing references)
			GUILayout.BeginVertical((GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.ExpandWidth(true) });
			WayfinderPinRecord wayfinderPinRecord = _manager.Find(_selectedId);
			if (wayfinderPinRecord == null && !string.IsNullOrEmpty(_selectedId))
			{
				wayfinderPinRecord = RecoverSelectedRecord();
				if (wayfinderPinRecord != null)
				{
					Select(wayfinderPinRecord);
				}
			}
			if (wayfinderPinRecord == null)
			{
				GUILayout.Label("Select a Wayfinder pin to edit it.", (GUILayoutOption[])(object)new GUILayoutOption[0]);
				GUILayout.Space(8f);
				GUILayout.Label("Choose a pin from the list or double-click a Wayfinder marker on the map.", (GUILayoutOption[])(object)new GUILayoutOption[0]);
				GUILayout.EndVertical();
				return;
			}
			GUILayout.Label("Edit selected pin", (GUILayoutOption[])(object)new GUILayoutOption[0]);
			GUILayout.Label(string.Concat("Category: ", wayfinderPinRecord.category, "   Source: ", wayfinderPinRecord.source), (GUILayoutOption[])(object)new GUILayoutOption[0]);
			if (WayfinderDynamicState.IsDynamicVehicle(wayfinderPinRecord))
			{
				string text = (wayfinderPinRecord.dynamicLive ? "LIVE" : "LAST KNOWN");
				GUILayout.Label("Vehicle status: " + text + "   |   Last seen: " + WayfinderDynamicState.FormatLastSeen(wayfinderPinRecord), (GUILayoutOption[])(object)new GUILayoutOption[0]);
			}
			if (wayfinderPinRecord.category == WayfinderPinCategory.Portal)
			{
				GUILayout.Label("Portal tag: " + WayfinderPortalState.GetTagLabel(wayfinderPinRecord), (GUILayoutOption[])(object)new GUILayoutOption[0]);
				GUILayout.Label("Connection: " + WayfinderPortalState.GetConnectionLabel(wayfinderPinRecord), (GUILayoutOption[])(object)new GUILayoutOption[0]);
				GUILayout.Label("Wayfinder label source: " + (wayfinderPinRecord.portalNameOverride ? "Custom Wayfinder label" : "Portal tag sync"), (GUILayoutOption[])(object)new GUILayoutOption[0]);
				GUILayout.Label("Changing this Wayfinder label does not change the Valheim portal tag or connection.", (GUILayoutOption[])(object)new GUILayoutOption[0]);
				GUILayout.BeginHorizontal((GUILayoutOption[])(object)new GUILayoutOption[0]);
				GUILayout.Label("Label", (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(70f) });
				_renameBuffer = DrawNamedTextField("rename_full_portal", _renameBuffer ?? string.Empty, GUILayout.ExpandWidth(true));
				if (GUILayout.Button("Apply", (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(62f) }))
				{
					_manager.Rename(wayfinderPinRecord.id, _renameBuffer);
					ForceMapRefresh();
				}
				GUILayout.EndHorizontal();
				if (wayfinderPinRecord.portalNameOverride && GUILayout.Button("Use Portal Tag as Label", (GUILayoutOption[])(object)new GUILayoutOption[0]))
				{
					_manager.UsePortalTagName(wayfinderPinRecord.id);
					WayfinderPinRecord wayfinderPinRecord2 = _manager.Find(wayfinderPinRecord.id);
					_renameBuffer = ((wayfinderPinRecord2 == null) ? string.Empty : wayfinderPinRecord2.displayName);
					ForceMapRefresh();
				}
				int num = _manager.CountOtherPortalsWithTag(wayfinderPinRecord);
				if (!string.IsNullOrEmpty(wayfinderPinRecord.portalTag))
				{
					GUILayout.Label("Other remembered portals with this tag: " + num, (GUILayoutOption[])(object)new GUILayoutOption[0]);
					WayfinderPinRecord wayfinderPinRecord3 = _manager.FindNearestPortalTagPartner(wayfinderPinRecord);
					if (wayfinderPinRecord3 != null)
					{
						float num2 = wayfinderPinRecord3.Position.x - wayfinderPinRecord.Position.x;
						float num3 = wayfinderPinRecord3.Position.z - wayfinderPinRecord.Position.z;
						float num4 = Mathf.Sqrt(num2 * num2 + num3 * num3);
						string text2 = (string.IsNullOrEmpty(wayfinderPinRecord3.displayName) ? "Portal" : wayfinderPinRecord3.displayName);
						GUILayout.Label("Nearest same-tag portal: " + text2 + " (" + num4.ToString("0") + "m)", (GUILayoutOption[])(object)new GUILayoutOption[0]);
					}
				}
			}
			if (WayfinderDynamicState.IsDynamicVehicle(wayfinderPinRecord))
			{
				GUILayout.Label("Wayfinder label source: " + (wayfinderPinRecord.vehicleNameOverride ? "Custom label tied to this vehicle" : "Automatic vehicle type"), (GUILayoutOption[])(object)new GUILayoutOption[0]);
				GUILayout.Label("Vehicle identity is tied to its stable world object, so movement does not replace a custom label.", (GUILayoutOption[])(object)new GUILayoutOption[0]);
				GUILayout.BeginHorizontal((GUILayoutOption[])(object)new GUILayoutOption[0]);
				GUILayout.Label("Label", (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(70f) });
				_renameBuffer = DrawNamedTextField("rename_full_vehicle", _renameBuffer ?? string.Empty, GUILayout.ExpandWidth(true));
				if (GUILayout.Button("Apply", (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(62f) }))
				{
					_manager.Rename(wayfinderPinRecord.id, _renameBuffer);
					ForceMapRefresh();
				}
				GUILayout.EndHorizontal();
				if (wayfinderPinRecord.vehicleNameOverride && GUILayout.Button("Use Vehicle Type as Label", (GUILayoutOption[])(object)new GUILayoutOption[0]))
				{
					_manager.UseVehicleTypeName(wayfinderPinRecord.id);
					WayfinderPinRecord wayfinderPinRecord4 = _manager.Find(wayfinderPinRecord.id);
					_renameBuffer = ((wayfinderPinRecord4 == null) ? string.Empty : wayfinderPinRecord4.displayName);
					ForceMapRefresh();
				}
			}
			if (wayfinderPinRecord.category != WayfinderPinCategory.Portal && !WayfinderDynamicState.IsDynamicVehicle(wayfinderPinRecord))
			{
				GUILayout.BeginHorizontal((GUILayoutOption[])(object)new GUILayoutOption[0]);
				_renameBuffer = DrawNamedTextField("rename_full", _renameBuffer ?? string.Empty, GUILayout.ExpandWidth(true));
				if (GUILayout.Button("Rename", (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(80f) }))
				{
					_manager.Rename(wayfinderPinRecord.id, _renameBuffer);
					ForceMapRefresh();
				}
				GUILayout.EndHorizontal();
			}
			if (GUILayout.Button(wayfinderPinRecord.favorite ? "Remove Favorite" : "Favorite", (GUILayoutOption[])(object)new GUILayoutOption[0]))
			{
				_manager.SetFavorite(wayfinderPinRecord.id, !wayfinderPinRecord.favorite);
				ForceMapRefresh();
			}
			GUILayout.BeginHorizontal((GUILayoutOption[])(object)new GUILayoutOption[0]);
			GUILayout.Label("Tracked: " + _manager.TrackedCount + "/" + _manager.MaxTrackedPins, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(110f) });
			if (GUILayout.Button(wayfinderPinRecord.tracked ? "Stop Tracking" : "Track Pin", (GUILayoutOption[])(object)new GUILayoutOption[0]))
			{
				bool tracked = wayfinderPinRecord.tracked;
				bool flag = _manager.SetTracked(wayfinderPinRecord.id, !tracked);
				_trackingStatus = ((!flag) ? ("Tracking limit reached (" + _manager.MaxTrackedPins + ").") : (tracked ? "Tracking stopped." : ("Tracking slot " + (wayfinderPinRecord.trackSlot + 1) + " — " + TrackedColorPalette.GetName(wayfinderPinRecord.trackSlot) + ".")));
				if (WayfinderPlugin.Map != null)
				{
					WayfinderPlugin.Map.RefreshTrackedOverlays();
				}
			}
			GUILayout.EndHorizontal();
			if (!string.IsNullOrEmpty(_trackingStatus))
			{
				GUILayout.Label(_trackingStatus, (GUILayoutOption[])(object)new GUILayoutOption[0]);
			}
			GUILayout.BeginHorizontal((GUILayoutOption[])(object)new GUILayoutOption[0]);
			if (GUILayout.Button("< Category", (GUILayoutOption[])(object)new GUILayoutOption[0]))
			{
				WayfinderPinCategory category = PreviousCategory(wayfinderPinRecord.category);
				_manager.SetCategory(wayfinderPinRecord.id, category);
				ForceMapRefresh();
			}
			if (GUILayout.Button("Category >", (GUILayoutOption[])(object)new GUILayoutOption[0]))
			{
				WayfinderPinCategory category2 = NextCategory(wayfinderPinRecord.category);
				_manager.SetCategory(wayfinderPinRecord.id, category2);
				ForceMapRefresh();
			}
			GUILayout.EndHorizontal();
			GUILayout.Space(7f);
			DrawExistingPinIconPicker(wayfinderPinRecord);
			if (!HasInGameIcon(wayfinderPinRecord))
			{
				GUILayout.Label("Custom/fallback pin styling", (GUILayoutOption[])(object)new GUILayoutOption[0]);
				GUILayout.Label("Scale: " + _scaleBuffer.ToString("0.00"), (GUILayoutOption[])(object)new GUILayoutOption[0]);
				_scaleBuffer = GUILayout.HorizontalSlider(_scaleBuffer, 0.5f, 2.5f, (GUILayoutOption[])(object)new GUILayoutOption[0]);
				if (GUILayout.Button("Apply Scale", (GUILayoutOption[])(object)new GUILayoutOption[0]))
				{
					_manager.SetScale(wayfinderPinRecord.id, _scaleBuffer);
					ForceMapRefresh();
				}
				GUILayout.Label("Color presets", (GUILayoutOption[])(object)new GUILayoutOption[0]);
				GUILayout.BeginHorizontal((GUILayoutOption[])(object)new GUILayoutOption[0]);
				if (GUILayout.Button("Default", (GUILayoutOption[])(object)new GUILayoutOption[0]))
				{
					ResetColorToDefault(wayfinderPinRecord.id);
				}
				if (GUILayout.Button("Red", (GUILayoutOption[])(object)new GUILayoutOption[0]))
				{
					ApplyColor(wayfinderPinRecord.id, new Color(0.95f, 0.28f, 0.25f, 1f));
				}
				if (GUILayout.Button("Gold", (GUILayoutOption[])(object)new GUILayoutOption[0]))
				{
					ApplyColor(wayfinderPinRecord.id, new Color(0.95f, 0.72f, 0.22f, 1f));
				}
				if (GUILayout.Button("Green", (GUILayoutOption[])(object)new GUILayoutOption[0]))
				{
					ApplyColor(wayfinderPinRecord.id, new Color(0.35f, 0.78f, 0.38f, 1f));
				}
				if (GUILayout.Button("Blue", (GUILayoutOption[])(object)new GUILayoutOption[0]))
				{
					ApplyColor(wayfinderPinRecord.id, new Color(0.3f, 0.62f, 0.95f, 1f));
				}
				if (GUILayout.Button("Purple", (GUILayoutOption[])(object)new GUILayoutOption[0]))
				{
					ApplyColor(wayfinderPinRecord.id, new Color(0.68f, 0.42f, 0.92f, 1f));
				}
				GUILayout.EndHorizontal();
				GUILayout.Label("Default = original Wayfinder pin art / no tint.", (GUILayoutOption[])(object)new GUILayoutOption[0]);
			}
			else
			{
				GUILayout.Label("Using an in-game icon: size/color are kept at the icon's normal presentation.", (GUILayoutOption[])(object)new GUILayoutOption[0]);
			}
			GUILayout.Space(8f);
			if (_deleteArmedId == wayfinderPinRecord.id)
			{
				GUILayout.BeginHorizontal((GUILayoutOption[])(object)new GUILayoutOption[0]);
				GUILayout.Label("Delete this pin?", (GUILayoutOption[])(object)new GUILayoutOption[0]);
				if (GUILayout.Button("YES", (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(70f) }))
				{
					_manager.Delete(wayfinderPinRecord.id);
					_selectedId = string.Empty;
					_deleteArmedId = string.Empty;
					ForceMapRefresh();
				}
				if (GUILayout.Button("Cancel", (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(70f) }))
				{
					_deleteArmedId = string.Empty;
				}
				GUILayout.EndHorizontal();
			}
			else if (GUILayout.Button("Delete Pin", (GUILayoutOption[])(object)new GUILayoutOption[0]))
			{
				_deleteArmedId = wayfinderPinRecord.id;
			}
			GUILayout.EndVertical();
		}

		private void DrawExistingPinIconPicker(WayfinderPinRecord selected)
		{
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			if (selected != null)
			{
				GUILayout.BeginVertical(_sectionStyle, (GUILayoutOption[])(object)new GUILayoutOption[0]);
				GUILayout.Label("ICON", _subtitleStyle, (GUILayoutOption[])(object)new GUILayoutOption[0]);
				_editIconSearch = DrawNamedTextField("edit_icon_search", _editIconSearch ?? string.Empty);
				RefreshEditIconSearch(selected.category);
				GUILayout.BeginHorizontal((GUILayoutOption[])(object)new GUILayoutOption[0]);
				GUILayout.Label(GetExistingPinIconSelectionLabel(selected), _subtitleStyle, (GUILayoutOption[])(object)new GUILayoutOption[0]);
				GUILayout.FlexibleSpace();
				GUI.enabled = selected.iconOverride;
				if (GUILayout.Button("Default", (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(90f) }) && _manager.ResetIconToDefault(selected.id))
				{
					ForceMapRefresh();
				}
				GUI.enabled = true;
				GUILayout.EndHorizontal();
				_editIconScroll = GUILayout.BeginScrollView(_editIconScroll, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(155f) });
				DrawEditIconPickerGrid(selected);
				GUILayout.EndScrollView();
				if (!string.IsNullOrEmpty(GUI.tooltip))
				{
					GUILayout.Label(GUI.tooltip, _subtitleStyle, (GUILayoutOption[])(object)new GUILayoutOption[0]);
				}
				else
				{
					GUILayout.Label(GetExistingPinIconSelectionLabel(selected), _subtitleStyle, (GUILayoutOption[])(object)new GUILayoutOption[0]);
				}
				GUILayout.EndVertical();
			}
		}

		private void RefreshEditIconSearch(WayfinderPinCategory category)
		{
			if (_icons == null || !_icons.IsBuilt)
			{
				_cachedEditIconResults.Clear();
				return;
			}
			int num = ((_icons.All != null) ? _icons.All.Count : 0);
			string text = _editIconSearch ?? string.Empty;
			if (!string.Equals(text, _cachedEditIconQuery, StringComparison.Ordinal) || num != _cachedEditIconRegistryCount || _cachedEditIconCategory != category)
			{
				_cachedEditIconQuery = text;
				_cachedEditIconRegistryCount = num;
				_cachedEditIconCategory = category;
				_cachedEditIconResults = _icons.Search(text, category, 48);
			}
		}

		private void DrawEditIconPickerGrid(WayfinderPinRecord selected)
		{
			int num = -1;
			string displayedIconKey = GetDisplayedIconKey(selected);
			bool flag = !selected.iconOverride;
			Sprite sprite = ResolveExistingPinDefaultPreviewSprite(selected);
			GUILayout.BeginHorizontal((GUILayoutOption[])(object)new GUILayoutOption[0]);
			if (DrawIconButton(sprite, flag, "Default") && _manager.ResetIconToDefault(selected.id))
			{
				ForceMapRefresh();
			}
			num++;
			for (int i = 0; i < _cachedEditIconResults.Count; i++)
			{
				WayfinderIconEntry wayfinderIconEntry = _cachedEditIconResults[i];
				if (wayfinderIconEntry != null)
				{
					if (num > 0 && num % 8 == 0)
					{
						GUILayout.EndHorizontal();
						GUILayout.BeginHorizontal((GUILayoutOption[])(object)new GUILayoutOption[0]);
					}
					string iconDisplayName = GetIconDisplayName(wayfinderIconEntry);
					bool selected2 = !flag && string.Equals(displayedIconKey, wayfinderIconEntry.Key, StringComparison.OrdinalIgnoreCase);
					if (DrawIconButton(wayfinderIconEntry.Sprite, selected2, iconDisplayName) && _manager.SetIcon(selected.id, wayfinderIconEntry.Key))
					{
						ForceMapRefresh();
					}
					num++;
				}
			}
			GUILayout.FlexibleSpace();
			GUILayout.EndHorizontal();
		}

		private Sprite ResolveExistingPinDefaultPreviewSprite(WayfinderPinRecord record)
		{
			if (record == null || _icons == null)
			{
				return null;
			}
			string defaultIconKey = WayfinderIconPolicy.GetDefaultIconKey(record);
			if (!string.IsNullOrEmpty(defaultIconKey) && _icons.TryGet(defaultIconKey, out var sprite))
			{
				return sprite;
			}
			return ResolveCategoryDefaultPreviewSprite(record.category);
		}

		private string GetExistingPinIconSelectionLabel(WayfinderPinRecord record)
		{
			if (record == null)
			{
				return "Selected: Default";
			}
			bool flag = !record.iconOverride;
			string displayedIconKey = GetDisplayedIconKey(record);
			WayfinderIconEntry wayfinderIconEntry = FindIconEntry(displayedIconKey);
			string text = ((wayfinderIconEntry != null) ? GetIconDisplayName(wayfinderIconEntry) : (string.IsNullOrEmpty(displayedIconKey) ? "Default" : displayedIconKey));
			if (!flag)
			{
				return "Selected: " + text;
			}
			return "Default: " + text;
		}

		private static string GetDisplayedIconKey(WayfinderPinRecord record)
		{
			if (record != null)
			{
				return WayfinderIconPolicy.GetEffectiveIconKey(record);
			}
			return string.Empty;
		}

		private void DrawPlacementPalette()
		{
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ed: Unknown result type (might be due to invalid IL or missing references)
			GUILayout.Label("Choose what you want to mark.", (GUILayoutOption[])(object)new GUILayoutOption[0]);
			GUILayout.BeginHorizontal((GUILayoutOption[])(object)new GUILayoutOption[0]);
			GUILayout.BeginVertical((GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(215f) });
			GUILayout.Label("Type", _subtitleStyle, (GUILayoutOption[])(object)new GUILayoutOption[0]);
			_typeSearch = DrawNamedTextField("type_search", _typeSearch ?? string.Empty);
			_typeScroll = GUILayout.BeginScrollView(_typeScroll, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(145f) });
			Array values = Enum.GetValues(typeof(WayfinderPinCategory));
			string value = (_typeSearch ?? string.Empty).Trim().ToLowerInvariant();
			for (int i = 0; i < values.Length; i++)
			{
				WayfinderPinCategory wayfinderPinCategory = (WayfinderPinCategory)values.GetValue(i);
				string text = FriendlyCategoryName(wayfinderPinCategory);
				if (string.IsNullOrEmpty(value) || text.ToLowerInvariant().IndexOf(value, StringComparison.Ordinal) >= 0 || wayfinderPinCategory.ToString().ToLowerInvariant().IndexOf(value, StringComparison.Ordinal) >= 0)
				{
					string text2 = ((wayfinderPinCategory == _newPinCategory) ? "• " : string.Empty);
					if (GUILayout.Button(text2 + text, (GUILayoutOption[])(object)new GUILayoutOption[0]))
					{
						SelectNewPinCategory(wayfinderPinCategory);
					}
				}
			}
			GUILayout.EndScrollView();
			GUILayout.EndVertical();
			GUILayout.Space(8f);
			GUILayout.BeginVertical((GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.ExpandWidth(true) });
			GUILayout.Label("Icon", _subtitleStyle, (GUILayoutOption[])(object)new GUILayoutOption[0]);
			_iconSearch = DrawNamedTextField("icon_search", _iconSearch ?? string.Empty);
			RefreshIconSearch();
			_iconScroll = GUILayout.BeginScrollView(_iconScroll, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(145f) });
			DrawIconPickerGrid();
			GUILayout.EndScrollView();
			if (!string.IsNullOrEmpty(GUI.tooltip))
			{
				GUILayout.Label(GUI.tooltip, _subtitleStyle, (GUILayoutOption[])(object)new GUILayoutOption[0]);
			}
			else
			{
				GUILayout.Label("Selected: " + _selectedIconLabel, _subtitleStyle, (GUILayoutOption[])(object)new GUILayoutOption[0]);
			}
			GUILayout.EndVertical();
			GUILayout.EndHorizontal();
			GUILayout.Space(5f);
			GUILayout.BeginHorizontal((GUILayoutOption[])(object)new GUILayoutOption[0]);
			GUILayout.Label("Name", (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(45f) });
			_newPinName = DrawNamedTextField("new_pin_name", _newPinName ?? string.Empty, GUILayout.ExpandWidth(true));
			GUILayout.EndHorizontal();
			GUILayout.BeginHorizontal((GUILayoutOption[])(object)new GUILayoutOption[0]);
			if (GUILayout.Button("Create Here", (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(110f) }))
			{
				CancelMapPlacement();
				CreateSelectedPinAtPlayer();
			}
			if (GUILayout.Button(_placeOnMapArmed ? "Cancel Map Placement" : "Place on Map", (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(155f) }))
			{
				_placeOnMapArmed = !_placeOnMapArmed;
			}
			GUILayout.FlexibleSpace();
			GUILayout.EndHorizontal();
			if (_placeOnMapArmed)
			{
				GUILayout.Label("Click any spot on the large map to place it there.", _subtitleStyle, (GUILayoutOption[])(object)new GUILayoutOption[0]);
			}
			else
			{
				GUILayout.Label("Arm Place on Map to choose a location. Double-click an existing Wayfinder pin to select it.", _subtitleStyle, (GUILayoutOption[])(object)new GUILayoutOption[0]);
			}
		}

		private void DrawIconPickerGrid()
		{
			int num = -1;
			Sprite sprite = ResolveCategoryDefaultPreviewSprite(_newPinCategory);
			GUILayout.BeginHorizontal((GUILayoutOption[])(object)new GUILayoutOption[0]);
			if (DrawIconButton(sprite, string.IsNullOrEmpty(_selectedIconKey), "Category default"))
			{
				_selectedIconKey = string.Empty;
				_selectedIconLabel = "Category default";
			}
			num++;
			for (int i = 0; i < _cachedIconResults.Count; i++)
			{
				WayfinderIconEntry wayfinderIconEntry = _cachedIconResults[i];
				if (wayfinderIconEntry == null)
				{
					continue;
				}
				if (num > 0 && num % 8 == 0)
				{
					GUILayout.EndHorizontal();
					GUILayout.BeginHorizontal((GUILayoutOption[])(object)new GUILayoutOption[0]);
				}
				string iconDisplayName = GetIconDisplayName(wayfinderIconEntry);
				bool selected = string.Equals(_selectedIconKey, wayfinderIconEntry.Key, StringComparison.OrdinalIgnoreCase);
				if (DrawIconButton(wayfinderIconEntry.Sprite, selected, iconDisplayName))
				{
					_selectedIconKey = wayfinderIconEntry.Key ?? string.Empty;
					_selectedIconLabel = iconDisplayName;
					if (wayfinderIconEntry.IsTrophy && _newPinCategory == WayfinderPinCategory.Custom)
					{
						SelectNewPinCategory(WayfinderPinCategory.Creature);
					}
					if (string.IsNullOrEmpty(_newPinName) || string.Equals(_newPinName, "New Wayfinder Pin", StringComparison.Ordinal))
					{
						_newPinName = CleanIconName(wayfinderIconEntry);
					}
				}
				num++;
			}
			GUILayout.FlexibleSpace();
			GUILayout.EndHorizontal();
		}

		private Sprite ResolveCategoryDefaultPreviewSprite(WayfinderPinCategory category)
		{
			if (_icons == null)
			{
				return null;
			}
			string key;
			switch (category)
			{
			case WayfinderPinCategory.Resource:
				key = "wayfinder:resource";
				break;
			case WayfinderPinCategory.Creature:
				key = "wayfinder:creature";
				break;
			case WayfinderPinCategory.Dungeon:
				key = "wayfinder:dungeon";
				break;
			case WayfinderPinCategory.PointOfInterest:
			case WayfinderPinCategory.Base:
				key = "wayfinder:structure";
				break;
			case WayfinderPinCategory.Spawner:
				key = "wayfinder:spawner";
				break;
			case WayfinderPinCategory.Habitat:
				key = "wayfinder:habitat";
				break;
			case WayfinderPinCategory.Sighting:
				key = "wayfinder:sighting";
				break;
			case WayfinderPinCategory.Vehicle:
				key = "wayfinder:vehicle";
				break;
			case WayfinderPinCategory.Trader:
				key = "wayfinder:trader";
				break;
			case WayfinderPinCategory.Portal:
				key = "wayfinder:portal";
				break;
			case WayfinderPinCategory.Outpost:
				key = "wayfinder:outpost";
				break;
			case WayfinderPinCategory.Farm:
				key = "wayfinder:farm";
				break;
			case WayfinderPinCategory.Dock:
				key = "wayfinder:dock";
				break;
			case WayfinderPinCategory.Road:
				key = "wayfinder:road";
				break;
			case WayfinderPinCategory.Bridge:
				key = "wayfinder:bridge";
				break;
			case WayfinderPinCategory.Camp:
				key = "wayfinder:camp";
				break;
			case WayfinderPinCategory.Storage:
				key = "wayfinder:storage";
				break;
			case WayfinderPinCategory.Danger:
				key = "wayfinder:danger";
				break;
			default:
				key = "wayfinder:custom";
				break;
			}
			if (_icons.TryGet(key, out var sprite))
			{
				return sprite;
			}
			return null;
		}

		private bool DrawIconButton(Sprite sprite, bool selected, string tooltip)
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: 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_004d: Expected O, but got Unknown
			//IL_010a: 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_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)
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			Rect rect = GUILayoutUtility.GetRect(42f, 42f, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.Width(42f),
				GUILayout.Height(42f)
			});
			bool result = GUI.Button(rect, new GUIContent(string.Empty, tooltip), _buttonStyle);
			if ((Object)(object)sprite != (Object)null && (Object)(object)sprite.texture != (Object)null)
			{
				Rect val = default(Rect);
				((Rect)(ref val))..ctor(((Rect)(ref rect)).x + 5f, ((Rect)(ref rect)).y + 5f, ((Rect)(ref rect)).width - 10f, ((Rect)(ref rect)).height - 10f);
				try
				{
					Rect textureRect = sprite.textureRect;
					Texture texture = (Texture)(object)sprite.texture;
					Rect val2 = default(Rect);
					((Rect)(ref val2))..ctor(((Rect)(ref textureRect)).x / (float)texture.width, ((Rect)(ref textureRect)).y / (float)texture.height, ((Rect)(ref textureRect)).width / (float)texture.width, ((Rect)(ref textureRect)).height / (float)texture.height);
					GUI.DrawTextureWithTexCoords(val, texture, val2, true);
				}
				catch
				{
					GUI.DrawTexture(val, (Texture)(object)sprite.texture, (ScaleMode)2, true);
				}
			}
			if (selected)
			{
				DrawBronzeRect(rect, 2f);
			}
			return result;
		}

		private void RefreshIconSearch()
		{
			if (_icons == null || !_icons.IsBuilt)
			{
				_cachedIconResults.Clear();
				return;
			}
			int num = ((_icons.All != null) ? _icons.All.Count : 0);
			string text = _iconSearch ?? string.Empty;
			if (!string.Equals(text, _cachedIconQuery, StringComparison.Ordinal) || num != _cachedIconRegistryCount || _cachedIconCategory != _newPinCategory)
			{
				_cachedIconQuery = text;
				_cachedIconRegistryCount = num;
				_cachedIconCategory = _newPinCategory;
				_cachedIconResults = _icons.Search(text, _newPinCategory, 48);
			}
		}

		private void CreateSelectedPinAtPlayer()
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)Player.m_localPlayer == (Object)null))
			{
				WayfinderPinRecord wayfinderPinRecord = _manager.CreateManualPin(_newPinName, _newPinCategory, ((Component)Player.m_localPlayer).transform.position, _selectedIconKey);
				if (wayfinderPinRecord != null)
				{
					Select(wayfinderPinRecord);
					ForceMapRefresh();
				}
			}
		}

		internal bool BeforeVanillaMapLeftDown()
		{
			//IL_0027: 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_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			if (!IsLargeMapOpen())
			{
				ResetMapPrimaryGesture();
				return true;
			}
			if (IsPointerOverWayfinderUi())
			{
				ResetMapPrimaryGesture();
				return false;
			}
			_mapPrimaryPointerDown = true;
			_mapPrimaryDownScreenPosition = new Vector2(Input.mousePosition.x, Input.mousePosition.y);
			return true;
		}

		internal bool BeforeVanillaMapLeftClick()
		{
			//IL_0039: 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_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			if (!IsLargeMapOpen())
			{
				ResetMapPrimaryGesture();
				return true;
			}
			if (IsPointerOverWayfinderUi())
			{
				ResetMapPrimaryGesture();
				return false;
			}
			if (!_placeOnMapArmed || !Visible)
			{
				ResetMapPrimaryGesture();
				return true;
			}
			Vector2 val = default(Vector2);
			((Vector2)(ref val))..ctor(Input.mousePosition.x, Input.mousePosition.y);
			if (_mapPrimaryPointerDown && Vector2.Distance(_mapPrimaryDownScreenPosition, val) > 8f)
			{
				ResetMapPrimaryGesture();
				return true;
			}
			ResetMapPrimaryGesture();
			if (!TryScreenPointToWorld(Input.mousePosition, out var worldPosition))
			{
				return false;
			}
			WayfinderPinRecord wayfinderPinRecord = _manager.CreateManualPin(_newPinName, _newPinCategory, worldPosition, _selectedIconKey);
			if (wayfinderPinRecord != null)
			{
				CancelMapPlacement();
				Select(wayfinderPinRecord);
				ForceMapRefresh();
			}
			return false;
		}

		internal bool BeforeVanillaMapDoubleClick()
		{
			//IL_0013: 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)
			if (!IsLargeMapOpen())
			{
				return true;
			}
			if (IsPointerOverWayfinderUi())
			{
				return false;
			}
			if (!TryScreenPointToWorld(Input.mousePosition, out var worldPosition))
			{
				return false;
			}
			WayfinderPinRecord wayfinderPinRecord = FindNearestWayfinderRecord(worldPosition, 22f);
			if (wayfinderPinRecord != null)
			{
				CancelMapPlacement();
				_view = ManagerView.Pins;
				Visible = true;
				_openedFromMapGraceUntil = Time.unscaledTime + 0.45f;
				_ignoreUiMouseUntil = Time.unscaledTime + 0.18f;
				Select(wayfinderPinRecord);
				if (wayfinderPinRecord.tracked && wayfinderPinRecord.trackSlot >= 0)
				{
					_trackingStatus = "Tracking slot " + (wayfinderPinRecord.trackSlot + 1) + " — " + TrackedColorPalette.GetName(wayfinderPinRecord.trackSlot) + ".";
				}
				else
				{
					_trackingStatus = "Selected existing pin. Press Track Pin to track it.";
				}
				return false;
			}
			return false;
		}

		private WayfinderPinRecord FindNearestWayfinderRecord(Vector3 worldPosition, float radius)
		{
			//IL_0032: 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)
			IReadOnlyList<WayfinderPinRecord> records = _manager.Records;
			if (records == null || radius <= 0f)
			{
				return null;
			}
			WayfinderPinRecord result = null;
			float num = radius * radius;
			for (int i = 0; i < records.Count; i++)
			{
				WayfinderPinRecord wayfinderPinRecord = records[i];
				if (wayfinderPinRecord != null)
				{
					float num2 = wayfinderPinRecord.Position.x - worldPosition.x;
					float num3 = wayfinderPinRecord.Position.z - worldPosition.z;
					float num4 = num2 * num2 + num3 * num3;
					if (!(num4 > num))
					{
						num = num4;
						result = wayfinderPinRecord;
					}
				}
			}
			return result;
		}

		private string DrawNamedTextField(string id, string value, params GUILayoutOption[] options)
		{
			//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_003c: 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)
			string text = "JW_TEXT_" + (id ?? "field");
			GUI.SetNextControlName(text);
			string result = GUILayout.TextField(value ?? string.Empty, options);
			Event current = Event.current;
			Rect lastRect = GUILayoutUtility.GetLastRect();
			if (current != null && (int)current.type == 0 && current.button == 0 && ((Rect)(ref lastRect)).Contains(current.mousePosition))
			{
				_textFieldHitThisMouseDown = true;
				_textInputFocused = true;
			}
			string nameOfFocusedControl = GUI.GetNameOfFocusedControl();
			if (string.Equals(nameOfFocusedControl, text, StringComparison.Ordinal))
			{
				_textInputFocused = true;
			}
			return result;
		}

		private void RefreshTextInputFocusFromGui()
		{
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			string nameOfFocusedControl = GUI.GetNameOfFocusedControl();
			if (Visible && !string.IsNullOrEmpty(nameOfFocusedControl) && nameOfFocusedControl.StartsWith("JW_TEXT_", StringComparison.Ordinal))
			{
				_textInputFocused = true;
			}
			else if (GUIUtility.keyboardControl == 0)
			{
				_textInputFocused = false;
			}
			Event current = Event.current;
			if (current != null && (int)current.type == 0 && current.button == 0 && !_textFieldHitThisMouseDown)
			{
				_textInputFocused = false;
			}
		}

		internal bool ShouldSuppressGameplayInputForTextInput()
		{
			if (Visible && IsLargeMapOpen())
			{
				return _textInputFocused;
			}
			return false;
		}

		internal bool ShouldSuppressMapActionForTextInput()
		{
			return ShouldSuppressGameplayInputForTextInput();
		}

		internal void LogSuppressedGameplayInput(string inputName)
		{
			if (_config.DebugLogging.Value && _config.VerboseRuntimeLogging.Value && !(Time.unscaledTime < _nextMapKeyDebugLogTime))
			{
				_nextMapKeyDebugLogTime = Time.unscaledTime + 0.25f;
				_log.LogInfo((object)("JW INPUT: text field captured gameplay input: " + (string.IsNullOrEmpty(inputName) ? "unknown" : inputName) + "."));
			}
		}

		internal bool ShouldBlockMapKeyboardInput()
		{
			if (ShouldSuppressGameplayInputForTextInput())
			{
				return Input.anyKeyDown;
			}
			return false;
		}

		internal bool ShouldBlockMapPointerInput()
		{
			if (IsLargeMapOpen())
			{
				return IsPointerOverWayfinderUi();
			}
			return false;
		}

		internal bool ShouldBlockMapZoomInput()
		{
			return ShouldBlockMapPointerInput();
		}

		private bool IsPointerOverWayfinderUi()
		{
			//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_0030: 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)
			Vector3 mousePosition = Input.mousePosition;
			Vector2 val = default(Vector2);
			((Vector2)(ref val))..ctor(mousePosition.x, (float)Screen.height - mousePosition.y);
			if (Visible && ((Rect)(ref _windowRect)).Contains(val))
			{
				return true;
			}
			if (_toolbarHitRectValid)
			{
				return ((Rect)(ref _toolbarHitRect)).Contains(val);
			}
			return false;
		}

		private void CancelMapPlacement()
		{
			_placeOnMapArmed = false;
			ResetMapPrimaryGesture();
		}

		private void ResetMapPrimaryGesture()
		{
			//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)
			_mapPrimaryPointerDown = false;
			_mapPrimaryDownScreenPosition = Vector2.zero;
		}

		private static bool TryScreenPointToWorld(Vector3 screenPoint, out Vector3 worldPosition)
		{
			//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_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
			worldPosition = Vector3.zero;
			Minimap instance = Minimap.instance;
			if ((Object)(object)instance == (Object)null)
			{
				return false;
			}
			for (int i = 0; i < MinimapMethods.Length; i++)
			{
				MethodInfo methodInfo = MinimapMethods[i];
				if (methodInfo == null || !string.Equals(methodInfo.Name, "ScreenToWorldPoint", StringComparison.Ordinal))
				{
					continue;
				}
				ParameterInfo[] parameters = methodInfo.GetParameters();
				try
				{
					object obj = null;
					if (parameters.Length == 1 && parameters[0].ParameterType == typeof(Vector3))
					{
						obj = methodInfo.Invoke(instance, new object[1] { screenPoint });
						goto IL_00e7;
					}
					if (parameters.Length == 1 && parameters[0].ParameterType == typeof(Vector2))
					{
						obj = methodInfo.Invoke(instance, new object[1] { (object)new Vector2(screenPoint.x, screenPoint.y) });
						goto IL_00e7;
					}
					goto end_IL_0054;
					IL_00e7:
					if (obj is Vector3)
					{
						worldPosition = (Vector3)obj;
						return true;
					}
					end_IL_0054:;
				}
				catch
				{
				}
			}
			return false;
		}

		private void SelectNewPinCategory(WayfinderPinCategory category)
		{
			_newPinCategory = category;
			_cachedIconQuery = null;
			_cachedIconCategory = (WayfinderPinCategory)(-1);
			if (!string.IsNullOrEmpty(_selectedIconKey) && _icons != null)
			{
				WayfinderIconEntry wayfinderIconEntry = FindIconEntry(_selectedIconKey);
				if (wayfinderIconEntry != null && !_icons.IsCompatibleWithCategory(wayfinderIconEntry, category))
				{
					_selectedIconKey = string.Empty;
					_selectedIconLabel = "Category default";
				}
			}
		}

		private WayfinderIconEntry FindIconEntry(string key)
		{
			if (_icons == null || _icons.All == null || string.IsNullOrEmpty(key))
			{
				return null;
			}
			for (int i = 0; i < _icons.All.Count; i++)
			{
				WayfinderIconEntry wayfinderIconEntry = _icons.All[i];
				if (wayfinderIconEntry != null && string.Equals(wayfinderIconEntry.Key, key, StringComparison.OrdinalIgnoreCase))
				{
					return wayfinderIconEntry;
				}
			}
			return null;
		}

		private void DrawBossNamingControls()
		{
			if (!_config.OverrideVanillaBossNames.Value)
			{
				GUILayout.BeginHorizontal((GUILayoutOption[])(object)new GUILayoutOption[0]);
				GUILayout.Label("Native boss labels: vanilla", (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(180f) });
				if (GUILayout.Button("Use Wayfinder Names", (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(150f) }))
				{
					_config.OverrideVanillaBossNames.Value = true;
					_bossNameBuffer = string.Empty;
					ForceMapRefresh();
				}
				GUILayout.EndHorizontal();
				return;
			}
			string[] knownKeys = WayfinderBossNaming.KnownKeys;
			if (knownKeys != null && knownKeys.Length != 0)
			{
				_bossNameIndex = Mathf.Clamp(_bossNameIndex, 0, knownKeys.Length - 1);
				string key = knownKeys[_bossNameIndex];
				if (string.IsNullOrEmpty(_bossNameBuffer))
				{
					_bossNameBuffer = WayfinderBossNaming.GetDisplayName(_config, key);
				}
				GUILayout.BeginHorizontal((GUILayoutOption[])(object)new GUILayoutOption[0]);
				GUILayout.Label("Boss label", (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(70f) });
				if (GUILayout.Button("<", (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(30f) }))
				{
					_bossNameIndex = (_bossNameIndex - 1 + knownKeys.Length) % knownKeys.Length;
					_bossNameBuffer = WayfinderBossNaming.GetDisplayName(_config, knownKeys[_bossNameIndex]);
				}
				GUILayout.Label(WayfinderBossNaming.DefaultDisplayName(knownKeys[_bossNameIndex]), (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(85f) });
				if (GUILayout.Button(">", (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(30f) }))
				{
					_bossNameIndex = (_bossNameIndex + 1) % knownKeys.Length;
					_bossNameBuffer = WayfinderBossNaming.GetDisplayName(_config, knownKeys[_bossNameIndex]);
				}
				_bossNameBuffer = DrawNamedTextField("boss_name", _bossNameBuffer ?? string.Empty, GUILayout.Width(180f));
				if (GUILayout.Button("Apply", (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(60f) }))
				{
					WayfinderBossNaming.SetDisplayName(_config, knownKeys[_bossNameIndex], _bossNameBuffer);
					ForceMapRefresh();
				}
				if (GUILayout.Button("Vanilla Names", (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(100f) }))
				{
					_config.OverrideVanillaBossNames.Value = false;
					ForceMapRefresh();
				}
				GUILayout.EndHorizontal();
			}
		}

		private static bool HasInGameIcon(WayfinderPinRecord record)
		{
			string displayedIconKey = GetDisplayedIconKey(record);
			if (!string.IsNullOrEmpty(displayedIconKey))
			{
				return displayedIconKey.StartsWith("item:", StringComparison.OrdinalIgnoreCase);
			}
			return false;
		}

		private void EnsureTheme()
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_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_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_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_0131: Unknown result type (might be due to invalid IL or missing references)
			//IL_0136: Unknown result type (might be due to invalid IL or missing references)
			//IL_013b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0150: Unknown result type (might be due to invalid IL or missing references)
			//IL_0155: 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_016f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0174: Unknown result type (might be due to invalid IL or missing references)
			//IL_0179: Unknown result type (might be due to invalid IL or missing references)
			//IL_0185: Unknown result type (might be due to invalid IL or missing references)
			//IL_018f: Expected O, but got Unknown
			//IL_024d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0257: Expected O, but got Unknown
			//IL_0262: Unknown result type (might be due to invalid IL or missing references)
			//IL_026c: Expected O, but got Unknown
			//IL_0327: Unknown result type (might be due to invalid IL or missing references)
			//IL_0338: Unknown result type (might be due to invalid IL or missing references)
			//IL_0349: Unknown result type (might be due to invalid IL or missing references)
			//IL_035a: Unknown result type (might be due to invalid IL or missing references)
			//IL_036b: 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_038d: Unknown result type (might be due to invalid IL or missing references)
			//IL_039e: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c4: Expected O, but got Unknown
			//IL_03cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d9: Expected O, but got Unknown
			//IL_0494: Unknown result type (might be due to invalid IL or missing references)
			//IL_04a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_04b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_04c3: Expected O, but got Unknown
			//IL_04ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_04d8: Expected O, but got Unknown
			//IL_04e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_04f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_04fe: Expected O, but got Unknown
			//IL_0509: Unknown result type (might be due to invalid IL or missing references)
			//IL_051a: Unknown result type (might be due to invalid IL or missing references)
			//IL_052b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0540: Unknown result type (might be due to invalid IL or missing references)
			//IL_0551: Unknown result type (might be due to invalid IL or missing references)
			//IL_0562: Unknown result type (might be due to invalid IL or missing references)
			//IL_0573: Unknown result type (might be due to invalid IL or missing references)
			//IL_0584: Unknown result type (might be due to invalid IL or missing references)
			//IL_0595: Unknown result type (might be due to invalid IL or missing references)
			//IL_059f: Expected O, but got Unknown
			//IL_05c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_05d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_05da: Expected O, but got Unknown
			//IL_05e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_05ee: Expected O, but got Unknown
			//IL_05f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_05ff: Expected O, but got Unknown
			//IL_0605: Unknown result type (might be due to invalid IL or missing references)
			//IL_060f: Expected O, but got Unknown
			//IL_062f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0639: Expected O, but got Unknown
			//IL_0644: Unknown result type (might be due to invalid IL or missing references)
			//IL_066a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0674: Expected O, but got Unknown
			//IL_067f: Unknown result type (might be due to invalid IL or missing references)
			if (_windowStyle == null)
			{
				_panelTexture = MakeSolidTexture(Color32.op_Implicit(new Color32((byte)20, (byte)22, (byte)24, (byte)248)), "JW Panel");
				_buttonTexture = MakeSolidTexture(Color32.op_Implicit(new Color32((byte)43, (byte)44, (byte)43, byte.MaxValue)), "JW Button");
				_buttonHoverTexture = MakeSolidTexture(Color32.op_Implicit(new Color32((byte)72, (byte)61, (byte)45, byte.MaxValue)), "JW Button Hover");
				_fieldTexture = MakeSolidTexture(Color32.op_Implicit(new Color32((byte)28, (byte)30, (byte)31, byte.MaxValue)), "JW Field");
				_sectionTexture = MakeSolidTexture(Color32.op_Implicit(new Color32((byte)30, (byte)32, (byte)33, (byte)238)), "JW Section");
				_jwButtonTexture = LoadEmbeddedRgba("JoeyBadManners.Wayfinder.Assets.wayfinder_compass_jw_small.rgba", 26, 26, "JW Pin Manager Button", flipVertical: true);
				_createControlTexture = MakeControlGlyphTexture(ControlGlyph.Create, "JW Add Pin");
				_pinsControlTexture = MakeControlGlyphTexture(ControlGlyph.Pins, "JW Pins");
				_visibilityControlTexture = MakeControlGlyphTexture(ControlGlyph.Visibility, "JW Visibility");
				_trackingControlTexture = MakeControlGlyphTexture(ControlGlyph.Tracking, "JW Track");
				Color textColor = Color32.op_Implicit(new Color32((byte)188, (byte)151, (byte)99, byte.MaxValue));
				Color textColor2 = Color32.op_Implicit(new Color32((byte)224, (byte)216, (byte)195, byte.MaxValue));
				Color textColor3 = Color32.op_Implicit(new Color32((byte)151, (byte)148, (byte)138, byte.MaxValue));
				_windowStyle = new GUIStyle(GUI.skin.window);
				_windowStyle.normal.background = _panelTexture;
				_windowStyle.hover.background = _panelTexture;
				_windowStyle.active.background = _panelTexture;
				_windowStyle.focused.background = _panelTexture;
				_windowStyle.onNormal.background = _panelTexture;
				_windowStyle.onHover.background = _panelTexture;
				_windowStyle.onActive.background = _panelTexture;
				_windowStyle.onFocused.background = _panelTexture;
				_windowStyle.padding = new RectOffset(12, 12, 10, 12);
				_buttonStyle = new GUIStyle(GUI.skin.button);
				_buttonStyle.normal.background = _buttonTexture;
				_buttonStyle.hover.background = _buttonTexture;
				_buttonStyle.active.background = _buttonTexture;
				_buttonStyle.focused.background = _buttonTexture;
				_buttonStyle.onNormal.background = _buttonTexture;
				_buttonStyle.onHover.background = _buttonTexture;
				_buttonStyle.onActive.background = _buttonTexture;
				_buttonStyle.onFocused.background = _buttonTexture;
				_buttonStyle.normal.textColor = textColor2;
				_buttonStyle.hover.textColor = textColor2;
				_buttonStyle.active.textColor = textColor2;
				_buttonStyle.focused.textColor = textColor2;
				_buttonStyle.onNormal.textColor = textColor2;
				_buttonStyle.onHover.textColor = textColor2;
				_buttonStyle.onActive.textColor = textColor2;
				_buttonStyle.onFocused.textColor = textColor2;
				_buttonStyle.fontStyle = (FontStyle)1;
				_buttonStyle.padding = new RectOffset(8, 8, 5, 5);
				_textFieldStyle = new GUIStyle(GUI.skin.textField);
				_textFieldStyle.normal.background = _fieldTexture;
				_textFieldStyle.focused.background = _fieldTexture;
				_textFieldStyle.hover.background = _fieldTexture;
				_textFieldStyle.active.background = _fieldTexture;
				_textFieldStyle.onNormal.background = _fieldTexture;
				_textFieldStyle.onHover.background = _fieldTexture;
				_textFieldStyle.onActive.background = _fieldTexture;
				_textFieldStyle.onFocused.background = _fieldTexture;
				_textFieldStyle.normal.textColor = textColor2;
				_textFieldStyle.focused.textColor = Color.white;
				_textFieldStyle.padding = new RectOffset(7, 7, 5, 5);
				_labelStyle = new GUIStyle(GUI.skin.label);
				_labelStyle.normal.textColor = textColor2;
				_toggleStyle = new GUIStyle(GUI.skin.toggle);
				_toggleStyle.normal.textColor = textColor2;
				_toggleStyle.onNormal.textColor = textColor;
				_toggleStyle.hover.textColor = Color.white;
				_toggleStyle.active.textColor = textColor2;
				_toggleStyle.focused.textColor = textColor2;
				_toggleStyle.onHover.textColor = textColor;
				_toggleStyle.onActive.textColor = textColor;
				_toggleStyle.onFocused.textColor = textColor;
				_sectionStyle = new GUIStyle(GUI.skin.box);
				_sectionStyle.normal.background = _sectionTexture;
				_sectionStyle.normal.textColor = textColor2;
				_sectionStyle.padding = new RectOffset(8, 8, 7, 8);
				_sectionStyle.margin = new RectOffset(2, 2, 2, 2);
				_mapButtonStyle = new GUIStyle(_buttonStyle);
				_toolbarButtonStyle = new GUIStyle(GUIStyle.none);
				_toolbarButtonStyle.alignment = (TextAnchor)4;
				_toolbarButtonStyle.fontSize = 10;
				_titleStyle = new GUIStyle(_labelStyle);
				_titleStyle.normal.textColor = textColor;
				_titleStyle.fontSize = 15;
				_titleStyle.fontStyle = (FontStyle)1;
				_subtitleStyle = new GUIStyle(_labelStyle);
				_subtitleStyle.normal.textColor = textColor3;
				_subtitleStyle.fontSize = 10;
				_subtitleStyle.fontStyle = (FontStyle)1;
			}
		}

		private static Texture2D MakeControlGlyphTexture(ControlGlyph glyph, string name)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			//IL_004e: 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_0072: 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_0092: 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_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: 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_010a: Unknown result type (might be due to invalid IL or missing references)
			//IL_011a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0129: Unknown result type (might be due to invalid IL or missing references)
			//IL_0139: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			Texture2D val = new Texture2D(32, 32, (TextureFormat)4, false);
			((Object)val).name = name;
			Color32 val2 = default(Color32);
			((Color32)(ref val2))..ctor((byte)0, (byte)0, (byte)0, (byte)0);
			Color32 color = default(Color32);
			((Color32)(ref color))..ctor((byte)205, (byte)166, (byte)106, byte.MaxValue);
			Color32[] array = (Color32[])(object)new Color32[1024];
			for (int i = 0; i < array.Length; i++)
			{
				array[i] = val2;
			}
			val.SetPixels32(array);
			switch (glyph)
			{
			case ControlGlyph.Create:
				DrawGlyphDiamond(val, 16, 16, 11, color, 1);
				DrawGlyphLine(val, 16, 9, 16, 23, color, 2);
				DrawGlyphLine(val, 9, 16, 23, 16, color, 2);
				break;
			case ControlGlyph.Pins:
				DrawGlyphPin(val, 9, 20, color);
				DrawGlyphPin(val, 16, 13, color);
				DrawGlyphPin(val, 23, 20, color);
				break;
			case ControlGlyph.Visibility:
				DrawGlyphEllipse(val, 16, 16, 12, 7, color, 1);
				DrawGlyphCircle(val, 16, 16, 3, color, 2);
				break;
			default:
				DrawGlyphCircle(val, 16, 16, 9, color, 1);
				DrawGlyphCircle(val, 16, 16, 3, color, 1);
				DrawGlyphLine(val, 16, 4, 16, 10, color, 1);
				DrawGlyphLine(val, 16, 22, 16, 28, color, 1);
				DrawGlyphLine(val, 4, 16, 10, 16, color, 1);
				DrawGlyphLine(val, 22, 16, 28, 16, color, 1);
				break;
			}
			val.Apply(false, true);
			return val;
		}

		private static void DrawGlyphPin(Texture2D texture, int x, int y, Color32 color)
		{
			//IL_0004: 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_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			DrawGlyphCircle(texture, x, y, 4, color, 2);
			DrawGlyphLine(texture, x, y - 4, x, y - 10, color, 2);
			DrawGlyphLine(texture, x - 3, y - 6, x, y - 10, color, 1);
			DrawGlyphLine(texture, x + 3, y - 6, x, y - 10, color, 1);
		}

		private static void DrawGlyphDiamond(Texture2D texture, int cx, int cy, int radius, Color32 color, int thickness)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: 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)
			DrawGlyphLine(texture, cx, cy + radius, cx + radius, cy, color, thickness);
			DrawGlyphLine(texture, cx + radius, cy, cx, cy - radius, color, thickness);
			DrawGlyphLine(texture, cx, cy - radius, cx - radius, cy, color, thickness);
			DrawGlyphLine(texture, cx - radius, cy, cx, cy + radius, color, thickness);
		}

		private static void DrawGlyphEllipse(Texture2D texture, int cx, int cy, int rx, int ry, Color32 color, int thickness)
		{
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			for (int i = 0; i < 360; i += 3)
			{
				float num = (float)i * ((float)Math.PI / 180f);
				int x = Mathf.RoundToInt((float)cx + Mathf.Cos(num) * (float)rx);
				int y = Mathf.RoundToInt((float)cy + Mathf.Sin(num) * (float)ry);
				SetGlyphPixel(texture, x, y, color, thickness);
			}
		}

		private static void DrawGlyphCircle(Texture2D texture, int cx, int cy, int radius, Color32 color, int thickness)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			DrawGlyphEllipse(texture, cx, cy, radius, radius, color, thickness);
		}

		private static void DrawGlyphLine(Texture2D texture, int x0, int y0, int x1, int y1, Color32 color, int thickness)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			int num = Mathf.Abs(x1 - x0);
			int num2 = ((x0 < x1) ? 1 : (-1));
			int num3 = -Mathf.Abs(y1 - y0);
			int num4 = ((y0 < y1) ? 1 : (-1));
			int num5 = num + num3;
			while (true)
			{
				SetGlyphPixel(texture, x0, y0, color, thickness);
				if (x0 == x1 && y0 == y1)
				{
					break;
				}
				int num6 = 2 * num5;
				if (num6 >= num3)
				{
					num5 += num3;
					x0 += num2;
				}
				if (num6 <= num)
				{
					num5 += num;
					y0 += num4;
				}
			}
		}

		private static void SetGlyphPixel(Texture2D texture, int x, int y, Color32 color, int thickness)
		{
			//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)
			if ((Object)(object)texture == (Object)null)
			{
				return;
			}
			int num = Mathf.Max(0, thickness - 1);
			for (int i = -num; i <= num; i++)
			{
				for (int j = -num; j <= num; j++)
				{
					int num2 = x + j;
					int num3 = y + i;
					if (num2 >= 0 && num3 >= 0 && num2 < ((Texture)texture).width && num3 < ((Texture)texture).height)
					{
						texture.SetPixel(num2, num3, Color32.op_Implicit(color));
					}
				}
			}
		}

		private static Texture2D MakeSolidTexture(Color color, string name)
		{
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Expected O, but got Unknown
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			Texture2D val = new Texture2D(1, 1, (TextureFormat)4, false);
			((Object)val).name = name;
			val.SetPixel(0, 0, color);
			val.Apply(false, true);
			return val;
		}

		private static Texture2D LoadEmbeddedRgba(string resourceName, int width, int height, string textureName, bool flipVertical)
		{
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Expected O, but got Unknown
			try
			{
				Assembly assembly = typeof(WayfinderPinManagerUI).Assembly;
				using Stream stream = assembly.GetManifestResourceStream(resourceName);
				if (stream == null)
				{
					return null;
				}
				int num = width * height * 4;
				byte[] array = new byte[num];
				int i;
				int num2;
				for (i = 0; i < array.Length; i += num2)
				{
					num2 = stream.Read(array, i, array.Length - i);
					if (num2 <= 0)
					{
						break;
					}
				}
				if (i != num)
				{
					return null;
				}
				Texture2D val = new Texture2D(width, height, (TextureFormat)4, false);
				((Object)val).name = textureName;
				if (flipVertical)
				{
					int num3 = width * 4;
					byte[] array2 = new byte[num3];
					for (int j = 0; j < height / 2; j++)
					{
						int num4 = j * num3;
						int num5 = (height - 1 - j) * num3;
						Buffer.BlockCopy(array, num4, array2, 0, num3);
						Buffer.BlockCopy(array, num5, array, num4, num3);
						Buffer.BlockCopy(array2, 0, array, num5, num3);
					}
				}
				val.LoadRawTextureData(array);
				val.Apply(false, true);
				return val;
			}
			catch
			{
				return null;
			}
		}

		private void DrawPanelBorder(Rect rect)
		{
			//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_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_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			Color color = GUI.color;
			GUI.color = Color32.op_Implicit(new Color32((byte)184, (byte)144, (byte)88, (byte)210));
			GUI.DrawTexture(new Rect(((Rect)(ref rect)).x, ((Rect)(ref rect)).y, ((Rect)(ref rect)).width, 1f), (Texture)(object)Texture2D.whiteTexture);
			GUI.DrawTexture(new Rect(((Rect)(ref rect)).x, ((Rect)(ref rect)).yMax - 1f, ((Rect)(ref rect)).width, 1f), (Texture)(object)Texture2D.whiteTexture);
			GUI.DrawTexture(new Rect(((Rect)(ref rect)).x, ((Rect)(ref rect)).y, 1f, ((Rect)(ref rect)).height), (Texture)(object)Texture2D.whiteTexture);
			GUI.DrawTexture(new Rect(((Rect)(ref rect)).xMax - 1f, ((Rect)(ref rect)).y, 1f, ((Rect)(ref rect)).height), (Texture)(object)Texture2D.whiteTexture);
			GUI.color = color;
		}

		private void DrawBronzeRect(Rect rect, float thickness)
		{
			//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_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_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			Color color = GUI.color;
			GUI.color = Color32.op_Implicit(new Color32((byte)188, (byte)151, (byte)99, (byte)235));
			GUI.DrawTexture(new Rect(((Rect)(ref rect)).x, ((Rect)(ref rect)).y, ((Rect)(ref rect)).width, thickness), (Texture)(object)Texture2D.whiteTexture);
			GUI.DrawTexture(new Rect(((Rect)(ref rect)).x, ((Rect)(ref rect)).yMax - thickness, ((Rect)(ref rect)).width, thickness), (Texture)(object)Texture2D.whiteTexture);
			GUI.DrawTexture(new Rect(((Rect)(ref rect)).x, ((Rect)(ref rect)).y, thickness, ((Rect)(ref rect)).height), (Texture)(object)Texture2D.whiteTexture);
			GUI.DrawTexture(new Rect(((Rect)(ref rect)).xMax - thickness, ((Rect)(ref rect)).y, thickness, ((Rect)(ref rect)).height), (Texture)(object)Texture2D.whiteTexture);
			GUI.color = color;
		}

		private void DrawHorizontalRule()
		{
			//IL_001b: 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_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: 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_0044: 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)
			Rect rect = GUILayoutUtility.GetRect(1f, 1f, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.ExpandWidth(true) });
			Color color = GUI.color;
			GUI.color = Color32.op_Implicit(new Color32((byte)129, (byte)103, (byte)67, (byte)190));
			GUI.DrawTexture(rect, (Texture)(object)Texture2D.whiteTexture);
			GUI.color = color;
			GUILayout.Space(5f);
		}

		private static string FriendlyCategoryName(WayfinderPinCategory category)
		{
			return category switch
			{
				WayfinderPinCategory.Creature => "Creature Marker", 
				WayfinderPinCategory.Sighting => "Enemy Sightings", 
				WayfinderPinCategory.Boss => "Bosses", 
				WayfinderPinCategory.PointOfInterest => "Point of Interest", 
				_ => category.ToString(), 
			};
		}

		private static string GetIconDisplayName(WayfinderIconEntry entry)
		{
			if (entry == null)
			{
				return "Unknown icon";
			}
			string text = CleanIconName(entry);
			string text2 = (entry.IsTrophy ? " [Trophy]" : string.Empty);
			return text + text2;
		}

		private static string CleanIconName(WayfinderIconEntry entry)
		{
			if (entry == null)
			{
				return "Wayfinder Pin";
			}
			string text = string.Empty;
			try
			{
				if (Localization.instance != null && !string.IsNullOrEmpty(entry.RawName))
				{
					text = Localization.instance.Localize(entry.RawName);
				}
			}
			catch
			{
			}
			string text2 = ((!string.IsNullOrEmpty(text) && !text.StartsWith("$")) ? text : entry.PrefabName);
			if (string.IsNullOrEmpty(text2))
			{
				text2 = entry.Key;
			}
			if (string.IsNullOrEmpty(text2))
			{
				return "Wayfinder Pin";
			}
			if (text2.StartsWith("Trophy", StringComparison.OrdinalIgnoreCase))
			{
				text2 = text2.Substring("Trophy".Length);
			}
			return text2.Replace("_", " ").Trim();
		}

		private void Select(WayfinderPinRecord record)
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			if (record != null)
			{
				_selectedId = record.id ?? string.Empty;
				_selectedCategory = record.category;
				_selectedPosition = record.Position;
				_renameBuffer = (string.IsNullOrEmpty(record.displayName) ? record.subtype : record.displayName);
				_scaleBuffer = Mathf.Clamp(record.scale, 0.5f, 2.5f);
				_deleteArmedId = string.Empty;
				_cachedEditIconQuery = null;
				_cachedEditIconCategory = (WayfinderPinCategory)(-1);
			}
		}

		private WayfinderPinRecord RecoverSelectedRecord()
		{
			//IL_003b: 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)
			IReadOnlyList<WayfinderPinRecord> records = _manager.Records;
			if (records == null)
			{
				return null;
			}
			WayfinderPinRecord result = null;
			float num = 2.25f;
			for (int i = 0; i < records.Count; i++)
			{
				WayfinderPinRecord wayfinderPinRecord = records[i];
				if (wayfinderPinRecord != null && wayfinderPinRecord.category == _selectedCategory)
				{
					float num2 = wayfinderPinRecord.Position.x - _selectedPosition.x;
					float num3 = wayfinderPinRecord.Position.z - _selectedPosition.z;
					float num4 = num2 * num2 + num3 * num3;
					if (!(num4 > num))
					{
						num = num4;
						result = wayfinderPinRecord;
					}
				}
			}
			return result;
		}

		private void ApplyColor(string id, Color color)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			_manager.SetColor(id, color);
			ForceMapRefresh();
		}

		private void ResetColorToDefault(string id)
		{
			_manager.ResetColorToDefault(id);
			ForceMapRefresh();
		}

		private static WayfinderPinCategory NextCategory(WayfinderPinCategory current)
		{
			Array values = Enum.GetValues(typeof(WayfinderPinCategory));
			int num = Array.IndexOf(values, current);
			num = (num + 1) % values.Length;
			return (WayfinderPinCategory)values.GetValue(num);
		}

		private static WayfinderPinCategory PreviousCategory(WayfinderPinCategory current)
		{
			Array values = Enum.GetValues(typeof(WayfinderPinCategory));
			int num = Array.IndexOf(values, current);
			num = (num - 1 + values.Length) % values.Length;
			return (WayfinderPinCategory)values.GetValue(num);
		}

		private static bool IsLargeMapOpen()
		{
			Minimap instance = Minimap.instance;
			if ((Object)(object)instance == (Object)null)
			{
				return false;
			}
			try
			{
				if (LargeRootField != null)
				{
					object? value = LargeRootField.GetValue(instance);
					GameObject val = (GameObject)((value is GameObject) ? value : null);
					if ((Object)(object)val != (Object)null)
					{
						return val.activeInHierarchy;
					}
				}
			}
			catch
			{
			}
			return false;
		}

		private static void ForceMapRefresh()
		{
			if (WayfinderPlugin.Map != null)
			{
				WayfinderPlugin.Map.ForceRefresh();
			}
		}
	}
}
namespace JoeyBadManners.Wayfinder.Map
{
	internal sealed class WayfinderMapController
	{
		private static readonly FieldInfo PinsField = AccessTools.Field(typeof(Minimap), "m_pins");

		private static readonly MethodInfo GetSpriteMethod = AccessTools.Method(typeof(Minimap), "GetSprite", new Type[1] { typeof(PinType) }, (Type[])null);

		private static readonly MethodInfo GetClosestPinMethod = AccessTools.Method(typeof(Minimap), "GetClosestPin", new Type[3]
		{
			typeof(Vector3),
			typeof(float),
			typeof(bool)
		}, (Type[])null);

		private static readonly FieldInfo PinUpdateRequiredField = AccessTools.Field(typeof(Minimap), "m_pinUpdateRequired");

		private static readonly FieldInfo LargeShipMarkerField = AccessTools.Field(typeof(Minimap), "m_largeShipMarker");

		private static readonly FieldInfo SmallShipMarkerField = AccessTools.Field(typeof(Minimap), "m_smallShipMarker");

		private static readonly FieldInfo LargeRootField = AccessTools.Field(typeof(Minimap), "m_largeRoot");

		private static readonly FieldInfo MapLargeField = typeof(Minimap).GetField("m_mapLarge", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);

		private static readonly Type UiInputHandlerType = AccessTools.TypeByName("UIInputHandler");

		private static readonly Type UiInputHintType = AccessTools.TypeByName("UIInputHint");

		private static readonly FieldInfo UiInputHintMouseKeyboardField = ((UiInputHintType == null) ? null : AccessTools.Field(UiInputHintType, "m_mouseKeyboardHint"));

		private static readonly FieldInfo[] VanillaSelectedIconFields = new FieldInfo[7]
		{
			AccessTools.Field(typeof(Minimap), "m_selectedIcon0"),
			AccessTools.Field(typeof(Minimap), "m_selectedIcon1"),
			AccessTools.Field(typeof(Minimap), "m_selectedIcon2"),
			AccessTools.Field(typeof(Minimap), "m_selectedIcon3"),
			AccessTools.Field(typeof(Minimap), "m_selectedIcon4"),
			AccessTools.Field(typeof(Minimap), "m_selectedIconDeath"),
			AccessTools.Field(typeof(Minimap), "m_selectedIconBoss")
		};

		private readonly ManualLogSource _log;

		private readonly WayfinderConfig _config;

		private readonly RuntimeIconRegistry _icons;

		private readonly WayfinderPinDatabase _database;

		private readonly WayfinderPinManagementService _manager;

		private readonly Dictionary<string, PinData> _recordPins = new Dictionary<string, PinData>();

		private readonly Dictionary<PinData, WayfinderPinRecord> _recordsByPin = new Dictionary<PinData, WayfinderPinRecord>();

		private readonly Dictionary<PinData, string> _nativeBossKeys = new Dictionary<PinData, string>();

		private readonly Dictionary<PinData, GameObject> _trackedOverlays = new Dictionary<PinData, GameObject>();

		private readonly Dictionary<PinData, GameObject> _lastKnownVehicleOverlays = new Dictionary<PinData, GameObject>();

		private Sprite _trackedDotSprite;

		private Sprite _lastKnownVehicleBadgeSprite;

		private GUIStyle _mapNameStyle;

		private readonly Dictionary<GameObject, bool> _vanillaPinUiOriginalActive = new Dictionary<GameObject, bool>();

		private bool _vanillaPinUiCacheBuilt;

		private float _nextVanillaPinUiProbeTime;

		private GameObject _persistentPinPanel;

		private bool _didDumpPersistentPanelDiagnostics;

		private float _nextPersistentPanelDiagnosticAttemptTime;

		private static readonly FieldInfo NamePinDataField = AccessTools.Field(typeof(PinData), "m_NamePinData");

		private static readonly FieldInfo NamePinField = typeof(PinData).GetField("m_namePin", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);

		private Minimap _map;

		private int _lastRevision = -1;

		private long _lastWorldUid = long.MinValue;

		private bool _internalPinRemoval;

		private float _nextVisualRefreshTime;

		private string _lastHiddenCategories;

		internal WayfinderMapController(ManualLogSource log, WayfinderConfig config, RuntimeIconRegistry icons, WayfinderPinDatabase database, WayfinderPinManagementService manager)
		{
			_log = log;
			_config = config;
			_icons = icons;
			_database = database;
			_manager = manager;
		}

		internal void Tick()
		{
			if (!_config.Enabled.Value)
			{
				return;
			}
			Minimap instance = Minimap.instance;
			if ((Object)(object)instance == (Object)null)
			{
				if ((Object)(object)_map != (Object)null)
				{
					Detach();
				}
				return;
			}
			if (!object.ReferenceEquals(instance, _map) || _lastWorldUid != _database.WorldUid)
			{
				Detach();
				_map = instance;
				_lastWorldUid = _database.WorldUid;
				_lastRevision = -1;
			}
			string text = _config.HiddenCategories.Value ?? string.Empty;
			if (!string.Equals(text, _lastHiddenCategories, StringComparison.Ordinal))
			{
				_lastHiddenCategories = text;
				_lastRevision = -1;
			}
			if (_database.WorldUid != 0 && _lastRevision != _database.Revision)
			{
				SyncDatabasePins();
			}
		}

		internal void OnMinimapStarted(Minimap map)
		{
			if (!((Object)(object)map == (Object)null))
			{
				if (!object.ReferenceEquals(_map, map))
				{
					Detach();
					_map = map;
					_lastRevision = -1;
					_lastWorldUid = _database.WorldUid;
				}
				SyncDatabasePins();
			}
		}

		internal void AfterUpdatePins(Minimap map)
		{
			if (_config.Enabled.Value && !((Object)(object)map == (Object)null) && !(Time.unscaledTime < _nextVisualRefreshTime))
			{
				_nextVisualRefreshTime = Time.unscaledTime + Mathf.Max(0.05f, _config.MapVisualRefreshInterval.Value);
				ApplyWayfinderPinVisuals();
				ApplyVanillaSpecialPinVisuals(map);
				ApplyVanillaBossVisuals(map);
				EnforceVanillaPersistentPinUiVisibility(map);
			}
		}

		internal void EnforceVanillaPersistentPinUiVisibility(Minimap map)
		{
			if ((Object)(object)map == (Object)null)
			{
				return;
			}
			if (!_config.ReplaceVanillaPersistentPinControls.Value)
			{
				RestoreVanillaPersistentPinUi();
				return;
			}
			if (!_vanillaPinUiCacheBuilt || _vanillaPinUiOriginalActive.Count == 0 || Time.unscaledTime >= _nextVanillaPinUiProbeTime)
			{
				_nextVanillaPinUiProbeTime = Time.unscaledTime + 0.75f;
				CacheVanillaPersistentPinUi(map);
			}
			foreach (KeyValuePair<GameObject, bool> item in _vanillaPinUiOriginalActive)
			{
				GameObject key = item.Key;
				if ((Object)(object)key != (Object)null && key.activeSelf)
				{
					key.SetActive(false);
				}
			}
		}

		private void CacheVanillaPersistentPinUi(Minimap map)
		{
			if ((Object)(object)map == (Object)null)
			{
				return;
			}
			int count = _vanillaPinUiOriginalActive.Count;
			List<GameObject> list = new List<GameObject>();
			for (int i = 0; i < VanillaSelectedIconFields.Length; i++)
			{
				FieldInfo fieldInfo = VanillaSelectedIconFields[i];
				if (fieldInfo == null)
				{
					continue;
				}
				object value = null;
				try
				{
					value = fieldInfo.GetValue(map);
				}
				catch
				{
				}
				GameObject unityGameObject = GetUnityGameObject(value);
				if ((Object)(object)unityGameObject == (Object)null)
				{
					continue;
				}
				GameObject val = FindVanillaPinControlRoot(unityGameObject);
				if ((Object)(object)val != (Object)null)
				{
					RememberVanillaPinUiObject(val);
					if (!list.Contains(val))
					{
						list.Add(val);
					}
				}
			}
			GameObject largeMapUiRoot = GetLargeMapUiRoot(map);
			if ((Object)(object)largeMapUiRoot != (Object)null)
			{
				CacheOldPersistentPinHintLabels(largeMapUiRoot);
				CacheBottomMouseHintGroup(largeMapUiRoot);
			}
			CachePersistentPinPanelChrome(list);
			CachePersistentPanelMouseGlyphs();
			CacheBottomMouseHintItemsGlobal();
			_vanillaPinUiCacheBuilt = _vanillaPinUiOriginalActive.Count > count || _vanillaPinUiOriginalActive.Count > 0;
		}

		internal bool TryGetPersistentPinPanelGuiRect(out Rect rect)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			rect = default(Rect);
			if ((Object)(object)_persistentPinPanel == (Object)null || !_persistentPinPanel.activeInHierarchy)
			{
				return false;
			}
			RectTransform component = _persistentPinPanel.GetComponent<RectTransform>();
			return TryGetGuiRect(component, out rect);
		}

		private void CachePersistentPinPanelChrome(List<GameObject> selectorRoots)
		{
			//IL_012f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01de: Unknown result type (might be due to invalid IL or missing references)
			//IL_020b: Unknown result type (might be due to invalid IL or missing references)
			//IL_020d: Unknown result type (might be due to invalid IL or missing references)
			//IL_05dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_04e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0389: Unknown result type (might be due to invalid IL or missing references)
			if (((Object)(object)_persistentPinPanel != (Object)null && _persistentPinPanel.activeInHierarchy) || selectorRoots == null || selectorRoots.Count == 0)
			{
				return;
			}
			Dictionary<GameObject, Rect> dictionary = new Dictionary<GameObject, Rect>();
			for (int i = 0; i < selectorRoots.Count; i++)
			{
				GameObject val = selectorRoots[i];
				if ((Object)(object)val == (Object)null)
				{
					continue;
				}
				Transform val2 = val.transform;
				int num = 0;
				while ((Object)(object)val2 != (Object)null && num < 8)
				{
					GameObject gameObject = ((Component)val2).gameObject;
					RectTransform component = gameObject.GetComponent<RectTransform>();
					if ((Object)(object)component != (Object)null && (Object)(object)gameObject.GetComponent<Image>() != (Object)null && TryGetGuiRect(component, out var rect) && ((Rect)(ref rect)).width >= 42f && ((Rect)(ref rect)).width <= 150f && ((Rect)(ref rect)).height >= 100f && ((Rect)(ref rect)).height <= 420f && ((Rect)(ref rect)).xMin >= (float)Screen.width * 0.55f && ((Rect)(ref rect)).xMax <= (float)Screen.width + 8f)
					{
						dictionary[gameObject] = rect;
					}
					val2 = val2.parent;
					num++;
				}
			}
			GameObject val3 = null;
			Rect val4 = default(Rect);
			int num2 = 0;
			float num3 = float.MinValue;
			foreach (KeyValuePair<GameObject, Rect> item in dictionary)
			{
				GameObject key = item.Key;
				if ((Object)(object)key == (Object)null || !key.activeInHierarchy)
				{
					continue;
				}
				int num4 = 0;
				for (int j = 0; j < selectorRoots.Count; j++)
				{
					GameObject val5 = selectorRoots[j];
					if (!((Object)(object)val5 == (Object)null))
					{
						Transform transform = val5.transform;
						if ((Object)(object)transform == (Object)(object)key.transform || transform.IsChildOf(key.transform))
						{
							num4++;
						}
					}
				}
				if (num4 >= 3)
				{
					Rect value = item.Value;
					float num5 = (float)num4 * 1000f + ((Rect)(ref value)).height - ((Rect)(ref value)).width * 0.25f;
					if (num5 > num3)
					{
						val3 = key;
						val4 = value;
						num2 = num4;
						num3 = num5;
					}
				}
			}
			if ((Object)(object)val3 == (Object)null)
			{
				Image[] array = Resources.FindObjectsOfTypeAll<Image>();
				Rect val8 = default(Rect);
				foreach (Image val6 in array)
				{
					if ((Object)(object)val6 == (Object)null || (Object)(object)((Component)val6).gameObject == (Object)null || !((Component)val6).gameObject.activeInHierarchy || !TryGetGuiRect(((Graphic)val6).rectTransform, out var rect2) || ((Rect)(ref rect2)).width < 42f || ((Rect)(ref rect2)).width > 150f || ((Rect)(ref rect2)).height < 100f || ((Rect)(ref rect2)).height > 420f || ((Rect)(ref rect2)).xMin < (float)Screen.width * 0.55f || ((Rect)(ref rect2)).xMax > (float)Screen.width + 8f)
					{
						continue;
					}
					int num6 = 0;
					for (int l = 0; l < selectorRoots.Count; l++)
					{
						GameObject val7 = selectorRoots[l];
						if ((Object)(object)val7 == (Object)null)
						{
							continue;
						}
						RectTransform component2 = val7.GetComponent<RectTransform>();
						if (!((Object)(object)component2 == (Object)null) && TryGetGuiRect(component2, out var rect3))
						{
							((Rect)(ref val8))..ctor(((Rect)(ref rect2)).x - 12f, ((Rect)(ref rect2)).y - 12f, ((Rect)(ref rect2)).width + 24f, ((Rect)(ref rect2)).height + 24f);
							if (((Rect)(ref val8)).Contains(((Rect)(ref rect3)).center))
							{
								num6++;
							}
						}
					}
					if (num6 >= 3)
					{
						float num7 = (float)num6 * 1000f + ((Rect)(ref rect2)).height - ((Rect)(ref rect2)).width * 0.25f;
						if (num7 > num3)
						{
							val3 = ((Component)val6).gameObject;
							val4 = rect2;
							num2 = num6;
							num3 = num7;
						}
					}
				}
			}
			if ((Object)(object)val3 == (Object)null)
			{
				return;
			}
			_persistentPinPanel = val3;
			Image[] array2 = Resources.FindObjectsOfTypeAll<Image>();
			GameObject val9 = null;
			float num8 = float.MaxValue;
			foreach (Image val10 in array2)
			{
				if ((Object)(object)val10 == (Object)null || (Object)(object)((Component)val10).gameObject == (Object)null || !((Component)val10).gameObject.activeInHierarchy || (Object)(object)((Component)val10).gameObject == (Object)(object)val3)
				{
					continue;
				}
				RectTransform rectTransform = ((Graphic)val10).rectTransform;
				if ((Object)(object)rectTransform == (Object)null || !TryGetGuiRect(rectTransform, out var rect4) || ((Rect)(ref rect4)).width < 38f || ((Rect)(ref rect4)).width > 125f || ((Rect)(ref rect4)).height < 48f || ((Rect)(ref rect4)).height > 145f)
				{
					continue;
				}
				float num9 = Mathf.Abs(((Rect)(ref rect4)).center.x - ((Rect)(ref val4)).center.x);
				float num10 = Mathf.Abs(((Rect)(ref rect4)).xMax - ((Rect)(ref val4)).xMax);
				float num11 = ((Rect)(ref val4)).yMin - ((Rect)(ref rect4)).yMax;
				if (!(num9 > 24f) && !(num10 > 24f) && !(num11 < -4f) && !(num11 > 90f))
				{
					float num12 = num11 + num9 + num10;
					if (num12 < num8)
					{
						val9 = ((Component)val10).gameObject;
						num8 = num12;
					}
				}
			}
			if ((Object)(object)val9 != (Object)null)
			{
				RememberVanillaPinUiObject(val9);
			}
			if (_config.DebugLogging.Value)
			{
				_log.LogDebug((object)("Wayfinder persistent panel: " + ((Object)val3).name + " descendants=" + num2 + " rect=" + val4));
			}
		}

		private void CachePersistentPanelMouseGlyphs()
		{
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_persistentPinPanel == (Object)null || !_persistentPinPanel.activeInHierarchy)
			{
				return;
			}
			RectTransform component = _persistentPinPanel.GetComponent<RectTransform>();
			if ((Object)(object)component == (Object)null || !TryGetGuiRect(component, out var rect))
			{
				return;
			}
			int num = CacheExactPersistentPanelMouseGlyphs();
			if (num >= 2)
			{
				return;
			}
			CacheUiInputHintMouseKeyboardGlyphs(rect);
			Graphic[] array = Resources.FindObjectsOfTypeAll<Graphic>();
			foreach (Graphic val in array)
			{
				if (!((Object)(object)val == (Object)null) && !((Object)(object)((Component)val).gameObject == (Object)null))
				{
					TryCachePersistentPanelMouseGlyphObject(((Component)val).gameObject, rect);
				}
			}
			CanvasRenderer[] array2 = Resources.FindObjectsOfTypeAll<CanvasRenderer>();
			foreach (CanvasRenderer val2 in array2)
			{
				if (!((Object)(object)val2 == (Object)null) && !((Object)(object)((Component)val2).gameObject == (Object)null) && !((Object)(object)((Component)val2).gameObject.GetComponent<Graphic>() != (Object)null))
				{
					TryCachePersistentPanelMouseGlyphObject(((Component)val2).gameObject, rect);
				}
			}
		}

		private void DumpPersistentPanelDiagnostics(Rect panelRect)
		{
			//IL_0116: Unknown result type (might be due to invalid IL or missing references)
			//IL_0129: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_021b: Unknown result type (might be due to invalid IL or missing references)
			if (_didDumpPersistentPanelDiagnostics || Time.unscaledTime < _nextPersistentPanelDiagnosticAttemptTime)
			{
				return;
			}
			_nextPersistentPanelDiagnosticAttemptTime = Time.unscaledTime + 1f;
			try
			{
				Rect val = default(Rect);
				((Rect)(ref val))..ctor(((Rect)(ref panelRect)).xMin - 180f, ((Rect)(ref panelRect)).yMin - 120f, ((Rect)(ref panelRect)).width + 240f, ((Rect)(ref panelRect)).height + 240f);
				RectTransform[] array = Resources.FindObjectsOfTypeAll<RectTransform>();
				List<RectTransform> list = new List<RectTransform>();
				foreach (RectTransform val2 in array)
				{
					if (!((Object)(object)val2 == (Object)null) && !((Object)(object)((Component)val2).gameObject == (Object)null) && TryGetGuiRect(val2, out var rect) && (((Rect)(ref val)).Overlaps(rect, true) || ((Rect)(ref val)).Contains(((Rect)(ref rect)).center)))
					{
						list.Add(val2);
					}
				}
				list.Sort(delegate(RectTransform a, RectTransform b)
				{
					//IL_0002: Unknown result type (might be due to invalid IL or missing references)
					//IL_000a: Unknown result type (might be due to invalid IL or missing references)
					Rect rect3 = default(Rect);
					Rect rect4 = default(Rect);
					bool flag = (Object)(object)a != (Object)null && TryGetGuiRect(a, out rect3);
					bool flag2 = (Object)(object)b != (Object)null && TryGetGuiRect(b, out rect4);
					if (!flag && !flag2)
					{
						return 0;
					}
					if (!flag)
					{
						return 1;
					}
					if (!flag2)
					{
						return -1;
					}
					int num2 = ((Rect)(ref rect3)).yMin.CompareTo(((Rect)(ref rect4)).yMin);
					return (num2 != 0) ? num2 : ((Rect)(ref rect3)).xMin.CompareTo(((Rect)(ref rect4)).xMin);
				});
				_log.LogWarning((object)"[JW UI DIAG 1.33.10] ===== BEGIN RIGHT PANEL DUMP =====");
				_log.LogWarning((object)string.Concat("[JW UI DIAG 1.33.10] panel=", panelRect, " probe=", val, " candidates=", list.Count));
				for (int num = 0; num < list.Count; num++)
				{
					RectTransform val3 = list[num];
					if (!((Object)(object)val3 == (Object)null) && !((Object)(object)((Component)val3).gameObject == (Object)null))
					{
						GameObject gameObject = ((Component)val3).gameObject;
						if (TryGetGuiRect(val3, out var rect2))
						{
							string diagnosticComponentSummary = GetDiagnosticComponentSummary(gameObject);
							_log.LogWarning((object)string.Concat("[JW UI DIAG 1.33.10] OBJ ", num, " name=\"", ((Object)gameObject).name, "\" activeSelf=", gameObject.activeSelf, " activeHierarchy=", gameObject.activeInHierarchy, " rect=", rect2, " path=\"", GetDiagnosticHierarchyPath(gameObject.transform), "\" components=[", diagnosticComponentSummary, "]"));
							LogDiagnosticSpecialComponents(gameObject);
						}
					}
				}
				_log.LogWarning((object)"[JW UI DIAG 1.33.10] ===== END RIGHT PANEL DUMP =====");
				_didDumpPersistentPanelDiagnostics = true;
			}
			catch (Exception ex)
			{
				_log.LogWarning((object)("[JW UI DIAG 1.33.10] dump failed: " + ex));
			}
		}

		private static string GetDiagnosticHierarchyPath(Transform transform)
		{
			if ((Object)(object)transform == (Object)null)
			{
				return "<null>";
			}
			List<string> list = new List<string>();
			Transform val = transform;
			int num = 0;
			while ((Object)(object)val != (Object)null && num < 32)
			{
				list.Add(((Object)(object)((Component)val).gameObject != (Object)null) ? ((Object)((Component)val).gameObject).name : "<null>");
				val = val.parent;
				num++;
			}
			list.Reverse();
			return string.Join("/", list.ToArray());
		}

		private static string GetDiagnosticComponentSummary(GameObject gameObject)
		{
			if ((Object)(object)gameObject == (Object)null)
			{
				return string.Empty;
			}
			Component[] array = null;
			try
			{
				array = gameObject.GetComponents<Component>();
			}
			catch
			{
				return "<GetComponents failed>";
			}
			if (array == null || array.Length == 0)
			{
				return string.Empty;
			}
			List<string> list = new List<string>();
			foreach (Component val in array)
			{
				if ((Object)(object)val == (Object)null)
				{
					list.Add("<missing-script>");
					continue;
				}
				Type type = ((object)val).GetType();
				list.Add((type != null) ? type.FullName : ((object)val).GetType().Name);
			}
			return string.Join(", ", list.ToArray());
		}

		private void LogDiagnosticSpecialComponents(GameObject gameObject)
		{
			if ((Object)(object)gameObject == (Object)null)
			{
				return;
			}
			Component[] array = null;
			try
			{
				array = gameObject.GetComponents<Component>();
			}
			catch
			{
				return;
			}
			if (array == null)
			{
				return;
			}
			foreach (Component val in array)
			{
				if ((Object)(object)val == (Object)null)
				{
					continue;
				}
				Type type = ((object)val).GetType();
				if (!(type == null))
				{
					string text = type.Name ?? string.Empty;
					if (text.IndexOf("UIInputHint", StringComparison.OrdinalIgnoreCase) >= 0 || text.IndexOf("InputLayoutElement", StringComparison.OrdinalIgnoreCase) >= 0 || text.IndexOf("UIInputHandler", StringComparison.OrdinalIgnoreCase) >= 0)
					{
						_log.LogWarning((object)("[JW UI DIAG 1.33.10]   SPECIAL type=" + type.FullName + " fields={" + GetDiagnosticFieldSummary(val, type) + "}"));
					}
				}
			}
			Image component = gameObject.GetComponent<Image>();
			if ((Object)(object)component != (Object)null)
			{
				string text2 = (((Object)(object)component.sprite != (Object)null) ? ((Object)component.sprite).name : "<null>");
				string text3 = (((Object)(object)((Graphic)component).mainTexture != (Object)null) ? ((Object)((Graphic)component).mainTexture).name : "<null>");
				_log.LogWarning((object)("[JW UI DIAG 1.33.10]   IMAGE sprite=\"" + text2 + "\" texture=\"" + text3 + "\" enabled=" + ((Behaviour)component).enabled + " raycast=" + ((Graphic)component).raycastTarget));
			}
			RawImage component2 = gameObject.GetComponent<RawImage>();
			if ((Object)(object)component2 != (Object)null)
			{
				string text4 = (((Object)(object)component2.texture != (Object)null) ? ((Object)component2.texture).name : "<null>");
				_log.LogWarning((object)("[JW UI DIAG 1.33.10]   RAWIMAGE texture=\"" + text4 + "\" enabled=" + ((Behaviour)component2).enabled + " raycast=" + ((Graphic)component2).raycastTarget));
			}
			TMP_Text component3 = gameObject.GetComponent<TMP_Text>();
			if ((Object)(object)component3 != (Object)null)
			{
				string text5 = component3.text ?? string.Empty;
				text5 = text5.Replace("\r", " ").Replace("\n", " ");
				_log.LogWarning((object)("[JW UI DIAG 1.33.10]   TMP text=\"" + text5 + "\" enabled=" + ((Behaviour)component3).enabled));
			}
		}

		private static string GetDiagnosticFieldSummary(object instance, Type type)
		{
			if (instance == null || type == null)
			{
				return string.Empty;
			}
			FieldInfo[] array = null;
			try
			{
				array = type.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			}
			catch
			{
				return "<field reflection failed>";
			}
			if (array == null || array.Length == 0)
			{
				return string.Empty;
			}
			List<string> list = new List<string>();
			foreach (FieldInfo fieldInfo in array)
			{
				if (!(fieldInfo == null))
				{
					object obj2 = null;
					try
					{
						obj2 = fieldInfo.GetValue(instance);
					}
					catch
					{
						list.Add(fieldInfo.Name + "=<unreadable>");
						continue;
					}
					list.Add(fieldInfo.Name + "=" + GetDiagnosticValueSummary(obj2));
				}
			}
			return string.Join(", ", list.ToArray());
		}

		private static string GetDiagnosticValueSummary(object value)
		{
			if (value == null)
			{
				return "<null>";
			}
			Object val = (Object)((value is Object) ? value : null);
			if (val != (Object)null)
			{
				Component val2 = (Component)(object)((val is Component) ? val : null);
				if ((Object)(object)val2 != (Object)null && (Object)(object)val2.gameObject != (Object)null)
				{
					return ((object)val).GetType().Name + "(\"" + ((Object)val2.gameObject).name + "\")";
				}
				GameObject val3 = (GameObject)(object)((val is GameObject) ? val : null);
				if ((Object)(object)val3 != (Object)null)
				{
					return "GameObject(\"" + ((Object)val3).name + "\")";
				}
				return ((object)val).GetType().Name + "(\"" + val.name + "\")";
			}
			string text = value.ToString();
			if (text == null)
			{
				return "<null-string>";
			}
			text = text.Replace("\r", " ").Replace("\n", " ");
			if (text.Length > 180)
			{
				text = text.Substring(0, 180) + "...";
			}
			return text;
		}

		private int CacheExactPersistentPanelMouseGlyphs()
		{
			if ((Object)(object)_persistentPinPanel == (Object)null)
			{
				return 0;
			}
			Transform transform = _persistentPinPanel.transform;
			if ((Object)(object)transform == (Object)null)
			{
				return 0;
			}
			int num = 0;
			string[] array = new string[2] { "iconhints/keyboardhints/mouse1", "iconhints/keyboardhints/mouse2" };
			for (int i = 0; i < array.Length; i++)
			{
				Transform val = transform.Find(array[i]);
				if (!((Object)(object)val == (Object)null) && !((Object)(object)((Component)val).gameObject == (Object)null))
				{
					GameObject gameObject = ((Component)val).gameObject;
					num++;
					RememberVanillaPinUiObject(gameObject);
					if (gameObject.activeSelf)
					{
						gameObject.SetActive(false);
					}
					if (_config.DebugLogging.Value)
					{
						Image component = gameObject.GetComponent<Image>();
						string text = (((Object)(object)component != (Object)null && (Object)(object)component.sprite != (Object)null) ? ((Object)component.sprite).name : "<null>");
						_log.LogDebug((object)("Wayfinder hid exact persistent map mouse glyph: " + array[i] + " sprite=" + text));
					}
				}
			}
			return num;
		}

		private void CacheUiInputHintMouseKeyboardGlyphs(Rect panelRect)
		{
			//IL_0138: Unknown result type (might be due to invalid IL or missing references)
			//IL_0156: 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_01da: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ee: Unknown result type (might be due to invalid IL or missing references)
			if (UiInputHintType == null || UiInputHintMouseKeyboardField == null)
			{
				return;
			}
			MonoBehaviour[] array = null;
			try
			{
				array = Resources.FindObjectsOfTypeAll<MonoBehaviour>();
			}
			catch
			{
				return;
			}
			if (array == null)
			{
				return;
			}
			foreach (MonoBehaviour val in array)
			{
				if ((Object)(object)val == (Object)null || (Object)(object)((Component)val).gameObject == (Object)null || !((Component)val).gameObject.activeInHierarchy || !UiInputHintType.IsInstanceOfType(val))
				{
					continue;
				}
				Component val2 = (Component)(object)val;
				object value = null;
				try
				{
					value = UiInputHintMouseKeyboardField.GetValue(val2);
				}
				catch
				{
				}
				GameObject unityGameObject = GetUnityGameObject(value);
				if ((Object)(object)unityGameObject == (Object)null || !unityGameObject.activeInHierarchy || IsPartOfVisiblePlayersControl(unityGameObject))
				{
					continue;
				}
				RectTransform component = unityGameObject.GetComponent<RectTransform>();
				if ((Object)(object)component == (Object)null || !TryGetGuiRect(component, out var rect))
				{
					continue;
				}
				float num = ((Rect)(ref panelRect)).xMin - ((Rect)(ref rect)).xMax;
				float num2 = ((Rect)(ref panelRect)).yMin - 24f;
				float num3 = ((Rect)(ref panelRect)).yMin + Mathf.Min(170f, ((Rect)(ref panelRect)).height * 0.58f);
				if (!(num < -14f) && !(num > 70f) && !(((Rect)(ref rect)).center.x >= ((Rect)(ref panelRect)).xMin + 4f) && !(((Rect)(ref rect)).center.y < num2) && !(((Rect)(ref rect)).center.y > num3))
				{
					RememberVanillaPinUiObject(unityGameObject);
					if (_config.DebugLogging.Value)
					{
						_log.LogDebug((object)string.Concat("Wayfinder hid UIInputHint mouse/keyboard glyph: owner=", ((Object)val2.gameObject).name, " target=", ((Object)unityGameObject).name, " rect=", rect, " panel=", panelRect));
					}
				}
			}
		}

		private void TryCachePersistentPanelMouseGlyphObject(GameObject gameObject, Rect panelRect)
		{
			//IL_00d2: 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_012e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0183: Unknown result type (might be due to invalid IL or missing references)
			//IL_0196: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)gameObject == (Object)null || !gameObject.activeInHierarchy || (Object)(object)gameObject == (Object)(object)_persistentPinPanel)
			{
				return;
			}
			Transform transform = gameObject.transform;
			if ((Object)(object)transform == (Object)null || ((Object)(object)_persistentPinPanel != (Object)null && (Object)(object)transform == (Object)(object)_persistentPinPanel.transform) || IsPartOfVisiblePlayersControl(gameObject))
			{
				return;
			}
			RectTransform component = gameObject.GetComponent<RectTransform>();
			if ((Object)(object)component == (Object)null || !TryGetGuiRect(component, out var rect) || ((Rect)(ref rect)).width < 2f || ((Rect)(ref rect)).width > 78f || ((Rect)(ref rect)).height < 2f || ((Rect)(ref rect)).height > 78f)
			{
				return;
			}
			float num = ((Rect)(ref panelRect)).xMin - ((Rect)(ref rect)).xMax;
			if (num < -10f || num > 58f || ((Rect)(ref rect)).center.x >= ((Rect)(ref panelRect)).xMin + 2f)
			{
				return;
			}
			float num2 = ((Rect)(ref panelRect)).yMin - 18f;
			float num3 = ((Rect)(ref panelRect)).yMin + Mathf.Min(155f, ((Rect)(ref panelRect)).height * 0.52f);
			if (!(((Rect)(ref rect)).center.y < num2) && !(((Rect)(ref rect)).center.y > num3))
			{
				RememberVanillaPinUiObject(gameObject);
				if (_config.DebugLogging.Value)
				{
					_log.LogDebug((object)string.Concat("Wayfinder hid orphaned map mouse glyph candidate: ", ((Object)gameObject).name, " rect=", rect, " panel=", panelRect));
				}
			}
		}

		private static bool IsPartOfVisiblePlayersControl(GameObject gameObject)
		{
			if ((Object)(object)gameObject == (Object)null)
			{
				return false;
			}
			Transform val = gameObject.transform;
			int num = 0;
			while ((Object)(object)val != (Object)null && num < 6)
			{
				if (ContainsVisiblePlayersText(((Component)val).gameObject))
				{
					return true;
				}
				val = val.parent;
				num++;
			}
			return false;
		}

		private void CacheBottomMouseHintItemsGlobal()
		{
			TMP_Text[] array = Resources.FindObjectsOfTypeAll<TMP_Text>();
			foreach (TMP_Text val in array)
			{
				if (!((Object)(object)val == (Object)null) && !((Object)(object)((Component)val).gameObject == (Object)null) && ((Component)val).gameObject.activeInHierarchy)
				{
					CacheBottomMouseHintItem(((Component)val).gameObject, NormalizeUiText(val.text));
				}
			}
			Text[] array2 = Resources.FindObjectsOfTypeAll<Text>();
			foreach (Text val2 in array2)
			{
				if (!((Object)(object)val2 == (Object)null) && !((Object)(object)((Component)val2).gameObject == (Object)null) && ((Component)val2).gameObject.activeInHierarchy)
				{
					CacheBottomMouseHintItem(((Component)val2).gameObject, NormalizeUiText(val2.text));
				}
			}
		}

		private void CacheBottomMouseHintItem(GameObject labelObject, string text)
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)labelObject == (Object)null || !IsBottomMouseHintText(text))
			{
				return;
			}
			RectTransform component = labelObject.GetComponent<RectTransform>();
			if ((Object)(object)component != (Object)null && TryGetGuiRect(component, out var rect) && ((Rect)(ref rect)).center.y < (float)Screen.height * 0.62f)
			{
				return;
			}
			Transform val = labelObject.transform;
			GameObject val2 = null;
			int num = 0;
			while ((Object)(object)val != (Object)null && num < 5)
			{
				Transform parent = val.parent;
				if ((Object)(object)parent == (Object)null)
				{
					break;
				}
				GameObject gameObject = ((Component)parent).gameObject;
				if (ContainsVisiblePlayersText(gameObject) || CountBottomMouseHintTexts(gameObject) > 1)
				{
					val2 = gameObject;
					break;
				}
				RectTransform component2 = gameObject.GetComponent<RectTransform>();
				if ((Object)(object)component2 != (Object)null && TryGetGuiRect(component2, out var rect2) && (((Rect)(ref rect2)).width > 260f || ((Rect)(ref rect2)).height > 90f))
				{
					break;
				}
				val = parent;
				num++;
			}
			if ((Object)(object)val != (Object)null && (Object)(object)((Component)val).gameObject != (Object)null)
			{
				RememberVanillaPinUiObject(((Component)val).gameObject);
			}
			if ((Object)(object)val2 != (Object)null)
			{
				CacheNearestMouseHintImage(labelObject, val2);
			}
		}

		private void CacheNearestMouseHintImage(GameObject labelObject, GameObject sharedHintRoot)
		{
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_010d: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)labelObject == (Object)null || (Object)(object)sharedHintRoot == (Object)null)
			{
				return;
			}
			RectTransform component = labelObject.GetComponent<RectTransform>();
			if ((Object)(object)component == (Object)null || !TryGetGuiRect(component, out var rect))
			{
				return;
			}
			Image[] componentsInChildren = sharedHintRoot.GetComponentsInChildren<Image>(true);
			Image val = null;
			float num = float.MaxValue;
			foreach (Image val2 in componentsInChildren)
			{
				if ((Object)(object)val2 == (Object)null || (Object)(object)((Component)val2).gameObject == (Object)null || !((Component)val2).gameObject.activeInHierarchy || ContainsVisiblePlayersText(((Component)val2).gameObject) || !TryGetGuiRect(((Graphic)val2).rectTransform, out var rect2) || ((Rect)(ref rect2)).width < 8f || ((Rect)(ref rect2)).width > 46f || ((Rect)(ref rect2)).height < 8f || ((Rect)(ref rect2)).height > 46f)
				{
					continue;
				}
				float num2 = Mathf.Abs(((Rect)(ref rect2)).center.x - ((Rect)(ref rect)).center.x);
				float num3 = Mathf.Abs(((Rect)(ref rect2)).center.y - ((Rect)(ref rect)).center.y);
				if (!(num2 > 62f) && !(num3 > 28f))
				{
					float num4 = num2 + num3 * 2f;
					if (num4 < num)
					{
						val = val2;
						num = num4;
					}
				}
			}
			if ((Object)(object)val != (Object)null)
			{
				RememberVanillaPinUiObject(((Component)val).gameObject);
			}
		}

		private static bool IsBottomMouseHintText(string text)
		{
			if (string.IsNullOrEmpty(text))
			{
				return false;
			}
			if (!text.Contains("addpin") && !text.Contains("crossoffpin") && !text.Contains("crossoff") && !text.Contains("crossoutpin") && !text.Contains("crossout") && !text.Contains("removepin"))
			{
				return string.Equals(text, "ping", StringComparison.Ordinal);
			}
			return true;
		}

		private static int CountBottomMouseHintTexts(GameObject root)
		{
			if ((Object)(object)root == (Object)null)
			{
				return 0;
			}
			int num = 0;
			TMP_Text[] componentsInChildren = root.GetComponentsInChildren<TMP_Text>(true);
			foreach (TMP_Text val in componentsInChildren)
			{
				if ((Object)(object)val != (Object)null && IsBottomMouseHintText(NormalizeUiText(val.text)))
				{
					num++;
				}
			}
			Text[] componentsInChildren2 = root.GetComponentsInChildren<Text>(true);
			foreach (Text val2 in componentsInChildren2)
			{
				if ((Object)(object)val2 != (Object)null && IsBottomMouseHintText(NormalizeUiText(val2.text)))
				{
					num++;
				}
			}
			return num;
		}

		private static bool TryGetGuiRect(RectTransform rectTransform, out Rect rect)
		{
			//IL_0001: 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_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: 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_0086: 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_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_010f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0114: Unknown result type (might be due to invalid IL or missing references)
			rect = default(Rect);
			if ((Object)(object)rectTransform == (Object)null)
			{
				return false;
			}
			Vector3[] array = (Vector3[])(object)new Vector3[4];
			rectTransform.GetWorldCorners(array);
			Canvas componentInParent = ((Component)rectTransform).GetComponentInParent<Canvas>();
			Camera val = null;
			if ((Object)(object)componentInParent != (Object)null && (int)componentInParent.renderMode != 0)
			{
				val = componentInParent.worldCamera;
			}
			Vector2 val2 = RectTransformUtility.WorldToScreenPoint(val, array[0]);
			float num = val2.x;
			float num2 = val2.x;
			float num3 = val2.y;
			float num4 = val2.y;
			for (int i = 1; i < 4; i++)
			{
				Vector2 val3 = RectTransformUtility.WorldToScreenPoint(val, array[i]);
				num = Mathf.Min(num, val3.x);
				num2 = Mathf.Max(num2, val3.x);
				num3 = Mathf.Min(num3, val3.y);
				num4 = Mathf.Max(num4, val3.y);
			}
			float num5 = num2 - num;
			float num6 = num4 - num3;
			if (num5 <= 0.5f || num6 <= 0.5f)
			{
				return false;
			}
			rect = new Rect(num, (float)Screen.height - num4, num5, num6);
			return true;
		}

		private static GameObject FindVanillaPinControlRoot(GameObject selectedIcon)
		{
			if ((Object)(object)selectedIcon == (Object)null)
			{
				return null;
			}
			Transform transform = selectedIcon.transform;
			if ((Object)(object)transform == (Object)null)
			{
				return selectedIcon;
			}
			if (UiInputHandlerType != null)
			{
				try
				{
					Component componentInParent = ((Component)transform).GetComponentInParent(UiInputHandlerType);
					if ((Object)(object)componentInParent != (Object)null && (Object)(object)componentInParent.gameObject != (Object)null)
					{
						return componentInParent.gameObject;
					}
				}
				catch
				{
				}
			}
			Button componentInParent2 = selectedIcon.GetComponentInParent<Button>();
			if ((Object)(object)componentInParent2 != (Object)null)
			{
				return ((Component)componentInParent2).gameObject;
			}
			Selectable componentInParent3 = selectedIcon.GetComponentInParent<Selectable>();
			if ((Object)(object)componentInParent3 != (Object)null)
			{
				return ((Component)componentInParent3).gameObject;
			}
			if ((Object)(object)transform.parent != (Object)null)
			{
				return ((Component)transform.parent).gameObject;
			}
			return selectedIcon;
		}

		private static GameObject GetLargeMapUiRoot(Minimap map)
		{
			if ((Object)(object)map == (Object)null)
			{
				return null;
			}
			try
			{
				if (MapLargeField != null)
				{
					GameObject unityGameObject = GetUnityGameObject(MapLargeField.GetValue(map));
					if ((Object)(object)unityGameObject != (Object)null)
					{
						return unityGameObject;
					}
				}
			}
			catch
			{
			}
			try
			{
				if (LargeRootField != null)
				{
					GameObject unityGameObject2 = GetUnityGameObject(LargeRootField.GetValue(map));
					if ((Object)(object)unityGameObject2 != (Object)null)
					{
						return unityGameObject2;
					}
				}
			}
			catch
			{
			}
			return null;
		}

		private void CacheOldPersistentPinHintLabels(GameObject largeRoot)
		{
			if ((Object)(object)largeRoot == (Object)null)
			{
				return;
			}
			TMP_Text[] componentsInChildren = largeRoot.GetComponentsInChildren<TMP_Text>(true);
			foreach (TMP_Text val in componentsInChildren)
			{
				if (!((Object)(object)val == (Object)null) && !((Object)(object)((Component)val).gameObject == (Object)null))
				{
					string text = NormalizeUiText(val.text);
					if (ShouldHideOldPersistentPinHint(text))
					{
						RememberVanillaPinUiObject(((Component)val).gameObject);
					}
				}
			}
			Text[] componentsInChildren2 = largeRoot.GetComponentsInChildren<Text>(true);
			foreach (Text val2 in componentsInChildren2)
			{
				if (!((Object)(object)val2 == (Object)null) && !((Object)(object)((Component)val2).gameObject == (Object)null))
				{
					string text2 = NormalizeUiText(val2.text);
					if (ShouldHideOldPersistentPinHint(text2))
					{
						RememberVanillaPinUiObject(((Component)val2).gameObject);
					}
				}
			}
		}

		private static bool ShouldHideOldPersistentPinHint(string text)
		{
			if (string.IsNullOrEmpty(text))
			{
				return false;
			}
			if (text.Contains("visible") || text.Contains("player"))
			{
				return false;
			}
			if (!text.Contains("addpin") && !text.Contains("removepin") && !text.Contains("crossoff") && !text.Contains("crossout"))
			{
				return text.Contains("selectpin");
			}
			return true;
		}

		private void CacheBottomMouseHintGroup(GameObject largeRoot)
		{
			if ((Object)(object)largeRoot == (Object)null)
			{
				return;
			}
			GameObject val = FindLabelGameObject(largeRoot, "ping");
			if ((Object)(object)val == (Object)null)
			{
				return;
			}
			Transform transform = largeRoot.transform;
			Transform val2 = val.transform;
			Transform val3 = val2;
			int num = 0;
			while ((Object)(object)val2 != (Object)null && (Object)(object)val2 != (Object)(object)transform && num < 6)
			{
				Transform parent = val2.parent;
				if ((Object)(object)parent == (Object)null || ContainsVisiblePlayersText(((Component)parent).gameObject))
				{
					break;
				}
				val3 = parent;
				val2 = parent;
				num++;
			}
			if ((Object)(object)val3 != (Object)null && (Object)(object)((Component)val3).gameObject != (Object)null)
			{
				RememberVanillaPinUiObject(((Component)val3).gameObject);
			}
		}

		private static GameObject FindLabelGameObject(GameObject root, string normalizedExact)
		{
			if ((Object)(object)root == (Object)null || string.IsNullOrEmpty(normalizedExact))
			{
				return null;
			}
			TMP_Text[] componentsInChildren = root.GetComponentsInChildren<TMP_Text>(true);
			foreach (TMP_Text val in componentsInChildren)
			{
				if (!((Object)(object)val == (Object)null) && string.Equals(NormalizeUiText(val.text), normalizedExact, StringComparison.Ordinal))
				{
					return ((Component)val).gameObject;
				}
			}
			Text[] componentsInChildren2 = root.GetComponentsInChildren<Text>(true);
			foreach (Text val2 in componentsInChildren2)
			{
				if (!((Object)(object)val2 == (Object)null) && string.Equals(NormalizeUiText(val2.text), normalizedExact, StringComparison.Ordinal))
				{
					return ((Component)val2).gameObject;
				}
			}
			return null;
		}

		private static bool ContainsVisiblePlayersText(GameObject root)
		{
			if ((Object)(object)root == (Object)null)
			{
				return false;
			}
			TMP_Text[] componentsInChildren = root.GetComponentsInChildren<TMP_Text>(true);
			foreach (TMP_Text val in componentsInChildren)
			{
				if (!((Object)(object)val == (Object)null))
				{
					string text = NormalizeUiText(val.text);
					if (text.Contains("visible") && text.Contains("player"))
					{
						return true;
					}
				}
			}
			Text[] componentsInChildren2 = root.GetComponentsInChildren<Text>(true);
			foreach (Text val2 in componentsInChildren2)
			{
				if (!((Object)(object)val2 == (Object)null))
				{
					string text2 = NormalizeUiText(val2.text);
					if (text2.Contains("visible") && text2.Contains("player"))
					{
						return true;
					}
				}
			}
			return false;
		}

		private void RememberVanillaPinUiObject(GameObject gameObject)
		{
			if (!((Object)(object)gameObject == (Object)null) && !_vanillaPinUiOriginalActive.ContainsKey(gameObject))
			{
				_vanillaPinUiOriginalActive.Add(gameObject, gameObject.activeSelf);
			}
		}

		private void RestoreVanillaPersistentPinUi()
		{
			foreach (KeyValuePair<GameObject, bool> item in _vanillaPinUiOriginalActive)
			{
				GameObject key = item.Key;
				if ((Object)(object)key != (Object)null && key.activeSelf != item.Value)
				{
					key.SetActive(item.Value);
				}
			}
			_vanillaPinUiOriginalActive.Clear();
			_vanillaPinUiCacheBuilt = false;
			_persistentPinPanel = null;
			_didDumpPersistentPanelDiagnostics = false;
			_nextPersistentPanelDiagnosticAttemptTime = 0f;
			_nextVanillaPinUiProbeTime = 0f;
		}

		private static GameObject GetUnityGameObject(object value)
		{
			if (value == null)
			{
				return null;
			}
			GameObject val = (GameObject)((value is GameObject) ? value : null);
			if ((Object)(object)val != (Object)null)
			{
				return val;
			}
			Component val2 = (Component)((value is Component) ? value : null);
			if (!((Object)(object)val2 == (Object)null))
			{
				return val2.gameObject;
			}
			return null;
		}

		private static string NormalizeUiText(string value)
		{
			if (string.IsNullOrEmpty(value))
			{
				return string.Empty;
			}
			char[] array = new char[value.Length];
			int length = 0;
			for (int i = 0; i < value.Length; i++)
			{
				char c = char.ToLowerInvariant(value[i]);
				if (char.IsLetterOrDigit(c))
				{
					array[length++] = c;
				}
			}
			return new string(array, 0, length);
		}

		internal bool BeforeRemovePinAt(Vector3 worldPosition, float radius, ref bool result)
		{
			//IL_0064: 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_00db: 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_011a: Unknown result type (might be due to invalid IL or missing references)
			if (_internalPinRemoval || !_config.RightClickRemovesWayfinderPins.Value || _recordPins.Count == 0)
			{
				return true;
			}
			PinData val = null;
			WayfinderPinRecord wayfinderPinRecord = null;
			float num = float.MaxValue;
			foreach (KeyValuePair<PinData, WayfinderPinRecord> item in _recordsByPin)
			{
				PinData key = item.Key;
				WayfinderPinRecord value = item.Value;
				if (key != null && value != null)
				{
					float num2 = HorizontalDistance(worldPosition, key.m_pos);
					if (num2 <= radius && num2 < num)
					{
						num = num2;
						val = key;
						wayfinderPinRecord = value;
					}
				}
			}
			if (val == null || wayfinderPinRecord == null)
			{
				return true;
			}
			if ((Object)(object)_map != (Object)null && GetClosestPinMethod != null)
			{
				try
				{
					object? obj = GetClosestPinMethod.Invoke(_map, new object[3] { worldPosition, radius, true });
					PinData val2 = (PinData)((obj is PinData) ? obj : null);
					if (val2 != null && !_recordsByPin.ContainsKey(val2))
					{
						float num3 = HorizontalDistance(worldPosition, val2.m_pos);
						if (num3 < num)
						{
							return true;
						}
					}
				}
				catch
				{
				}
			}
			if (RequiresPinsPanelDeletion(wayfinderPinRecord))
			{
				result = true;
				if (_config.DebugLogging.Value)
				{
					_log.LogInfo((object)("Ignored map right-click removal for managed travel pin: " + (wayfinderPinRecord.displayName ?? wayfinderPinRecord.subtype ?? wayfinderPinRecord.id)));
				}
				return false;
			}
			_database.Remove(wayfinderPinRecord.id);
			_recordsByPin.Remove(val);
			_recordPins.Remove(wayfinderPinRecord.id);
			RemoveTransientPin(val);
			result = true;
			if (_config.DebugLogging.Value)
			{
				_log.LogInfo((object)("Right-click removed Wayfinder pin: " + (wayfinderPinRecord.displayName ?? wayfinderPinRecord.subtype ?? wayfinderPinRecord.id)));
			}
			return false;
		}

		internal bool BeforeRemovePin(PinData pin)
		{
			if (_internalPinRemoval || pin == null)
			{
				return true;
			}
			if (!_recordsByPin.TryGetValue(pin, out var value) || value == null)
			{
				return true;
			}
			if (!_config.RightClickRemovesWayfinderPins.Value)
			{
				return false;
			}
			if (RequiresPinsPanelDeletion(value))
			{
				if (_config.DebugLogging.Value)
				{
					_log.LogInfo((object)("Ignored map removal for managed travel pin: " + (value.displayName ?? value.subtype ?? value.id)));
				}
				return false;
			}
			_database.Remove(value.id);
			_recordsByPin.Remove(pin);
			_recordPins.Remove(value.id);
			if (_config.DebugLogging.Value)
			{
				_log.LogInfo((object)("Removed Wayfinder pin: " + (value.displayName ?? value.subtype ?? value.id)));
			}
			return true;
		}

		private static bool RequiresPinsPanelDeletion(WayfinderPinRecord record)
		{
			if (record != null)
			{
				if (record.category != WayfinderPinCategory.Portal)
				{
					return record.category == WayfinderPinCategory.Vehicle;
				}
				return true;
			}
			return false;
		}

		internal void DrawLargeMapNameLabels()
		{
			//IL_0296: 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_015d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0162: Unknown result type (might be due to invalid IL or missing references)
			//IL_0167: Unknown result type (might be due to invalid IL or missing references)
			//IL_0149: Unknown result type (might be due to invalid IL or missing references)
			//IL_0236: Unknown result type (might be due to invalid IL or missing references)
			//IL_023d: Unknown result type (might be due to invalid IL or missing references)
			if (!_config.Enabled.Value || (Object)(object)_map == (Object)null || !IsLargeMapOpen(_map))
			{
				return;
			}
			EnsureMapNameStyle();
			int depth = GUI.depth;
			Color color = GUI.color;
			GUI.depth = 250;
			try
			{
				Color color2 = default(Color);
				foreach (KeyValuePair<PinData, WayfinderPinRecord> item in _recordsByPin)
				{
					PinData key = item.Key;
					WayfinderPinRecord value = item.Value;
					if (key == null || value == null || (Object)(object)key.m_iconElement == (Object)null || !((Component)key.m_iconElement).gameObject.activeInHierarchy)
					{
						continue;
					}
					bool flag = value.category == WayfinderPinCategory.Portal;
					bool flag2 = value.category == WayfinderPinCategory.Vehicle;
					if ((!flag && !flag2) || (flag && !_config.ShowPortalNamesOnLargeMap.Value) || (flag2 && !_config.ShowVehicleNamesOnLargeMap.Value))
					{
						continue;
					}
					string largeMapLabel = GetLargeMapLabel(value);
					if (string.IsNullOrEmpty(largeMapLabel))
					{
						continue;
					}
					RectTransform rectTransform = ((Graphic)key.m_iconElement).rectTransform;
					if ((Object)(object)rectTransform == (Object)null)
					{
						continue;
					}
					Canvas componentInParent = ((Component)key.m_iconElement).GetComponentInParent<Canvas>();
					Camera val = null;
					if ((Object)(object)componentInParent != (Object)null && (int)componentInParent.renderMode != 0)
					{
						val = componentInParent.worldCamera;
					}
					Vector2 val2 = RectTransformUtility.WorldToScreenPoint(val, ((Transform)rectTransform).position);
					if (!(val2.x < -100f) && !(val2.x > (float)Screen.width + 100f) && !(val2.y < -100f) && !(val2.y > (float)Screen.height + 100f))
					{
						float x = val2.x;
						float num = (float)Screen.height - val2.y;
						((Color)(ref color2))..ctor(1f, 1f, 1f, 0.98f);
						if (WayfinderDynamicState.IsLastKnownVehicle(value))
						{
							color2.a *= Mathf.Clamp01(_config.LastKnownVehicleOpacity.Value);
						}
						DrawMapNameLabel(new Rect(x - 90f, num + 12f, 180f, 22f), largeMapLabel, color2);
					}
				}
			}
			catch (Exception ex)
			{
				if (_config.DebugLogging.Value)
				{
					_log.LogWarning((object)("Map name label draw failed: " + ex.Message));
				}
			}
			finally
			{
				GUI.color = color;
				GUI.depth = depth;
			}
		}

		private static string GetLargeMapLabel(WayfinderPinRecord record)
		{
			if (record == null)
			{
				return string.Empty;
			}
			if (!string.IsNullOrEmpty(record.displayName))
			{
				return record.displayName;
			}
			if (record.category == WayfinderPinCategory.Portal)
			{
				if (!string.IsNullOrEmpty(record.portalTag))
				{
					return record.portalTag;
				}
				return "Portal";
			}
			if (record.category == WayfinderPinCategory.Vehicle)
			{
				if (!string.IsNullOrEmpty(record.subtype))
				{
					string subtype = record.subtype;
					if (subtype.IndexOf("cart", StringComparison.OrdinalIgnoreCase) >= 0)
					{
						return "Cart";
					}
					if (subtype.IndexOf("raft", StringComparison.OrdinalIgnoreCase) >= 0)
					{
						return "Raft";
					}
					if (subtype.IndexOf("karve", StringComparison.OrdinalIgnoreCase) >= 0)
					{
						return "Karve";
					}
					if (subtype.IndexOf("drakkar", StringComparison.OrdinalIgnoreCase) >= 0)
					{
						return "Drakkar";
					}
					if (subtype.IndexOf("longship", StringComparison.OrdinalIgnoreCase) >= 0 || subtype.IndexOf("vikingship", StringComparison.OrdinalIgnoreCase) >= 0)
					{
						return "Longship";
					}
				}
				return "Vehicle";
			}
			return string.Empty;
		}

		private void EnsureMapNameStyle()
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Expected O, but got Unknown
			if (_mapNameStyle == null)
			{
				_mapNameStyle = new GUIStyle(GUI.skin.label);
				_mapNameStyle.alignment = (TextAnchor)1;
				_mapNameStyle.fontSize = 13;
				_mapNameStyle.fontStyle = (FontStyle)1;
				_mapNameStyle.clipping = (TextClipping)0;
			}
		}

		private void DrawMapNameLabel(Rect rect, string text, Color color)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: 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_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			if (_mapNameStyle != null && !string.IsNullOrEmpty(text))
			{
				Color color2 = GUI.color;
				GUI.color = new Color(0f, 0f, 0f, color.a * 0.95f);
				Rect val = rect;
				((Rect)(ref val)).x = ((Rect)(ref val)).x + 1f;
				((Rect)(ref val)).y = ((Rect)(ref val)).y + 1f;
				GUI.Label(val, text, _mapNameStyle);
				GUI.color = color;
				GUI.Label(rect, text, _mapNameStyle);
				GUI.color = color2;
			}
		}

		internal void ForceRefresh()
		{
			_lastRevision = -1;
			_nextVisualRefreshTime = 0f;
		}

		internal void RefreshDynamicVehiclePositions()
		{
			//IL_0040: 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)
			foreach (KeyValuePair<PinData, WayfinderPinRecord> item in _recordsByPin)
			{
				PinData key = item.Key;
				WayfinderPinRecord value = item.Value;
				if (key != null && value != null && value.category == WayfinderPinCategory.Vehicle && value.source == WayfinderPinSource.Dynamic)
				{
					key.m_pos = value.Position;
				}
			}
		}

		internal void RefreshTrackedOverlays()
		{
			foreach (KeyValuePair<PinData, WayfinderPinRecord> item in _recordsByPin)
			{
				PinData key = item.Key;
				WayfinderPinRecord value = item.Value;
				if (key != null && value != null)
				{
					SetTrackedOverlay(key, value.tracked, value.trackSlot);
				}
			}
		}

		private void SyncDatabasePins()
		{
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_map == (Object)null || _database.WorldUid == 0)
			{
				return;
			}
			HashSet<string> hashSet = new HashSet<string>();
			IReadOnlyList<WayfinderPinRecord> records = _database.Records;
			for (int i = 0; i < records.Count; i++)
			{
				WayfinderPinRecord wayfinderPinRecord = records[i];
				if (wayfinderPinRecord == null || string.IsNullOrEmpty(wayfinderPinRecord.id) || (_manager != null && !_manager.IsCategoryVisible(wayfinderPinRecord.category)))
				{
					continue;
				}
				hashSet.Add(wayfinderPinRecord.id);
				if (!_recordPins.TryGetValue(wayfinderPinRecord.id, out var value) || value == null)
				{
					value = CreateTransientPin(wayfinderPinRecord);
					if (value == null)
					{
						continue;
					}
					_recordPins[wayfinderPinRecord.id] = value;
					_recordsByPin[value] = wayfinderPinRecord;
				}
				value.m_pos = wayfinderPinRecord.Position;
				value.m_name = BuildDisplayName(wayfinderPinRecord);
				value.m_save = false;
				value.m_checked = false;
				string effectiveIconKey = WayfinderIconPolicy.GetEffectiveIconKey(wayfinderPinRecord);
				if (_icons.TryGet(effectiveIconKey, out var sprite))
				{
					value.m_icon = sprite;
				}
			}
			List<string> list = new List<string>();
			foreach (KeyValuePair<string, PinData> recordPin in _recordPins)
			{
				if (!hashSet.Contains(recordPin.Key))
				{
					list.Add(recordPin.Key);
				}
			}
			for (int j = 0; j < list.Count; j++)
			{
				string key = list[j];
				if (_recordPins.TryGetValue(key, out var value2) && value2 != null)
				{
					_recordsByPin.Remove(value2);
					RemoveTransientPin(value2);
				}
				_recordPins.Remove(key);
			}
			MarkPinUpdateRequired();
			_lastRevision = _database.Revision;
		}

		private PinData CreateTransientPin(WayfinderPinRecord record)
		{
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Expected O, but got Unknown
			//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)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_map == (Object)null || PinsField == null)
			{
				return null;
			}
			if (!(PinsField.GetValue(_map) is List<PinData> list))
			{
				return null;
			}
			string effectiveIconKey = WayfinderIconPolicy.GetEffectiveIconKey(record);
			if (!_icons.TryGet(effectiveIconKey, out var sprite))
			{
				string wayfinderFallbackKey = GetWayfinderFallbackKey(record.category);
				if (!_icons.TryGet(wayfinderFallbackKey, out sprite))
				{
					sprite = GetFallbackSprite(_map, record.category);
				}
			}
			PinData val = new PinData();
			val.m_name = BuildDisplayName(record);
			val.m_type = GetFallbackPinType(record.category);
			val.m_icon = sprite;
			val.m_pos = record.Position;
			val.m_save = false;
			val.m_ownerID = 0L;
			val.m_shouldDelete = false;
			val.m_checked = false;
			val.m_doubleSize = false;
			val.m_animate = false;
			val.m_worldSize = 0f;
			list.Add(val);
			MarkPinUpdateRequired();
			return val;
		}

		private static string GetWayfinderFallbackKey(WayfinderPinCategory category)
		{
			return category switch
			{
				WayfinderPinCategory.Resource => "wayfinder:resource", 
				WayfinderPinCategory.Creature => "wayfinder:creature", 
				WayfinderPinCategory.Boss => "wayfinder:creature", 
				WayfinderPinCategory.Dungeon => "wayfinder:dungeon", 
				WayfinderPinCategory.PointOfInterest => "wayfinder:structure", 
				WayfinderPinCategory.Spawner => "wayfinder:spawner", 
				WayfinderPinCategory.Habitat => "wayfinder:habitat", 
				WayfinderPinCategory.Sighting => "wayfinder:sighting", 
				WayfinderPinCategory.Vehicle => "wayfinder:vehicle", 
				WayfinderPinCategory.Trader => "wayfinder:trader", 
				WayfinderPinCategory.Portal => "wayfinder:portal", 
				WayfinderPinCategory.Base => "wayfinder:structure", 
				WayfinderPinCategory.Outpost => "wayfinder:outpost", 
				WayfinderPinCategory.Farm => "wayfinder:farm", 
				WayfinderPinCategory.Dock => "wayfinder:dock", 
				WayfinderPinCategory.Road => "wayfinder:road", 
				WayfinderPinCategory.Bridge => "wayfinder:bridge", 
				WayfinderPinCategory.Camp => "wayfinder:camp", 
				WayfinderPinCategory.Storage => "wayfinder:storage", 
				WayfinderPinCategory.Danger => "wayfinder:danger", 
				_ => "wayfinder:custom", 
			};
		}

		private static PinType GetFallbackPinType(WayfinderPinCategory category)
		{
			return (PinType)(category switch
			{
				WayfinderPinCategory.Dungeon => 2, 
				WayfinderPinCategory.PointOfInterest => 3, 
				WayfinderPinCategory.Trader => 6, 
				_ => 0, 
			});
		}

		private static Sprite GetFallbackSprite(Minimap map, WayfinderPinCategory category)
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)map == (Object)null || GetSpriteMethod == null)
			{
				return null;
			}
			try
			{
				object? obj = GetSpriteMethod.Invoke(map, new object[1] { GetFallbackPinType(category) });
				return (Sprite)((obj is Sprite) ? obj : null);
			}
			catch
			{
				return null;
			}
		}

		private void MarkPinUpdateRequired()
		{
			if ((Object)(object)_map != (Object)null && PinUpdateRequiredField != null)
			{
				PinUpdateRequiredField.SetValue(_map, true);
			}
		}

		private void ApplyWayfinderPinVisuals()
		{
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			foreach (KeyValuePair<PinData, WayfinderPinRecord> item in _recordsByPin)
			{
				PinData key = item.Key;
				WayfinderPinRecord value = item.Value;
				if (key == null || value == null)
				{
					continue;
				}
				string effectiveIconKey = WayfinderIconPolicy.GetEffectiveIconKey(value);
				if (_icons.TryGet(effectiveIconKey, out var sprite))
				{
					key.m_icon = sprite;
					if ((Object)(object)key.m_iconElement != (Object)null)
					{
						key.m_iconElement.sprite = sprite;
					}
				}
				if ((Object)(object)key.m_iconElement != (Object)null)
				{
					Color color = value.Color;
					if (WayfinderDynamicState.IsLastKnownVehicle(value))
					{
						color.a *= Mathf.Clamp01(_config.LastKnownVehicleOpacity.Value);
					}
					((Graphic)key.m_iconElement).color = color;
					((Transform)((Graphic)key.m_iconElement).rectTransform).localScale = Vector3.one * WayfinderIconPolicy.GetVisualScale(value, effectiveIconKey);
				}
				SetTrackedOverlay(key, value.tracked, value.trackSlot);
				SetLastKnownVehicleOverlay(key, value);
			}
		}

		private static bool IsLargeMapOpen(Minimap map)
		{
			if ((Object)(object)map == (Object)null || LargeRootField == null)
			{
				return false;
			}
			try
			{
				object? value = LargeRootField.GetValue(map);
				GameObject val = (GameObject)((value is GameObject) ? value : null);
				return (Object)(object)val != (Object)null && val.activeInHierarchy;
			}
			catch
			{
				return false;
			}
		}

		private void ApplyVanillaSpecialPinVisuals(Minimap map)
		{
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Invalid comparison between Unknown and I4
			//IL_0157: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_021e: 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)
			ApplyNativeShipMarkerVisibility(map);
			ApplyNativeTraderMarkerVisibility(map);
			if (!_config.SupersedeVanillaPinVisuals.Value || !_icons.IsBuilt || PinsField == null || !(PinsField.GetValue(map) is List<PinData> list))
			{
				return;
			}
			for (int i = 0; i < list.Count; i++)
			{
				PinData val = list[i];
				if (val == null || _recordsByPin.ContainsKey(val) || (int)val.m_type == 9)
				{
					continue;
				}
				if (GravestoneIntegration.IsNativeDeathPin(val))
				{
					if (_icons.TryGet("wayfinder:gravestone", out var sprite) && (Object)(object)sprite != (Object)null)
					{
						SetNativePinVisualVisibility(val, visible: true);
						val.m_icon = sprite;
						if ((Object)(object)val.m_iconElement != (Object)null)
						{
							val.m_iconElement.sprite = sprite;
							((Transform)((Graphic)val.m_iconElement).rectTransform).localScale = Vector3.one * 1.18f;
						}
					}
				}
				else if (IsNativeBoatPin(val) && _config.Enabled.Value && _config.TrackBoats.Value)
				{
					SetNativePinVisualVisibility(val, visible: false);
				}
				else
				{
					if ((TraderIdentity.TryFromNativePin(val, out var traderType, out var _) && _config.Enabled.Value && HasConfirmedTraderRecordNear(traderType, val.m_pos, 128f)) || !TryClassifyNativePin(val, out var category, out var iconKey))
					{
						continue;
					}
					bool flag = _manager == null || _manager.IsCategoryVisible(category);
					SetNativePinVisualVisibility(val, flag);
					if (flag && _icons.TryGet(iconKey, out var sprite2) && !((Object)(object)sprite2 == (Object)null))
					{
						val.m_icon = sprite2;
						if ((Object)(object)val.m_iconElement != (Object)null)
						{
							val.m_iconElement.sprite = sprite2;
							float num = ((iconKey == "wayfinder:dungeon") ? 1.2f : ((iconKey == "wayfinder:spawner") ? 1.18f : 1.16f));
							((Transform)((Graphic)val.m_iconElement).rectTransform).localScale = Vector3.one * num;
						}
					}
				}
			}
		}

		private void ApplyNativeTraderMarkerVisibility(Minimap map)
		{
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)map == (Object)null || PinsField == null)
			{
				return;
			}
			List<PinData> list = null;
			try
			{
				list = PinsField.GetValue(map) as List<PinData>;
			}
			catch
			{
			}
			if (list == null)
			{
				return;
			}
			bool flag = _manager == null || _manager.IsCategoryVisible(WayfinderPinCategory.Trader);
			for (int i = 0; i < list.Count; i++)
			{
				PinData val = list[i];
				if (val != null && !_recordsByPin.ContainsKey(val) && TraderIdentity.TryFromNativePin(val, out var traderType, out var _))
				{
					bool flag2 = _config.Enabled.Value && HasConfirmedTraderRecordNear(traderType, val.m_pos, 128f);
					SetNativePinVisualVisibility(val, !flag2 && flag);
				}
			}
		}

		private bool HasConfirmedTraderRecordNear(string traderType, Vector3 position, float radius)
		{
			//IL_0091: 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)
			IReadOnlyList<WayfinderPinRecord> records = _database.Records;
			if (records == null)
			{
				return false;
			}
			bool flag = string.IsNullOrEmpty(traderType) || string.Equals(traderType, "generic", StringComparison.OrdinalIgnoreCase);
			string b = (flag ? string.Empty : TraderIdentity.ConfirmedSubtype(traderType));
			float num = radius * radius;
			for (int i = 0; i < records.Count; i++)
			{
				WayfinderPinRecord wayfinderPinRecord = records[i];
				if (wayfinderPinRecord != null && wayfinderPinRecord.category == WayfinderPinCategory.Trader && !(wayfinderPinRecord.subtype ?? string.Empty).EndsWith(":candidate", StringComparison.OrdinalIgnoreCase) && (flag || string.Equals(wayfinderPinRecord.subtype, b, StringComparison.OrdinalIgnoreCase)))
				{
					float num2 = wayfinderPinRecord.Position.x - position.x;
					float num3 = wayfinderPinRecord.Position.z - position.z;
					if (num2 * num2 + num3 * num3 <= num)
					{
						return true;
					}
				}
			}
			return false;
		}

		internal void EnforceNativeShipMarkerVisibility(Minimap map)
		{
			ApplyNativeShipMarkerVisibility(map);
		}

		private void ApplyNativeShipMarkerVisibility(Minimap map)
		{
			if ((Object)(object)map == (Object)null)
			{
				return;
			}
			bool visible = !_config.Enabled.Value || !_config.TrackBoats.Value;
			object value = null;
			object value2 = null;
			try
			{
				if (LargeShipMarkerField != null)
				{
					value = LargeShipMarkerField.GetValue(map);
				}
			}
			catch
			{
			}
			try
			{
				if (SmallShipMarkerField != null)
				{
					value2 = SmallShipMarkerField.GetValue(map);
				}
			}
			catch
			{
			}
			SetShipMarkerVisible(value, visible);
			SetShipMarkerVisible(value2, visible);
		}

		private static void SetShipMarkerVisible(object value, bool visible)
		{
			if (value == null)
			{
				return;
			}
			GameObject val = (GameObject)((value is GameObject) ? value : null);
			Component val2 = (Component)((value is Component) ? value : null);
			if ((Object)(object)val == (Object)null && (Object)(object)val2 != (Object)null)
			{
				val = val2.gameObject;
			}
			if ((Object)(object)val == (Object)null)
			{
				return;
			}
			try
			{
				Graphic[] componentsInChildren = val.GetComponentsInChildren<Graphic>(true);
				if (componentsInChildren != null)
				{
					foreach (Graphic val3 in componentsInChildren)
					{
						if ((Object)(object)val3 != (Object)null)
						{
							((Behaviour)val3).enabled = visible;
						}
					}
				}
			}
			catch
			{
			}
			try
			{
				CanvasGroup[] componentsInChildren2 = val.GetComponentsInChildren<CanvasGroup>(true);
				if (componentsInChildren2 != null)
				{
					foreach (CanvasGroup val4 in componentsInChildren2)
					{
						if ((Object)(object)val4 != (Object)null)
						{
							val4.alpha = (visible ? 1f : 0f);
						}
					}
				}
			}
			catch
			{
			}
			try
			{
				val.SetActive(visible);
			}
			catch
			{
			}
		}

		private static bool IsNativeBoatPin(PinData pin)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			if (pin == null)
			{
				return false;
			}
			string text = string.Empty;
			try
			{
				text = ((object)pin.m_type).ToString();
			}
			catch
			{
			}
			string text2 = pin.m_name ?? string.Empty;
			string text3 = Normalize(text + " " + text2);
			if (!text3.Contains("ship") && !text3.Contains("boat") && !text3.Contains("karve") && !text3.Contains("longship") && !text3.Contains("drakkar"))
			{
				return text3.Contains("raft");
			}
			return true;
		}

		private bool HasNearbyDynamicBoatRecord(Vector3 position, float radius)
		{
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			IReadOnlyList<WayfinderPinRecord> records = _database.Records;
			if (records == null)
			{
				return false;
			}
			float num = Mathf.Max(0f, radius);
			num *= num;
			for (int i = 0; i < records.Count; i++)
			{
				WayfinderPinRecord wayfinderPinRecord = records[i];
				if (wayfinderPinRecord == null || wayfinderPinRecord.category != WayfinderPinCategory.Vehicle || wayfinderPinRecord.source != WayfinderPinSource.Dynamic)
				{
					continue;
				}
				string text = Normalize((wayfinderPinRecord.subtype ?? string.Empty) + " " + (wayfinderPinRecord.displayName ?? string.Empty));
				if (text.Contains("boat") || text.Contains("ship") || text.Contains("raft") || text.Contains("karve") || text.Contains("longship") || text.Contains("drakkar"))
				{
					float num2 = wayfinderPinRecord.Position.x - position.x;
					float num3 = wayfinderPinRecord.Position.z - position.z;
					if (num2 * num2 + num3 * num3 <= num)
					{
						return true;
					}
				}
			}
			return false;
		}

		private bool TryClassifyNativePin(PinData pin, out WayfinderPinCategory category, out string iconKey)
		{
			category = WayfinderPinCategory.Unknown;
			iconKey = string.Empty;
			if (pin == null)
			{
				return false;
			}
			if (TraderIdentity.TryFromNativePin(pin, out var _, out var _))
			{
				category = WayfinderPinCategory.Trader;
				iconKey = "wayfinder:trader";
				return true;
			}
			string text = pin.m_name ?? string.Empty;
			string text2 = text;
			try
			{
				if (Localization.instance != null && !string.IsNullOrEmpty(text))
				{
					text2 = Localization.instance.Localize(text);
				}
			}
			catch
			{
			}
			string text3 = Normalize(text + " " + text2);
			if (string.IsNullOrEmpty(text3))
			{
				return false;
			}
			if (text3.Contains("eikthyr") || text3.Contains("elder") || text3.Contains("bonemass") || text3.Contains("moder") || text3.Contains("yagluth") || text3.Contains("queen") || text3.Contains("fader"))
			{
				return false;
			}
			if (text3.Contains("tarpit"))
			{
				category = WayfinderPinCategory.Danger;
				iconKey = "wayfinder:danger";
				return true;
			}
			if (text3.Contains("runestone") || text3.Contains("rune") || text3.Contains("lorestone"))
			{
				category = WayfinderPinCategory.PointOfInterest;
				iconKey = "wayfinder:runestone";
				return true;
			}
			if (text3.Contains("crypt") || text3.Contains("burial") || text3.Contains("chamber") || text3.Contains("tomb") || text3.Contains("cave") || text3.Contains("mine") || text3.Contains("dungeon") || text3.Contains("citadel") || text3.Contains("sealedtower") || text3.Contains("howlingcavern") || text3.Contains("smoulderingtomb") || text3.Contains("putridhole") || text3.Contains("hildirplainsfortress") || text3.Contains("dvergrtownentrance"))
			{
				category = WayfinderPinCategory.Dungeon;
				iconKey = "wayfinder:dungeon";
				return true;
			}
			if (text3.Contains("drakenest") || text3.Contains("volturenest"))
			{
				category = WayfinderPinCategory.Habitat;
				iconKey = "wayfinder:habitat";
				return true;
			}
			if (text3.Contains("greydwarfnest") || text3.Contains("spawner") || text3.Contains("bonepile") || text3.Contains("bodypile") || text3.Contains("monumentoftorment") || text3.Contains("effigyofmalice") || text3.Contains("firehole") || text3.Contains("surtling") || text3.Contains("nest"))
			{
				category = WayfinderPinCategory.Spawner;
				iconKey = "wayfinder:spawner";
				return true;
			}
			if (text3.Contains("tower") || text3.Contains("outpost") || text3.Contains("watchtower") || text3.Contains("lighthouse") || text3.Contains("fort") || text3.Contains("keep"))
			{
				category = WayfinderPinCategory.Outpost;
				iconKey = "wayfinder:outpost";
				return true;
			}
			if (text3.Contains("farm") || text3.Contains("field"))
			{
				category = WayfinderPinCategory.Farm;
				iconKey = "wayfinder:farm";
				return true;
			}
			if (text3.Contains("dock") || text3.Contains("harbor") || text3.Contains("harbour") || text3.Contains("pier"))
			{
				category = WayfinderPinCategory.Dock;
				iconKey = "wayfinder:dock";
				return true;
			}
			if (text3.Contains("bridge") || text3.Contains("viaduct"))
			{
				category = WayfinderPinCategory.Bridge;
				iconKey = "wayfinder:bridge";
				return true;
			}
			if (text3.Contains("storage") || text3.Contains("warehouse") || text3.Contains("storehouse"))
			{
				category = WayfinderPinCategory.Storage;
				iconKey = "wayfinder:storage";
				return true;
			}
			if (text3.Contains("camp") || text3.Contains("tent"))
			{
				category = WayfinderPinCategory.Camp;
				iconKey = "wayfinder:camp";
				return true;
			}
			if (text3.Contains("road") || text3.Contains("path") || text3.Contains("causeway"))
			{
				category = WayfinderPinCategory.Road;
				iconKey = "wayfinder:road";
				return true;
			}
			if (text3.Contains("hut") || text3.Contains("house") || text3.Contains("village") || text3.Contains("cabin") || text3.Contains("ruin") || text3.Contains("hall") || text3.Contains("shipwreck") || text3.Contains("building") || text3.Contains("structure"))
			{
				category = WayfinderPinCategory.PointOfInterest;
				iconKey = "wayfinder:structure";
				return true;
			}
			return false;
		}

		private void ApplyVanillaBossVisuals(Minimap map)
		{
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Invalid comparison between Unknown and I4
			//IL_0178: Unknown result type (might be due to invalid IL or missing references)
			//IL_0197: Unknown result type (might be due to invalid IL or missing references)
			if (PinsField == null || !(PinsField.GetValue(map) is List<PinData> list))
			{
				return;
			}
			bool flag = _manager == null || _manager.IsCategoryVisible(WayfinderPinCategory.Boss);
			for (int i = 0; i < list.Count; i++)
			{
				PinData val = list[i];
				if (val == null || (int)val.m_type != 9 || _recordsByPin.ContainsKey(val))
				{
					continue;
				}
				if (!_nativeBossKeys.TryGetValue(val, out var value))
				{
					value = WayfinderBossNaming.IdentifyBossKey(val.m_name);
					if (!string.IsNullOrEmpty(value))
					{
						_nativeBossKeys[val] = value;
					}
				}
				SetNativeBossVisualVisibility(val, flag);
				if (_config.OverrideVanillaBossNames.Value && !string.IsNullOrEmpty(value))
				{
					string displayName = WayfinderBossNaming.GetDisplayName(_config, value);
					ApplyNativeBossLabel(val, displayName);
				}
				if (!flag || !_config.SupersedeVanillaPinVisuals.Value || !_icons.IsBuilt)
				{
					continue;
				}
				WayfinderIconEntry wayfinderIconEntry = _icons.FindBestBossTrophy(string.IsNullOrEmpty(value) ? val.m_name : value);
				if (wayfinderIconEntry != null && !((Object)(object)wayfinderIconEntry.Sprite == (Object)null))
				{
					val.m_icon = wayfinderIconEntry.Sprite;
					val.m_doubleSize = true;
					if ((Object)(object)val.m_iconElement != (Object)null)
					{
						val.m_iconElement.sprite = wayfinderIconEntry.Sprite;
						((Transform)((Graphic)val.m_iconElement).rectTransform).localScale = Vector3.one * Mathf.Max(1f, _config.BossPinScale.Value);
					}
				}
			}
		}

		private static void SetNativePinVisualVisibility(PinData pin, bool visible)
		{
			if (pin == null)
			{
				return;
			}
			if ((Object)(object)pin.m_iconElement != (Object)null)
			{
				((Component)pin.m_iconElement).gameObject.SetActive(visible);
			}
			object namePinData = GetNamePinData(pin);
			SetObjectVisible(namePinData, visible);
			object value = null;
			try
			{
				if (NamePinField != null)
				{
					value = NamePinField.GetValue(pin);
				}
			}
			catch
			{
			}
			SetObjectVisible(value, visible);
		}

		private static void SetNativeBossVisualVisibility(PinData pin, bool visible)
		{
			SetNativePinVisualVisibility(pin, visible);
		}

		private static void ApplyNativeBossLabel(PinData pin, string displayName)
		{
			if (pin == null || string.IsNullOrEmpty(displayName))
			{
				return;
			}
			pin.m_name = displayName;
			object namePinData = GetNamePinData(pin);
			SetObjectText(namePinData, displayName);
			object value = null;
			try
			{
				if (NamePinField != null)
				{
					value = NamePinField.GetValue(pin);
				}
			}
			catch
			{
			}
			SetObjectText(value, displayName);
		}

		private static object GetNamePinData(PinData pin)
		{
			if (pin == null || NamePinDataField == null)
			{
				return null;
			}
			try
			{
				return NamePinDataField.GetValue(pin);
			}
			catch
			{
				return null;
			}
		}

		private static void SetObjectVisible(object value, bool visible)
		{
			if (value == null)
			{
				return;
			}
			GameObject val = (GameObject)((value is GameObject) ? value : null);
			Component val2 = (Component)((value is Component) ? value : null);
			if ((Object)(object)val == (Object)null && (Object)(object)val2 != (Object)null)
			{
				val = val2.gameObject;
			}
			if ((Object)(object)val != (Object)null)
			{
				val.SetActive(visible);
				return;
			}
			Type type = value.GetType();
			string[] array = new string[3] { "PinNameGameObject", "PinNameText", "PinNameRectTransform" };
			for (int i = 0; i < array.Length; i++)
			{
				try
				{
					PropertyInfo property = type.GetProperty(array[i], BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
					if (!(property == null) && property.CanRead)
					{
						object value2 = property.GetValue(value, null);
						GameObject val3 = (GameObject)((value2 is GameObject) ? value2 : null);
						Component val4 = (Component)((value2 is Component) ? value2 : null);
						if ((Object)(object)val3 == (Object)null && (Object)(object)val4 != (Object)null)
						{
							val3 = val4.gameObject;
						}
						if ((Object)(object)val3 != (Object)null)
						{
							val3.SetActive(visible);
						}
					}
				}
				catch
				{
				}
			}
		}

		private static void SetObjectText(object value, string displayName)
		{
			if (value == null || string.IsNullOrEmpty(displayName))
			{
				return;
			}
			TMP_Text val = (TMP_Text)((value is TMP_Text) ? value : null);
			if ((Object)(object)val != (Object)null)
			{
				val.text = displayName;
			}
			Text val2 = (Text)((value is Text) ? value : null);
			if ((Object)(object)val2 != (Object)null)
			{
				val2.text = displayName;
			}
			GameObject val3 = (GameObject)((value is GameObject) ? value : null);
			Component val4 = (Component)((value is Component) ? value : null);
			if ((Object)(object)val3 == (Object)null && (Object)(object)val4 != (Object)null)
			{
				val3 = val4.gameObject;
			}
			if ((Object)(object)val3 != (Object)null)
			{
				TMP_Text componentInChildren = val3.GetComponentInChildren<TMP_Text>(true);
				if ((Object)(object)componentInChildren != (Object)null)
				{
					componentInChildren.text = displayName;
				}
				Text componentInChildren2 = val3.GetComponentInChildren<Text>(true);
				if ((Object)(object)componentInChildren2 != (Object)null)
				{
					componentInChildren2.text = displayName;
				}
			}
			Type type = value.GetType();
			try
			{
				PropertyInfo property = type.GetProperty("PinNameText", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				if (property != null && property.CanRead)
				{
					object value2 = property.GetValue(value, null);
					TMP_Text val5 = (TMP_Text)((value2 is TMP_Text) ? value2 : null);
					if ((Object)(object)val5 != (Object)null)
					{
						val5.text = displayName;
					}
					Text val6 = (Text)((value2 is Text) ? value2 : null);
					if ((Object)(object)val6 != (Object)null)
					{
						val6.text = displayName;
					}
				}
			}
			catch
			{
			}
			try
			{
				FieldInfo[] fields = type.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				foreach (FieldInfo fieldInfo in fields)
				{
					if (fieldInfo == null)
					{
						continue;
					}
					string text = fieldInfo.Name ?? string.Empty;
					if (text.IndexOf("name", StringComparison.OrdinalIgnoreCase) < 0 && text.IndexOf("text", StringComparison.OrdinalIgnoreCase) < 0)
					{
						continue;
					}
					object obj2 = null;
					try
					{
						obj2 = fieldInfo.GetValue(value);
					}
					catch
					{
					}
					if (obj2 != null && !object.ReferenceEquals(obj2, value))
					{
						TMP_Text val7 = (TMP_Text)((obj2 is TMP_Text) ? obj2 : null);
						if ((Object)(object)val7 != (Object)null)
						{
							val7.text = displayName;
						}
						Text val8 = (Text)((obj2 is Text) ? obj2 : null);
						if ((Object)(object)val8 != (Object)null)
						{
							val8.text = displayName;
						}
					}
				}
			}
			catch
			{
			}
		}

		private string BuildDisplayName(WayfinderPinRecord record)
		{
			string text = (string.IsNullOrEmpty(record.displayName) ? record.subtype : record.displayName);
			if (_config.ShowClusterCounts.Value && record.count > 1)
			{
				return text + " x" + record.count;
			}
			return text;
		}

		private void SetLastKnownVehicleOverlay(PinData pin, WayfinderPinRecord record)
		{
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Expected O, but got Unknown
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_011a: Unknown result type (might be due to invalid IL or missing references)
			//IL_012f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0144: Unknown result type (might be due to invalid IL or missing references)
			//IL_0159: 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_0179: Unknown result type (might be due to invalid IL or missing references)
			if (pin == null)
			{
				return;
			}
			GameObject value;
			if (!_config.ShowLastKnownVehicleBadge.Value || !WayfinderDynamicState.IsLastKnownVehicle(record))
			{
				if (_lastKnownVehicleOverlays.TryGetValue(pin, out value))
				{
					if ((Object)(object)value != (Object)null)
					{
						Object.Destroy((Object)(object)value);
					}
					_lastKnownVehicleOverlays.Remove(pin);
				}
			}
			else if (!((Object)(object)pin.m_iconElement == (Object)null) && (!_lastKnownVehicleOverlays.TryGetValue(pin, out value) || !((Object)(object)value != (Object)null)))
			{
				value = new GameObject("Wayfinder Last Known Vehicle Badge", new Type[3]
				{
					typeof(RectTransform),
					typeof(CanvasRenderer),
					typeof(Image)
				});
				value.transform.SetParent(((Component)pin.m_iconElement).transform, false);
				Image component = value.GetComponent<Image>();
				component.sprite = GetLastKnownVehicleBadgeSprite();
				((Graphic)component).color = new Color(1f, 0.67f, 0.18f, 0.95f);
				((Graphic)component).raycastTarget = false;
				RectTransform component2 = value.GetComponent<RectTransform>();
				component2.anchorMin = new Vector2(0f, 0f);
				component2.anchorMax = new Vector2(0f, 0f);
				component2.pivot = new Vector2(0.5f, 0.5f);
				component2.sizeDelta = new Vector2(10f, 10f);
				component2.anchoredPosition = new Vector2(1f, 1f);
				((Transform)component2).localScale = Vector3.one;
				_lastKnownVehicleOverlays[pin] = value;
			}
		}

		private Sprite GetLastKnownVehicleBadgeSprite()
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Expected O, but got Unknown
			//IL_016c: Unknown result type (might be due to invalid IL or missing references)
			//IL_017b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_0127: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_lastKnownVehicleBadgeSprite != (Object)null)
			{
				return _lastKnownVehicleBadgeSprite;
			}
			Texture2D val = new Texture2D(32, 32, (TextureFormat)4, false);
			((Object)val).name = "Wayfinder Last Known Vehicle Badge Texture";
			((Texture)val).wrapMode = (TextureWrapMode)1;
			((Texture)val).filterMode = (FilterMode)1;
			Color32[] array = (Color32[])(object)new Color32[1024];
			float num = 15.5f;
			for (int i = 0; i < 32; i++)
			{
				for (int j = 0; j < 32; j++)
				{
					float num2 = (float)j - num;
					float num3 = (float)i - num;
					float num4 = Mathf.Sqrt(num2 * num2 + num3 * num3);
					bool flag = num4 >= 9f && num4 <= 12f;
					bool flag2 = Mathf.Abs(num2) <= 1.25f && num3 >= -1f && num3 <= 7f;
					bool flag3 = j >= 16 && j <= 23 && i >= 8 && i <= 16 && Mathf.Abs(j - 16 + (i - 16)) <= 2;
					ref Color32 reference = ref array[i * 32 + j];
					reference = ((flag || flag2 || flag3) ? new Color32(byte.MaxValue, byte.MaxValue, byte.MaxValue, byte.MaxValue) : new Color32((byte)0, (byte)0, (byte)0, (byte)0));
				}
			}
			val.SetPixels32(array);
			val.Apply(false, false);
			_lastKnownVehicleBadgeSprite = Sprite.Create(val, new Rect(0f, 0f, 32f, 32f), new Vector2(0.5f, 0.5f), 100f);
			((Object)_lastKnownVehicleBadgeSprite).name = "Wayfinder Last Known Vehicle Badge";
			return _lastKnownVehicleBadgeSprite;
		}

		private void SetTrackedOverlay(PinData pin, bool tracked, int trackSlot)
		{
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Expected O, but got Unknown
			//IL_00ee: 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_0126: Unknown result type (might be due to invalid IL or missing references)
			//IL_013b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0150: 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_0170: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			if (pin == null)
			{
				return;
			}
			GameObject value;
			if (!tracked)
			{
				if (_trackedOverlays.TryGetValue(pin, out value))
				{
					if ((Object)(object)value != (Object)null)
					{
						Object.Destroy((Object)(object)value);
					}
					_trackedOverlays.Remove(pin);
				}
			}
			else
			{
				if ((Object)(object)pin.m_iconElement == (Object)null)
				{
					return;
				}
				if (_trackedOverlays.TryGetValue(pin, out value) && (Object)(object)value != (Object)null)
				{
					Image component = value.GetComponent<Image>();
					if ((Object)(object)component != (Object)null)
					{
						((Graphic)component).color = TrackedColorPalette.GetColor(trackSlot, 1f);
					}
					return;
				}
				value = new GameObject("Wayfinder Tracked Dot", new Type[3]
				{
					typeof(RectTransform),
					typeof(CanvasRenderer),
					typeof(Image)
				});
				value.transform.SetParent(((Component)pin.m_iconElement).transform, false);
				Image component2 = value.GetComponent<Image>();
				component2.sprite = GetTrackedDotSprite();
				((Graphic)component2).color = TrackedColorPalette.GetColor(trackSlot, 1f);
				((Graphic)component2).raycastTarget = false;
				RectTransform component3 = value.GetComponent<RectTransform>();
				component3.anchorMin = new Vector2(1f, 1f);
				component3.anchorMax = new Vector2(1f, 1f);
				component3.pivot = new Vector2(0.5f, 0.5f);
				component3.sizeDelta = new Vector2(10f, 10f);
				component3.anchoredPosition = new Vector2(-1f, -1f);
				((Transform)component3).localScale = Vector3.one;
				_trackedOverlays[pin] = value;
			}
		}

		private Sprite GetTrackedDotSprite()
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Expected O, but got Unknown
			//IL_011b: Unknown result type (might be due to invalid IL or missing references)
			//IL_012a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_trackedDotSprite != (Object)null)
			{
				return _trackedDotSprite;
			}
			Texture2D val = new Texture2D(24, 24, (TextureFormat)4, false);
			((Object)val).name = "Wayfinder Tracked Dot Texture";
			((Texture)val).wrapMode = (TextureWrapMode)1;
			((Texture)val).filterMode = (FilterMode)1;
			Color32[] array = (Color32[])(object)new Color32[576];
			float num = 11.5f;
			Color32 val2 = default(Color32);
			for (int i = 0; i < 24; i++)
			{
				for (int j = 0; j < 24; j++)
				{
					float num2 = (float)j - num;
					float num3 = (float)i - num;
					float num4 = Mathf.Sqrt(num2 * num2 + num3 * num3);
					if (num4 <= 8.5f)
					{
						((Color32)(ref val2))..ctor(byte.MaxValue, byte.MaxValue, byte.MaxValue, byte.MaxValue);
					}
					else if (num4 <= 10.5f)
					{
						((Color32)(ref val2))..ctor((byte)70, (byte)70, (byte)70, (byte)245);
					}
					else
					{
						((Color32)(ref val2))..ctor((byte)0, (byte)0, (byte)0, (byte)0);
					}
					array[i * 24 + j] = val2;
				}
			}
			val.SetPixels32(array);
			val.Apply(false, false);
			_trackedDotSprite = Sprite.Create(val, new Rect(0f, 0f, 24f, 24f), new Vector2(0.5f, 0.5f), 100f);
			((Object)_trackedDotSprite).name = "Wayfinder Tracked Dot";
			return _trackedDotSprite;
		}

		private void RemoveTransientPin(PinData pin)
		{
			if (pin == null)
			{
				return;
			}
			if (_trackedOverlays.TryGetValue(pin, out var value))
			{
				if ((Object)(object)value != (Object)null)
				{
					Object.Destroy((Object)(object)value);
				}
				_trackedOverlays.Remove(pin);
			}
			if (_lastKnownVehicleOverlays.TryGetValue(pin, out value))
			{
				if ((Object)(object)value != (Object)null)
				{
					Object.Destroy((Object)(object)value);
				}
				_lastKnownVehicleOverlays.Remove(pin);
			}
			if ((Object)(object)_map == (Object)null)
			{
				return;
			}
			_internalPinRemoval = true;
			try
			{
				_map.RemovePin(pin);
			}
			catch (Exception ex)
			{
				if (_config.DebugLogging.Value)
				{
					_log.LogWarning((object)("Could not remove transient Wayfinder map pin: " + ex.Message));
				}
			}
			finally
			{
				_internalPinRemoval = false;
			}
		}

		private static float HorizontalDistance(Vector3 a, Vector3 b)
		{
			float num = a.x - b.x;
			float num2 = a.z - b.z;
			return Mathf.Sqrt(num * num + num2 * num2);
		}

		private static string Normalize(string value)
		{
			if (string.IsNullOrEmpty(value))
			{
				return string.Empty;
			}
			char[] array = new char[value.Length];
			int length = 0;
			for (int i = 0; i < value.Length; i++)
			{
				char c = char.ToLowerInvariant(value[i]);
				if (char.IsLetterOrDigit(c))
				{
					array[length++] = c;
				}
			}
			return new string(array, 0, length);
		}

		private void Detach()
		{
			RestoreVanillaPersistentPinUi();
			if ((Object)(object)_map != (Object)null)
			{
				List<PinData> list = new List<PinData>(_recordPins.Values);
				for (int i = 0; i < list.Count; i++)
				{
					RemoveTransientPin(list[i]);
				}
			}
			foreach (GameObject value in _trackedOverlays.Values)
			{
				if ((Object)(object)value != (Object)null)
				{
					Object.Destroy((Object)(object)value);
				}
			}
			_trackedOverlays.Clear();
			foreach (GameObject value2 in _lastKnownVehicleOverlays.Values)
			{
				if ((Object)(object)value2 != (Object)null)
				{
					Object.Destroy((Object)(object)value2);
				}
			}
			_lastKnownVehicleOverlays.Clear();
			_recordPins.Clear();
			_recordsByPin.Clear();
			_nativeBossKeys.Clear();
			_map = null;
			_lastRevision = -1;
			_nextVisualRefreshTime = 0f;
			_lastHiddenCategories = null;
		}
	}
}
namespace JoeyBadManners.Wayfinder.Patches
{
	[HarmonyPatch(typeof(Location), "Awake")]
	internal static class WayfinderLocationRegistryAwakePatch
	{
		private static void Postfix(Location __instance)
		{
			LiveDiscoveryRegistry.RegisterLocation(__instance);
		}
	}
	[HarmonyPatch(typeof(Location), "OnDestroy")]
	internal static class WayfinderLocationRegistryDestroyPatch
	{
		private static void Prefix(Location __instance)
		{
			LiveDiscoveryRegistry.UnregisterLocation(__instance);
		}
	}
	[HarmonyPatch(typeof(SpawnArea), "Awake")]
	internal static class WayfinderSpawnAreaRegistryAwakePatch
	{
		private static void Postfix(SpawnArea __instance)
		{
			LiveDiscoveryRegistry.RegisterSpawnArea(__instance);
		}
	}
	[HarmonyPatch(typeof(Trader), "Start")]
	internal static class WayfinderTraderRegistryStartPatch
	{
		private static void Postfix(Trader __instance)
		{
			LiveDiscoveryRegistry.RegisterTrader(__instance);
		}
	}
	[HarmonyPatch(typeof(Minimap), "UpdateExplore")]
	internal static class ExplorationPatches
	{
		private struct ExploreState
		{
			internal bool Modified;

			internal float OriginalRadius;
		}

		[HarmonyPrefix]
		private static void Prefix(Minimap __instance, Player player, ref ExploreState __state)
		{
			__state.Modified = false;
			if (!((Object)(object)__instance == (Object)null) && !((Object)(object)player == (Object)null) && WayfinderPlugin.Settings != null && WayfinderPlugin.Settings.Enabled.Value && WayfinderPlugin.Settings.ExpandedExploration.Value)
			{
				__state.OriginalRadius = __instance.m_exploreRadius;
				__state.Modified = true;
				float num = (((Character)player).IsAttachedToShip() ? WayfinderPlugin.Settings.SailingExploreMultiplier.Value : WayfinderPlugin.Settings.WalkingExploreMultiplier.Value);
				__instance.m_exploreRadius = __state.OriginalRadius * Mathf.Max(0f, num);
			}
		}

		[HarmonyPostfix]
		private static void Postfix(Minimap __instance, ExploreState __state)
		{
			if ((Object)(object)__instance != (Object)null && __state.Modified)
			{
				__instance.m_exploreRadius = __state.OriginalRadius;
			}
		}
	}
	[HarmonyPatch(typeof(TombStone), "Awake")]
	internal static class TombStoneAwakePatch
	{
		[HarmonyPostfix]
		private static void Postfix(TombStone __instance)
		{
			if (WayfinderPlugin.Gravestones != null)
			{
				WayfinderPlugin.Gravestones.RegisterLoadedGrave(__instance);
			}
		}
	}
	[HarmonyPatch(typeof(TombStone), "Setup")]
	internal static class TombStoneSetupPatch
	{
		[HarmonyPostfix]
		private static void Postfix(TombStone __instance)
		{
			if (WayfinderPlugin.Gravestones != null)
			{
				WayfinderPlugin.Gravestones.RegisterLoadedGrave(__instance);
			}
		}
	}
	[HarmonyPatch(typeof(ZNetScene), "Destroy", new Type[] { typeof(GameObject) })]
	internal static class GravestoneNetworkDestroyPatch
	{
		[HarmonyPrefix]
		private static void Prefix(GameObject __0)
		{
			if (WayfinderPlugin.Gravestones != null)
			{
				WayfinderPlugin.Gravestones.BeforePermanentNetworkDestroy(__0);
			}
		}
	}
	[HarmonyPatch(typeof(Minimap))]
	internal static class MinimapPatches
	{
		[HarmonyPostfix]
		[HarmonyPatch("Start")]
		private static void StartPostfix(Minimap __instance)
		{
			if (WayfinderPlugin.Map != null)
			{
				WayfinderPlugin.Map.OnMinimapStarted(__instance);
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch("Update")]
		private static bool UpdatePrefix()
		{
			if (WayfinderPlugin.PinManagerUI != null)
			{
				return !WayfinderPlugin.PinManagerUI.ShouldBlockMapKeyboardInput();
			}
			return true;
		}

		[HarmonyPatch("UpdatePins")]
		[HarmonyPostfix]
		private static void UpdatePinsPostfix(Minimap __instance)
		{
			if (WayfinderPlugin.Map != null)
			{
				WayfinderPlugin.Map.AfterUpdatePins(__instance);
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch("RemovePin", new Type[]
		{
			typeof(Vector3),
			typeof(float)
		})]
		private static bool RemovePinAtPrefix(Vector3 __0, float __1, ref bool __result)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			if (WayfinderPlugin.Map == null)
			{
				return true;
			}
			return WayfinderPlugin.Map.BeforeRemovePinAt(__0, __1, ref __result);
		}

		[HarmonyPatch("RemovePin", new Type[] { typeof(PinData) })]
		[HarmonyPrefix]
		private static bool RemovePinPrefix(PinData __0)
		{
			if (WayfinderPlugin.Map == null)
			{
				return true;
			}
			return WayfinderPlugin.Map.BeforeRemovePin(__0);
		}

		[HarmonyPrefix]
		[HarmonyPatch("OnMapDblClick")]
		private static bool OnMapDblClickPrefix()
		{
			if (WayfinderPlugin.PinManagerUI == null)
			{
				return true;
			}
			return WayfinderPlugin.PinManagerUI.BeforeVanillaMapDoubleClick();
		}

		[HarmonyPrefix]
		[HarmonyPatch("OnMapLeftDown")]
		private static bool OnMapLeftDownPrefix()
		{
			if (WayfinderPlugin.PinManagerUI == null)
			{
				return true;
			}
			return WayfinderPlugin.PinManagerUI.BeforeVanillaMapLeftDown();
		}

		[HarmonyPrefix]
		[HarmonyPatch("OnMapLeftClick")]
		private static bool OnMapLeftClickPrefix()
		{
			if (WayfinderPlugin.PinManagerUI == null)
			{
				return true;
			}
			if (!WayfinderPlugin.PinManagerUI.BeforeVanillaMapLeftClick())
			{
				return false;
			}
			return !WayfinderPlugin.PinManagerUI.ShouldBlockMapPointerInput();
		}

		[HarmonyPrefix]
		[HarmonyPatch("OnMapRightClick")]
		private static bool OnMapRightClickPrefix()
		{
			if (WayfinderPlugin.PinManagerUI != null)
			{
				return !WayfinderPlugin.PinManagerUI.ShouldBlockMapPointerInput();
			}
			return true;
		}

		[HarmonyPrefix]
		[HarmonyPatch("OnMapMiddleClick")]
		private static bool OnMapMiddleClickPrefix()
		{
			if (WayfinderPlugin.PinManagerUI != null)
			{
				return !WayfinderPlugin.PinManagerUI.ShouldBlockMapPointerInput();
			}
			return true;
		}
	}
	[HarmonyPatch]
	internal static class NativeShipMarkerPatches
	{
		private static IEnumerable<MethodBase> TargetMethods()
		{
			HashSet<MethodBase> yielded = new HashSet<MethodBase>();
			MethodInfo update = FindOptionalInstanceMethod(typeof(Minimap), "Update");
			if (update != null && yielded.Add(update))
			{
				yield return update;
			}
			MethodInfo lateUpdate = FindOptionalInstanceMethod(typeof(Minimap), "LateUpdate");
			if (lateUpdate != null && yielded.Add(lateUpdate))
			{
				yield return lateUpdate;
			}
		}

		private static MethodInfo FindOptionalInstanceMethod(Type type, string name)
		{
			if (type == null || string.IsNullOrEmpty(name))
			{
				return null;
			}
			try
			{
				return type.GetMethod(name, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, Type.EmptyTypes, null);
			}
			catch
			{
				return null;
			}
		}

		private static void Postfix(Minimap __instance)
		{
			if ((Object)(object)__instance == (Object)null || WayfinderPlugin.Map == null || WayfinderPlugin.Settings == null)
			{
				return;
			}
			try
			{
				WayfinderPlugin.Map.EnforceNativeShipMarkerVisibility(__instance);
			}
			catch
			{
			}
		}
	}
	[HarmonyPatch(typeof(ObjectDB), "UpdateRegisters")]
	internal static class ObjectDBUpdateRegistersPatch
	{
		private static void Postfix()
		{
			if (WayfinderPlugin.Icons != null)
			{
				WayfinderPlugin.Icons.MarkDirty();
			}
		}
	}
	[HarmonyPatch(typeof(TeleportWorld), "SetText")]
	internal static class PortalTagSetTextPatch
	{
		private static void Postfix(TeleportWorld __instance, string text)
		{
			if ((Object)(object)__instance == (Object)null || WayfinderPlugin.Portals == null)
			{
				return;
			}
			try
			{
				WayfinderPlugin.Portals.ForceSyncPortal(__instance);
			}
			catch
			{
			}
		}
	}
	[HarmonyPatch]
	internal static class ResourceDiscoveryPatches
	{
		[HarmonyPatch]
		private static class GenericDestructibleDamageDiagnosticPatch
		{
			private static IEnumerable<MethodBase> TargetMethods()
			{
				string[] typeNames = new string[2] { "Destructible", "WearNTear" };
				for (int i = 0; i < typeNames.Length; i++)
				{
					Type type = AccessTools.TypeByName(typeNames[i]);
					if (type == null)
					{
						continue;
					}
					MethodInfo[] methods = type.GetMethods(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
					foreach (MethodInfo method in methods)
					{
						if (!(method.Name != "Damage"))
						{
							ParameterInfo[] parameters = method.GetParameters();
							if (parameters.Length == 1 && parameters[0].ParameterType == typeof(HitData))
							{
								yield return method;
							}
						}
					}
				}
			}

			private static void Postfix(object __instance, HitData hit, MethodBase __originalMethod)
			{
				Component val = (Component)((__instance is Component) ? __instance : null);
				if (!((Object)(object)val == (Object)null) && WayfinderPlugin.OreDiagnostics != null)
				{
					string hook = ((__originalMethod == null || __originalMethod.DeclaringType == null) ? "GenericDamage" : (__originalMethod.DeclaringType.Name + "." + __originalMethod.Name));
					if (WayfinderPlugin.OreDiagnostics != null)
					{
						WayfinderPlugin.OreDiagnostics.LogHit(val.gameObject, hit, hook);
					}
					if (WayfinderPlugin.Discovery != null)
					{
						WayfinderPlugin.Discovery.ObserveDestructibleDrop(val.gameObject, hit);
					}
				}
			}
		}

		[HarmonyPatch(typeof(Pickable), "Interact")]
		[HarmonyPostfix]
		private static void PickableInteractPostfix(Pickable __instance, Humanoid character, bool __result)
		{
			if (__result && object.ReferenceEquals(character, Player.m_localPlayer) && WayfinderPlugin.Discovery != null)
			{
				WayfinderPlugin.Discovery.ObservePickable(__instance);
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(MineRock), "Damage")]
		private static void MineRockDamagePostfix(MineRock __instance, HitData hit)
		{
			if (WayfinderPlugin.OreDiagnostics != null && (Object)(object)__instance != (Object)null)
			{
				WayfinderPlugin.OreDiagnostics.LogHit(((Component)__instance).gameObject, hit, "MineRock.Damage");
			}
			if (WayfinderPlugin.Discovery != null)
			{
				WayfinderPlugin.Discovery.ObserveMineRock(__instance, hit);
			}
		}

		[HarmonyPatch(typeof(MineRock5), "Damage")]
		[HarmonyPostfix]
		private static void MineRock5DamagePostfix(MineRock5 __instance, HitData hit)
		{
			if (WayfinderPlugin.OreDiagnostics != null && (Object)(object)__instance != (Object)null)
			{
				WayfinderPlugin.OreDiagnostics.LogHit(((Component)__instance).gameObject, hit, "MineRock5.Damage");
			}
			if (WayfinderPlugin.Discovery != null)
			{
				WayfinderPlugin.Discovery.ObserveMineRock5(__instance, hit);
			}
		}
	}
	[HarmonyPatch]
	internal static class VehicleDestructionPatches
	{
		private static IEnumerable<MethodBase> TargetMethods()
		{
			Type wearNTear = AccessTools.TypeByName("WearNTear");
			if (!(wearNTear == null))
			{
				HashSet<MethodBase> yielded = new HashSet<MethodBase>();
				MethodInfo destroy = FindOptionalInstanceMethod(wearNTear, "Destroy");
				if (destroy != null && yielded.Add(destroy))
				{
					yield return destroy;
				}
				MethodInfo destroyNow = FindOptionalInstanceMethod(wearNTear, "DestroyNow");
				if (destroyNow != null && yielded.Add(destroyNow))
				{
					yield return destroyNow;
				}
			}
		}

		private static MethodInfo FindOptionalInstanceMethod(Type type, string name)
		{
			if (type == null || string.IsNullOrEmpty(name))
			{
				return null;
			}
			MethodInfo[] array = null;
			try
			{
				array = type.GetMethods(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			}
			catch
			{
				return null;
			}
			if (array == null)
			{
				return null;
			}
			foreach (MethodInfo methodInfo in array)
			{
				if (methodInfo != null && string.Equals(methodInfo.Name, name, StringComparison.Ordinal))
				{
					return methodInfo;
				}
			}
			return null;
		}

		private static void Prefix(object __instance)
		{
			if ((WayfinderPlugin.Vehicles == null && WayfinderPlugin.Portals == null) || __instance == null)
			{
				return;
			}
			Component val = (Component)((__instance is Component) ? __instance : null);
			if ((Object)(object)val == (Object)null || (Object)(object)val.gameObject == (Object)null)
			{
				return;
			}
			try
			{
				if (WayfinderPlugin.Vehicles != null)
				{
					WayfinderPlugin.Vehicles.NotifyDestroyed(val.gameObject);
				}
			}
			catch
			{
			}
			try
			{
				if (WayfinderPlugin.Portals != null)
				{
					WayfinderPlugin.Portals.NotifyDestroyed(val.gameObject);
				}
			}
			catch
			{
			}
		}
	}
	[HarmonyPatch(typeof(ZInput))]
	internal static class WayfinderZInputPatches
	{
		[HarmonyPatch("GetMouseScrollWheel", new Type[] { })]
		[HarmonyPrefix]
		private static bool GetMouseScrollWheelPrefix(ref float __result)
		{
			if (WayfinderPlugin.PinManagerUI == null)
			{
				return true;
			}
			if (!WayfinderPlugin.PinManagerUI.ShouldSuppressGameplayInputForTextInput() && !WayfinderPlugin.PinManagerUI.ShouldBlockMapZoomInput())
			{
				return true;
			}
			__result = 0f;
			return false;
		}
	}
	internal static class WayfinderGameplayInputCaptureInstaller
	{
		private static readonly string[] BoolMethodNames = new string[9] { "GetButton", "GetButtonDown", "GetButtonUp", "GetKey", "GetKeyDown", "GetKeyUp", "GetMouseButton", "GetMouseButtonDown", "GetMouseButtonUp" };

		private static readonly string[] FloatMethodNames = new string[9] { "GetAxis", "GetJoyLTrigger", "GetJoyRTrigger", "GetJoyLeftStickX", "GetJoyLeftStickY", "GetJoyRightStickX", "GetJoyRightStickY", "GetButtonLastPressedTimer", "GetButtonPressedTimer" };

		internal static int Install(Harmony harmony)
		{
			if (harmony == null)
			{
				return 0;
			}
			int num = 0;
			HashSet<MethodBase> hashSet = new HashSet<MethodBase>();
			MethodInfo prefix = AccessTools.Method(typeof(WayfinderGameplayBoolInputPatches), "Prefix", (Type[])null, (Type[])null);
			MethodInfo prefix2 = AccessTools.Method(typeof(WayfinderGameplayFloatInputPatches), "Prefix", (Type[])null, (Type[])null);
			MethodInfo prefix3 = AccessTools.Method(typeof(WayfinderPlayerTakeInputPatch), "Prefix", (Type[])null, (Type[])null);
			foreach (MethodInfo declaredMethod in AccessTools.GetDeclaredMethods(typeof(ZInput)))
			{
				if (declaredMethod == null || !hashSet.Add(declaredMethod))
				{
					continue;
				}
				if (declaredMethod.ReturnType == typeof(bool) && ContainsName(BoolMethodNames, declaredMethod.Name))
				{
					if (TryPatchPrefix(harmony, declaredMethod, prefix))
					{
						num++;
					}
				}
				else if (declaredMethod.ReturnType == typeof(float) && ContainsName(FloatMethodNames, declaredMethod.Name) && TryPatchPrefix(harmony, declaredMethod, prefix2))
				{
					num++;
				}
			}
			foreach (MethodInfo declaredMethod2 in AccessTools.GetDeclaredMethods(typeof(Player)))
			{
				if (!(declaredMethod2 == null) && !(declaredMethod2.ReturnType != typeof(bool)) && string.Equals(declaredMethod2.Name, "TakeInput", StringComparison.Ordinal) && hashSet.Add(declaredMethod2) && TryPatchPrefix(harmony, declaredMethod2, prefix3))
				{
					num++;
				}
			}
			return num;
		}

		private static bool TryPatchPrefix(Harmony harmony, MethodBase original, MethodInfo prefix)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Expected O, but got Unknown
			if (original == null || prefix == null)
			{
				return false;
			}
			try
			{
				harmony.Patch(original, new HarmonyMethod(prefix), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				return true;
			}
			catch
			{
				return false;
			}
		}

		private static bool ContainsName(string[] names, string candidate)
		{
			if (names == null || string.IsNullOrEmpty(candidate))
			{
				return false;
			}
			for (int i = 0; i < names.Length; i++)
			{
				if (string.Equals(names[i], candidate, StringComparison.Ordinal))
				{
					return true;
				}
			}
			return false;
		}
	}
	internal static class WayfinderGameplayBoolInputPatches
	{
		private static bool Prefix(MethodBase __originalMethod, object[] __args, ref bool __result)
		{
			if (WayfinderPlugin.PinManagerUI == null || !WayfinderPlugin.PinManagerUI.ShouldSuppressGameplayInputForTextInput())
			{
				return true;
			}
			__result = false;
			WayfinderPlugin.PinManagerUI.LogSuppressedGameplayInput(DescribeInput(__originalMethod, __args));
			return false;
		}

		private static string DescribeInput(MethodBase method, object[] args)
		{
			string text = ((method != null) ? method.Name : "ZInput");
			if (args == null || args.Length == 0 || args[0] == null)
			{
				return text;
			}
			return text + "(" + args[0].ToString() + ")";
		}
	}
	internal static class WayfinderGameplayFloatInputPatches
	{
		private static bool Prefix(MethodBase __originalMethod, object[] __args, ref float __result)
		{
			if (WayfinderPlugin.PinManagerUI == null || !WayfinderPlugin.PinManagerUI.ShouldSuppressGameplayInputForTextInput())
			{
				return true;
			}
			__result = 0f;
			WayfinderPlugin.PinManagerUI.LogSuppressedGameplayInput(DescribeInput(__originalMethod, __args));
			return false;
		}

		private static string DescribeInput(MethodBase method, object[] args)
		{
			string text = ((method != null) ? method.Name : "ZInputFloat");
			if (args == null || args.Length == 0 || args[0] == null)
			{
				return text;
			}
			return text + "(" + args[0].ToString() + ")";
		}
	}
	internal static class WayfinderPlayerTakeInputPatch
	{
		private static bool Prefix(ref bool __result)
		{
			if (WayfinderPlugin.PinManagerUI == null || !WayfinderPlugin.PinManagerUI.ShouldSuppressGameplayInputForTextInput())
			{
				return true;
			}
			__result = false;
			WayfinderPlugin.PinManagerUI.LogSuppressedGameplayInput("Player.TakeInput");
			return false;
		}
	}
}
namespace JoeyBadManners.Wayfinder.Pins
{
	internal static class WayfinderDynamicState
	{
		private const long UnixEpochTicks = 621355968000000000L;

		private const long TicksPerSecond = 10000000L;

		internal static bool IsDynamicVehicle(WayfinderPinRecord record)
		{
			if (record != null && record.category == WayfinderPinCategory.Vehicle)
			{
				return record.source == WayfinderPinSource.Dynamic;
			}
			return false;
		}

		internal static bool IsLiveVehicle(WayfinderPinRecord record)
		{
			if (IsDynamicVehicle(record))
			{
				return record.dynamicLive;
			}
			return false;
		}

		internal static bool IsLastKnownVehicle(WayfinderPinRecord record)
		{
			if (IsDynamicVehicle(record) && !record.dynamicLive)
			{
				return record.lastSeenUnix > 0;
			}
			return false;
		}

		internal static long NowUnixSeconds()
		{
			try
			{
				long num = DateTime.UtcNow.Ticks - 621355968000000000L;
				return (num <= 0) ? 0 : (num / 10000000);
			}
			catch
			{
				return 0L;
			}
		}

		internal static long AgeSeconds(WayfinderPinRecord record)
		{
			if (record == null || record.lastSeenUnix <= 0)
			{
				return -1L;
			}
			long num = NowUnixSeconds();
			if (num <= 0)
			{
				return -1L;
			}
			long num2 = num - record.lastSeenUnix;
			if (num2 >= 0)
			{
				return num2;
			}
			return 0L;
		}

		internal static string FormatLastSeen(WayfinderPinRecord record)
		{
			if (record == null)
			{
				return "unknown";
			}
			if (record.dynamicLive)
			{
				return "now";
			}
			long num = AgeSeconds(record);
			if (num < 0)
			{
				return "unknown";
			}
			if (num < 10)
			{
				return "just now";
			}
			if (num < 60)
			{
				return num + "s ago";
			}
			long num2 = num / 60;
			if (num2 < 60)
			{
				return num2 + "m ago";
			}
			long num3 = num2 / 60;
			if (num3 < 24)
			{
				return num3 + "h ago";
			}
			long num4 = num3 / 24;
			if (num4 < 30)
			{
				return num4 + "d ago";
			}
			long num5 = num4 / 30;
			if (num5 < 12)
			{
				return num5 + "mo ago";
			}
			return num4 / 365 + "y ago";
		}

		internal static string GetVehicleStateLabel(WayfinderPinRecord record)
		{
			if (!IsDynamicVehicle(record))
			{
				return string.Empty;
			}
			if (record.dynamicLive)
			{
				return "LIVE";
			}
			return "LAST KNOWN";
		}
	}
	internal sealed class WayfinderPinDatabase
	{
		private const float DuplicatePositionTolerance = 0.25f;

		private const string PortalRightClickProtectionMigrationSentinel = "__jw_1350_portal_rightclick_protection__";

		private readonly ManualLogSource _log;

		private readonly WayfinderConfig _config;

		private WayfinderWorldData _data = new WayfinderWorldData();

		private string _filePath;

		private bool _dirty;

		private float _nextScheduledSaveTime;

		private readonly HashSet<string> _suppressedKeyCache = new HashSet<string>(StringComparer.Ordinal);

		internal IReadOnlyList<WayfinderPinRecord> Records => _data.pins;

		internal long WorldUid => _data.worldUid;

		internal int Revision { get; private set; }

		internal WayfinderPinDatabase(ManualLogSource log, WayfinderConfig config)
		{
			_log = log;
			_config = config;
		}

		internal bool LoadWorld(long worldUid, string worldName)
		{
			if (!Save())
			{
				_log.LogWarning((object)"Wayfinder postponed world switch because the previous world database could not be saved. The in-memory records were kept and the save/switch will retry automatically.");
				return false;
			}
			string text = Path.Combine(Paths.ConfigPath, "JoeysWayfinder", "worlds");
			Directory.CreateDirectory(text);
			string text2 = Path.Combine(text, worldUid + ".wfd");
			WayfinderWorldData wayfinderWorldData = new WayfinderWorldData();
			wayfinderWorldData.worldUid = worldUid;
			wayfinderWorldData.worldName = worldName ?? string.Empty;
			WayfinderWorldData wayfinderWorldData2 = wayfinderWorldData;
			bool flag = false;
			bool flag2 = false;
			bool flag3 = false;
			if (File.Exists(text2))
			{
				WayfinderWorldData wayfinderWorldData3 = null;
				try
				{
					wayfinderWorldData3 = WayfinderSaveCodec.Read(text2, worldUid, worldName);
				}
				catch (Exception ex)
				{
					flag3 = true;
					_log.LogWarning((object)("Could not read the primary Wayfinder world database: " + ex.Message));
				}
				if (wayfinderWorldData3 == null)
				{
					flag3 = true;
				}
				if (wayfinderWorldData3 == null)
				{
					string text3 = text2 + ".bak";
					if (File.Exists(text3))
					{
						try
						{
							wayfinderWorldData3 = WayfinderSaveCodec.Read(text3, worldUid, worldName);
							if (wayfinderWorldData3 != null && wayfinderWorldData3.worldUid == worldUid)
							{
								flag = true;
								try
								{
									File.Copy(text3, text2, overwrite: true);
								}
								catch (Exception ex2)
								{
									flag2 = true;
									_log.LogWarning((object)("Wayfinder loaded the backup database but could not restore it over the primary file yet: " + ex2.Message));
								}
							}
						}
						catch (Exception ex3)
						{
							_log.LogWarning((object)("Could not read the Wayfinder backup database: " + ex3.Message));
						}
					}
				}
				if (wayfinderWorldData3 != null && wayfinderWorldData3.worldUid == worldUid)
				{
					wayfinderWorldData2 = wayfinderWorldData3;
				}
				else if (flag3)
				{
					PreserveUnreadableWorldFile(text2);
					_log.LogWarning((object)"Wayfinder could not validate either the primary world database or its backup. The unreadable primary was preserved before starting a clean in-memory database for this world.");
				}
			}
			else
			{
				string path = Path.Combine(text, worldUid + ".json");
				if (File.Exists(path))
				{
					try
					{
						string text4 = File.ReadAllText(path);
						WayfinderWorldData wayfinderWorldData4 = JsonUtility.FromJson<WayfinderWorldData>(text4);
						if (wayfinderWorldData4 != null && wayfinderWorldData4.worldUid == worldUid && wayfinderWorldData4.suppressedKeys != null)
						{
							wayfinderWorldData2.suppressedKeys = new List<string>(wayfinderWorldData4.suppressedKeys);
						}
					}
					catch (Exception ex4)
					{
						_log.LogWarning((object)("Could not migrate legacy Wayfinder suppression data: " + ex4.Message));
					}
				}
			}
			_filePath = text2;
			_data = wayfinderWorldData2;
			if (_data.pins == null)
			{
				_data.pins = new List<WayfinderPinRecord>();
			}
			if (_data.suppressedKeys == null)
			{
				_data.suppressedKeys = new List<string>();
			}
			if (_data.schemaVersion < 2)
			{
				_data.schemaVersion = 2;
			}
			_dirty = false;
			_nextScheduledSaveTime = 0f;
			if (flag2)
			{
				_dirty = true;
				ScheduleSave();
			}
			int repairedIds;
			int repairedMembers;
			int repairedSuppressions;
			int num = RepairLoadedPersistenceIntegrity(out repairedIds, out repairedMembers, out repairedSuppressions);
			if (num > 0)
			{
				_dirty = true;
				ScheduleSave();
			}
			int mergedResourceRecords;
			int removedStaticPointRecords;
			int num2 = RepairLoadedDiscoveryDuplicates(out mergedResourceRecords, out removedStaticPointRecords);
			if (num2 > 0)
			{
				_dirty = true;
				ScheduleSave();
			}
			int num3 = RepairPre1350PortalRightClickSuppressions();
			if (num3 >= 0)
			{
				_dirty = true;
				ScheduleSave();
			}
			int preservedCustomNames;
			int num4 = RepairPre1351VehicleNaming(out preservedCustomNames);
			if (num4 >= 0)
			{
				_data.schemaVersion = 10;
				_dirty = true;
				ScheduleSave();
			}
			RebuildSuppressionCache();
			Revision++;
			_log.LogInfo((object)("Wayfinder world database ready: " + _data.pins.Count + " records for " + (_data.worldName ?? worldUid.ToString()) + "."));
			if (flag)
			{
				_log.LogWarning((object)"Recovered this world's Wayfinder database from the .bak safety copy after the primary file failed validation.");
			}
			if (num > 0)
			{
				_log.LogInfo((object)("Persistence integrity repaired " + repairedIds + " pin id(s), " + repairedMembers + " invalid/duplicate member(s), and " + repairedSuppressions + " invalid/duplicate suppression key(s)."));
			}
			if (num2 > 0)
			{
				_log.LogInfo((object)("Discovery regression cleanup merged " + mergedResourceRecords + " exact duplicate resource cluster record(s) and removed " + removedStaticPointRecords + " exact duplicate generated-location/spawner record(s)."));
			}
			if (num3 > 0)
			{
				_log.LogInfo((object)("Portal recovery restored " + num3 + " previously suppressed portal pin(s). Map right-click can no longer permanently suppress managed portals; deliberate removal remains available from the Pins panel."));
			}
			if (num4 > 0 || preservedCustomNames > 0)
			{
				_log.LogInfo((object)("Vehicle-name migration repaired " + num4 + " automatic vehicle label(s) and preserved " + preservedCustomNames + " existing custom label(s)."));
			}
			return true;
		}

		private void PreserveUnreadableWorldFile(string path)
		{
			if (string.IsNullOrEmpty(path) || !File.Exists(path))
			{
				return;
			}
			try
			{
				string text = DateTime.UtcNow.ToString("yyyyMMdd-HHmmss");
				string destFileName = path + ".corrupt-" + text;
				File.Copy(path, destFileName, overwrite: false);
			}
			catch
			{
			}
		}

		private int RepairLoadedPersistenceIntegrity(out int repairedIds, out int repairedMembers, out int repairedSuppressions)
		{
			repairedIds = 0;
			repairedMembers = 0;
			repairedSuppressions = 0;
			if (_data == null)
			{
				return 0;
			}
			if (_data.pins == null)
			{
				_data.pins = new List<WayfinderPinRecord>();
			}
			if (_data.suppressedKeys == null)
			{
				_data.suppressedKeys = new List<string>();
			}
			HashSet<string> hashSet = new HashSet<string>(StringComparer.Ordinal);
			for (int i = 0; i < _data.pins.Count; i++)
			{
				WayfinderPinRecord wayfinderPinRecord = _data.pins[i];
				if (wayfinderPinRecord == null)
				{
					continue;
				}
				if (string.IsNullOrEmpty(wayfinderPinRecord.id) || hashSet.Contains(wayfinderPinRecord.id))
				{
					wayfinderPinRecord.id = Guid.NewGuid().ToString("N");
					repairedIds++;
				}
				hashSet.Add(wayfinderPinRecord.id);
				if (wayfinderPinRecord.members == null)
				{
					wayfinderPinRecord.members = new List<WayfinderClusterMember>();
					continue;
				}
				HashSet<string> hashSet2 = new HashSet<string>(StringComparer.Ordinal);
				bool flag = false;
				for (int num = wayfinderPinRecord.members.Count - 1; num >= 0; num--)
				{
					string text = wayfinderPinRecord.members[num]?.key;
					if (string.IsNullOrEmpty(text) || hashSet2.Contains(text))
					{
						wayfinderPinRecord.members.RemoveAt(num);
						repairedMembers++;
						flag = true;
					}
					else
					{
						hashSet2.Add(text);
					}
				}
				if (flag && (wayfinderPinRecord.category == WayfinderPinCategory.Resource || wayfinderPinRecord.category == WayfinderPinCategory.Sighting))
				{
					RecalculateCluster(wayfinderPinRecord);
				}
			}
			HashSet<string> hashSet3 = new HashSet<string>(StringComparer.Ordinal);
			for (int num2 = _data.suppressedKeys.Count - 1; num2 >= 0; num2--)
			{
				string text2 = _data.suppressedKeys[num2];
				if (string.IsNullOrEmpty(text2) || hashSet3.Contains(text2))
				{
					_data.suppressedKeys.RemoveAt(num2);
					repairedSuppressions++;
				}
				else
				{
					hashSet3.Add(text2);
				}
			}
			return repairedIds + repairedMembers + repairedSuppressions;
		}

		private int RepairLoadedDiscoveryDuplicates(out int mergedResourceRecords, out int removedStaticPointRecords)
		{
			mergedResourceRecords = 0;
			removedStaticPointRecords = 0;
			if (_data == null || _data.pins == null || _data.pins.Count < 2)
			{
				return 0;
			}
			Dictionary<string, WayfinderPinRecord> ownerByMember = new Dictionary<string, WayfinderPinRecord>(StringComparer.OrdinalIgnoreCase);
			Dictionary<string, WayfinderPinRecord> dictionary = new Dictionary<string, WayfinderPinRecord>(StringComparer.OrdinalIgnoreCase);
			for (int i = 0; i < _data.pins.Count; i++)
			{
				WayfinderPinRecord wayfinderPinRecord = _data.pins[i];
				if (!IsRepairableAutoDiscoveryRecord(wayfinderPinRecord) || wayfinderPinRecord.members == null || wayfinderPinRecord.members.Count == 0)
				{
					continue;
				}
				if (wayfinderPinRecord.category == WayfinderPinCategory.Resource)
				{
					WayfinderPinRecord wayfinderPinRecord2 = FindExistingResourceOwner(wayfinderPinRecord, ownerByMember);
					if (wayfinderPinRecord2 != null && !object.ReferenceEquals(wayfinderPinRecord2, wayfinderPinRecord))
					{
						MergeExactDuplicateResourceRecord(wayfinderPinRecord2, wayfinderPinRecord);
						_data.pins.RemoveAt(i);
						i--;
						mergedResourceRecords++;
						IndexResourceMembers(wayfinderPinRecord2, ownerByMember);
					}
					else
					{
						IndexResourceMembers(wayfinderPinRecord, ownerByMember);
					}
				}
				else
				{
					if (!IsStaticGeneratedOrSpawnerRecord(wayfinderPinRecord))
					{
						continue;
					}
					string exactStaticIdentityKey = GetExactStaticIdentityKey(wayfinderPinRecord);
					if (!string.IsNullOrEmpty(exactStaticIdentityKey))
					{
						if (!dictionary.TryGetValue(exactStaticIdentityKey, out var value))
						{
							dictionary[exactStaticIdentityKey] = wayfinderPinRecord;
						}
						else if (!object.ReferenceEquals(value, wayfinderPinRecord))
						{
							PreserveDuplicateUserState(value, wayfinderPinRecord);
							_data.pins.RemoveAt(i);
							i--;
							removedStaticPointRecords++;
						}
					}
				}
			}
			return mergedResourceRecords + removedStaticPointRecords;
		}

		private static bool IsRepairableAutoDiscoveryRecord(WayfinderPinRecord record)
		{
			if (record != null && record.source != WayfinderPinSource.Manual && record.source != WayfinderPinSource.Imported && record.source != WayfinderPinSource.Vanilla)
			{
				return record.source != WayfinderPinSource.Dynamic;
			}
			return false;
		}

		private static bool IsStaticGeneratedOrSpawnerRecord(WayfinderPinRecord record)
		{
			if (record == null || record.members == null)
			{
				return false;
			}
			for (int i = 0; i < record.members.Count; i++)
			{
				string text = ((record.members[i] == null) ? null : record.members[i].key);
				if (!string.IsNullOrEmpty(text) && (text.StartsWith("location:", StringComparison.OrdinalIgnoreCase) || text.StartsWith("spawner:", StringComparison.OrdinalIgnoreCase)))
				{
					return true;
				}
			}
			return false;
		}

		private static string GetExactStaticIdentityKey(WayfinderPinRecord record)
		{
			if (record == null || record.members == null)
			{
				return null;
			}
			for (int i = 0; i < record.members.Count; i++)
			{
				string text = ((record.members[i] == null) ? null : record.members[i].key);
				if (!string.IsNullOrEmpty(text) && (text.StartsWith("location:", StringComparison.OrdinalIgnoreCase) || text.StartsWith("spawner:", StringComparison.OrdinalIgnoreCase)))
				{
					return text;
				}
			}
			return null;
		}

		private static string BuildResourceMemberIdentity(WayfinderPinRecord record, WayfinderClusterMember member)
		{
			if (record == null || member == null || string.IsNullOrEmpty(member.key))
			{
				return null;
			}
			return (record.subtype ?? string.Empty).ToLowerInvariant() + "|" + member.key;
		}

		private static WayfinderPinRecord FindExistingResourceOwner(WayfinderPinRecord record, Dictionary<string, WayfinderPinRecord> ownerByMember)
		{
			if (record == null || record.members == null || ownerByMember == null)
			{
				return null;
			}
			for (int i = 0; i < record.members.Count; i++)
			{
				string text = BuildResourceMemberIdentity(record, record.members[i]);
				if (!string.IsNullOrEmpty(text) && ownerByMember.TryGetValue(text, out var value) && value != null && !object.ReferenceEquals(value, record))
				{
					return value;
				}
			}
			return null;
		}

		private static void IndexResourceMembers(WayfinderPinRecord record, Dictionary<string, WayfinderPinRecord> ownerByMember)
		{
			if (record == null || record.members == null || ownerByMember == null)
			{
				return;
			}
			for (int i = 0; i < record.members.Count; i++)
			{
				string text = BuildResourceMemberIdentity(record, record.members[i]);
				if (!string.IsNullOrEmpty(text))
				{
					ownerByMember[text] = record;
				}
			}
		}

		private void MergeExactDuplicateResourceRecord(WayfinderPinRecord keep, WayfinderPinRecord duplicate)
		{
			if (keep == null || duplicate == null)
			{
				return;
			}
			if (keep.members == null)
			{
				keep.members = new List<WayfinderClusterMember>();
			}
			if (duplicate.members != null)
			{
				for (int i = 0; i < duplicate.members.Count; i++)
				{
					WayfinderClusterMember wayfinderClusterMember = duplicate.members[i];
					if (wayfinderClusterMember != null && !string.IsNullOrEmpty(wayfinderClusterMember.key) && !HasResourceMember(keep, wayfinderClusterMember.key))
					{
						keep.members.Add(wayfinderClusterMember);
					}
				}
			}
			PreserveDuplicateUserState(keep, duplicate);
			if (duplicate.source == WayfinderPinSource.InteractionDiscovery)
			{
				keep.source = WayfinderPinSource.InteractionDiscovery;
			}
			if (string.IsNullOrEmpty(keep.displayName) && !string.IsNullOrEmpty(duplicate.displayName))
			{
				keep.displayName = duplicate.displayName;
			}
			if (string.IsNullOrEmpty(keep.iconKey) && !string.IsNullOrEmpty(duplicate.iconKey))
			{
				keep.iconKey = duplicate.iconKey;
			}
			RecalculateCluster(keep);
		}

		private static bool HasResourceMember(WayfinderPinRecord record, string memberKey)
		{
			if (record == null || record.members == null || string.IsNullOrEmpty(memberKey))
			{
				return false;
			}
			for (int i = 0; i < record.members.Count; i++)
			{
				WayfinderClusterMember wayfinderClusterMember = record.members[i];
				if (wayfinderClusterMember != null && string.Equals(wayfinderClusterMember.key, memberKey, StringComparison.Ordinal))
				{
					return true;
				}
			}
			return false;
		}

		private static void PreserveDuplicateUserState(WayfinderPinRecord keep, WayfinderPinRecord duplicate)
		{
			if (keep == null || duplicate == null)
			{
				return;
			}
			if (duplicate.favorite)
			{
				keep.favorite = true;
			}
			if (duplicate.iconOverride && !keep.iconOverride)
			{
				keep.iconOverride = true;
				keep.iconOverrideKey = duplicate.iconOverrideKey ?? string.Empty;
			}
			if (duplicate.tracked)
			{
				if (!keep.tracked)
				{
					keep.tracked = true;
					keep.trackSlot = duplicate.trackSlot;
				}
				else if (duplicate.trackSlot >= 0 && (keep.trackSlot < 0 || duplicate.trackSlot < keep.trackSlot))
				{
					keep.trackSlot = duplicate.trackSlot;
				}
			}
		}

		private void RebuildSuppressionCache()
		{
			_suppressedKeyCache.Clear();
			if (_data == null || _data.suppressedKeys == null)
			{
				return;
			}
			for (int i = 0; i < _data.suppressedKeys.Count; i++)
			{
				string text = _data.suppressedKeys[i];
				if (!string.IsNullOrEmpty(text))
				{
					_suppressedKeyCache.Add(text);
				}
			}
		}

		private int RepairPre1350PortalRightClickSuppressions()
		{
			if (_data == null || _data.suppressedKeys == null)
			{
				return -1;
			}
			for (int i = 0; i < _data.suppressedKeys.Count; i++)
			{
				if (string.Equals(_data.suppressedKeys[i], "__jw_1350_portal_rightclick_protection__", StringComparison.Ordinal))
				{
					return -1;
				}
			}
			int num = 0;
			for (int num2 = _data.suppressedKeys.Count - 1; num2 >= 0; num2--)
			{
				string text = _data.suppressedKeys[num2];
				if (!string.IsNullOrEmpty(text) && text.StartsWith("portal:", StringComparison.OrdinalIgnoreCase))
				{
					_data.suppressedKeys.RemoveAt(num2);
					num++;
				}
			}
			_data.suppressedKeys.Add("__jw_1350_portal_rightclick_protection__");
			return num;
		}

		private int RepairPre1351VehicleNaming(out int preservedCustomNames)
		{
			preservedCustomNames = 0;
			if (_data == null || _data.pins == null || _data.schemaVersion >= 9)
			{
				return -1;
			}
			int num = 0;
			for (int i = 0; i < _data.pins.Count; i++)
			{
				WayfinderPinRecord wayfinderPinRecord = _data.pins[i];
				if (wayfinderPinRecord == null || wayfinderPinRecord.category != WayfinderPinCategory.Vehicle || wayfinderPinRecord.source != WayfinderPinSource.Dynamic)
				{
					continue;
				}
				if (WayfinderVehicleNaming.LooksLikeAutomaticOrLegacyName(wayfinderPinRecord))
				{
					wayfinderPinRecord.vehicleNameOverride = false;
					string automaticDisplayName = WayfinderVehicleNaming.GetAutomaticDisplayName(wayfinderPinRecord);
					if (!string.Equals(wayfinderPinRecord.displayName ?? string.Empty, automaticDisplayName, StringComparison.Ordinal))
					{
						wayfinderPinRecord.displayName = automaticDisplayName;
						num++;
					}
				}
				else
				{
					wayfinderPinRecord.vehicleNameOverride = true;
					preservedCustomNames++;
				}
			}
			return num;
		}

		internal bool UnloadWorld()
		{
			int num = ((_data != null && _data.pins != null) ? _data.pins.Count : 0);
			long num2 = ((_data == null) ? 0 : _data.worldUid);
			if (!Save())
			{
				return false;
			}
			_data = new WayfinderWorldData();
			_filePath = null;
			_dirty = false;
			_suppressedKeyCache.Clear();
			_nextScheduledSaveTime = 0f;
			Revision++;
			if (num2 != 0)
			{
				_log.LogInfo((object)("Wayfinder world session closed after saving " + num + " records."));
			}
			return true;
		}

		internal void Tick()
		{
			if (_dirty && !(_nextScheduledSaveTime <= 0f) && Time.unscaledTime >= _nextScheduledSaveTime)
			{
				Save();
			}
		}

		private void ScheduleSave()
		{
			if (_dirty && !string.IsNullOrEmpty(_filePath) && !(_nextScheduledSaveTime > 0f))
			{
				_nextScheduledSaveTime = Time.unscaledTime + Mathf.Max(0.5f, _config.PersistenceFlushInterval.Value);
			}
		}

		internal bool Save()
		{
			if (!_dirty || string.IsNullOrEmpty(_filePath))
			{
				_nextScheduledSaveTime = 0f;
				return true;
			}
			try
			{
				WayfinderSaveCodec.Write(_filePath, _data);
				_dirty = false;
				_nextScheduledSaveTime = 0f;
				if (_config.DebugLogging.Value && _config.VerboseRuntimeLogging.Value)
				{
					_log.LogInfo((object)("Wayfinder persisted " + _data.pins.Count + " pins to " + _filePath));
				}
				return true;
			}
			catch (Exception ex)
			{
				_dirty = true;
				_nextScheduledSaveTime = Time.unscaledTime + Mathf.Max(1f, _config.PersistenceFlushInterval.Value);
				_log.LogWarning((object)("Could not save Wayfinder world database; keeping changes in memory and retrying automatically: " + ex.Message));
				return false;
			}
		}

		internal WayfinderPinRecord AddResourceObservation(string resourceKey, string displayName, Vector3 position, string iconKey, WayfinderPinSource source, string memberKey = null, float? linkDistanceOverride = null)
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_019c: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_0164: Unknown result type (might be due to invalid IL or missing references)
			if (string.IsNullOrEmpty(resourceKey))
			{
				throw new ArgumentException("resourceKey is required", "resourceKey");
			}
			memberKey = (string.IsNullOrEmpty(memberKey) ? BuildPositionKey(resourceKey, position) : memberKey);
			if (IsSuppressed(memberKey))
			{
				return null;
			}
			for (int i = 0; i < _data.pins.Count; i++)
			{
				WayfinderPinRecord wayfinderPinRecord = _data.pins[i];
				if (wayfinderPinRecord.category != WayfinderPinCategory.Resource || wayfinderPinRecord.subtype != resourceKey || wayfinderPinRecord.members == null)
				{
					continue;
				}
				for (int j = 0; j < wayfinderPinRecord.members.Count; j++)
				{
					WayfinderClusterMember wayfinderClusterMember = wayfinderPinRecord.members[j];
					if (wayfinderClusterMember.key == memberKey || HorizontalDistance(wayfinderClusterMember.Position, position) <= 0.25f)
					{
						RepairResourceMetadata(wayfinderPinRecord, displayName, iconKey, source);
						return wayfinderPinRecord;
					}
				}
			}
			float num = linkDistanceOverride ?? _config.ResourceClusterLinkDistance.Value;
			if (!_config.ResourceClustering.Value)
			{
				num = 0f;
			}
			List<WayfinderPinRecord> list = new List<WayfinderPinRecord>();
			if (num > 0f)
			{
				for (int k = 0; k < _data.pins.Count; k++)
				{
					WayfinderPinRecord wayfinderPinRecord2 = _data.pins[k];
					if (wayfinderPinRecord2.category == WayfinderPinCategory.Resource && !(wayfinderPinRecord2.subtype != resourceKey) && ClusterTouches(wayfinderPinRecord2, position, num))
					{
						list.Add(wayfinderPinRecord2);
					}
				}
			}
			WayfinderPinRecord wayfinderPinRecord3;
			if (list.Count == 0)
			{
				wayfinderPinRecord3 = NewResourceRecord(resourceKey, displayName, position, iconKey, source);
				wayfinderPinRecord3.members.Add(new WayfinderClusterMember(memberKey, position));
				_data.pins.Add(wayfinderPinRecord3);
			}
			else
			{
				wayfinderPinRecord3 = list[0];
				wayfinderPinRecord3.members.Add(new WayfinderClusterMember(memberKey, position));
				if (!string.IsNullOrEmpty(displayName))
				{
					wayfinderPinRecord3.displayName = displayName;
				}
				if (!string.IsNullOrEmpty(iconKey))
				{
					wayfinderPinRecord3.iconKey = iconKey;
				}
				if (source == WayfinderPinSource.InteractionDiscovery)
				{
					wayfinderPinRecord3.source = source;
				}
				for (int l = 1; l < list.Count; l++)
				{
					WayfinderPinRecord wayfinderPinRecord4 = list[l];
					if (wayfinderPinRecord4.members != null)
					{
						wayfinderPinRecord3.members.AddRange(wayfinderPinRecord4.members);
					}
					_data.pins.Remove(wayfinderPinRecord4);
				}
			}
			RecalculateCluster(wayfinderPinRecord3);
			_dirty = true;
			Revision++;
			ScheduleSave();
			return wayfinderPinRecord3;
		}

		internal WayfinderPinRecord AddSightingObservation(string creatureKey, string displayName, Vector3 position, string iconKey, string memberKey, float linkDistance)
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0202: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_019e: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cd: Unknown result type (might be due to invalid IL or missing references)
			if (string.IsNullOrEmpty(creatureKey))
			{
				return null;
			}
			memberKey = (string.IsNullOrEmpty(memberKey) ? BuildPositionKey("sighting:" + creatureKey, position) : memberKey);
			if (IsSuppressed(memberKey))
			{
				return null;
			}
			for (int i = 0; i < _data.pins.Count; i++)
			{
				WayfinderPinRecord wayfinderPinRecord = _data.pins[i];
				if (wayfinderPinRecord == null || wayfinderPinRecord.category != WayfinderPinCategory.Sighting || !string.Equals(wayfinderPinRecord.subtype, creatureKey, StringComparison.OrdinalIgnoreCase) || wayfinderPinRecord.members == null)
				{
					continue;
				}
				for (int j = 0; j < wayfinderPinRecord.members.Count; j++)
				{
					WayfinderClusterMember wayfinderClusterMember = wayfinderPinRecord.members[j];
					if (wayfinderClusterMember != null && wayfinderClusterMember.key == memberKey)
					{
						RepairPointMetadata(wayfinderPinRecord, displayName, iconKey, WayfinderPinSource.Dynamic);
						return wayfinderPinRecord;
					}
				}
			}
			List<WayfinderPinRecord> list = new List<WayfinderPinRecord>();
			for (int k = 0; k < _data.pins.Count; k++)
			{
				WayfinderPinRecord wayfinderPinRecord2 = _data.pins[k];
				if (wayfinderPinRecord2 != null && wayfinderPinRecord2.category == WayfinderPinCategory.Sighting && string.Equals(wayfinderPinRecord2.subtype, creatureKey, StringComparison.OrdinalIgnoreCase) && ClusterTouches(wayfinderPinRecord2, position, linkDistance))
				{
					list.Add(wayfinderPinRecord2);
				}
			}
			WayfinderPinRecord wayfinderPinRecord4;
			if (list.Count == 0)
			{
				WayfinderPinRecord wayfinderPinRecord3 = new WayfinderPinRecord();
				wayfinderPinRecord3.id = Guid.NewGuid().ToString("N");
				wayfinderPinRecord3.displayName = displayName ?? creatureKey;
				wayfinderPinRecord3.subtype = creatureKey;
				wayfinderPinRecord3.iconKey = iconKey ?? string.Empty;
				wayfinderPinRecord3.category = WayfinderPinCategory.Sighting;
				wayfinderPinRecord3.source = WayfinderPinSource.Dynamic;
				wayfinderPinRecord3.Position = position;
				wayfinderPinRecord3.count = 1;
				wayfinderPinRecord3.isCluster = false;
				wayfinderPinRecord3.scale = 0.9f;
				wayfinderPinRecord4 = wayfinderPinRecord3;
				wayfinderPinRecord4.members.Add(new WayfinderClusterMember(memberKey, position));
				_data.pins.Add(wayfinderPinRecord4);
			}
			else
			{
				wayfinderPinRecord4 = list[0];
				wayfinderPinRecord4.members.Add(new WayfinderClusterMember(memberKey, position));
				if (!string.IsNullOrEmpty(displayName))
				{
					wayfinderPinRecord4.displayName = displayName;
				}
				if (!string.IsNullOrEmpty(iconKey))
				{
					wayfinderPinRecord4.iconKey = iconKey;
				}
				for (int l = 1; l < list.Count; l++)
				{
					WayfinderPinRecord wayfinderPinRecord5 = list[l];
					if (wayfinderPinRecord5.members != null)
					{
						wayfinderPinRecord4.members.AddRange(wayfinderPinRecord5.members);
					}
					_data.pins.Remove(wayfinderPinRecord5);
				}
			}
			RecalculateCluster(wayfinderPinRecord4);
			_dirty = true;
			Revision++;
			ScheduleSave();
			return wayfinderPinRecord4;
		}

		internal int CollapseNearbyAutoPoints(Func<WayfinderPinRecord, string> groupSelector, float radius)
		{
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: 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_0139: Unknown result type (might be due to invalid IL or missing references)
			//IL_0148: Unknown result type (might be due to invalid IL or missing references)
			//IL_0154: Unknown result type (might be due to invalid IL or missing references)
			if (groupSelector == null || radius <= 0f)
			{
				return 0;
			}
			float num = radius * radius;
			float num2 = 1f / radius;
			Dictionary<string, Dictionary<long, List<WayfinderPinRecord>>> dictionary = new Dictionary<string, Dictionary<long, List<WayfinderPinRecord>>>(StringComparer.OrdinalIgnoreCase);
			HashSet<WayfinderPinRecord> hashSet = new HashSet<WayfinderPinRecord>();
			for (int i = 0; i < _data.pins.Count; i++)
			{
				WayfinderPinRecord wayfinderPinRecord = _data.pins[i];
				if (wayfinderPinRecord == null || wayfinderPinRecord.category == WayfinderPinCategory.Portal || wayfinderPinRecord.source == WayfinderPinSource.Manual || wayfinderPinRecord.source == WayfinderPinSource.Imported || wayfinderPinRecord.source == WayfinderPinSource.Dynamic)
				{
					continue;
				}
				string text = null;
				try
				{
					text = groupSelector(wayfinderPinRecord);
				}
				catch
				{
				}
				if (string.IsNullOrEmpty(text))
				{
					continue;
				}
				int num3 = Mathf.FloorToInt(wayfinderPinRecord.Position.x * num2);
				int num4 = Mathf.FloorToInt(wayfinderPinRecord.Position.z * num2);
				if (!dictionary.TryGetValue(text, out var value))
				{
					value = (dictionary[text] = new Dictionary<long, List<WayfinderPinRecord>>());
				}
				bool flag = false;
				for (int j = -1; j <= 1; j++)
				{
					if (flag)
					{
						break;
					}
					for (int k = -1; k <= 1; k++)
					{
						if (flag)
						{
							break;
						}
						long key = BuildSpatialCellKey(num3 + j, num4 + k);
						if (!value.TryGetValue(key, out var value2))
						{
							continue;
						}
						for (int l = 0; l < value2.Count; l++)
						{
							WayfinderPinRecord wayfinderPinRecord2 = value2[l];
							if (wayfinderPinRecord2 != null)
							{
								float num5 = wayfinderPinRecord2.Position.x - wayfinderPinRecord.Position.x;
								float num6 = wayfinderPinRecord2.Position.z - wayfinderPinRecord.Position.z;
								if (num5 * num5 + num6 * num6 <= num)
								{
									flag = true;
									break;
								}
							}
						}
					}
				}
				if (flag)
				{
					hashSet.Add(wayfinderPinRecord);
					continue;
				}
				long key2 = BuildSpatialCellKey(num3, num4);
				if (!value.TryGetValue(key2, out var value3))
				{
					value3 = (value[key2] = new List<WayfinderPinRecord>());
				}
				value3.Add(wayfinderPinRecord);
			}
			int num7 = 0;
			if (hashSet.Count > 0)
			{
				for (int num8 = _data.pins.Count - 1; num8 >= 0; num8--)
				{
					if (hashSet.Contains(_data.pins[num8]))
					{
						_data.pins.RemoveAt(num8);
						num7++;
					}
				}
			}
			if (num7 > 0)
			{
				_dirty = true;
				Revision++;
				ScheduleSave();
			}
			return num7;
		}

		private static long BuildSpatialCellKey(int x, int z)
		{
			return ((long)x << 32) ^ (uint)z;
		}

		internal WayfinderPinRecord AddPointObservation(string subtype, string displayName, Vector3 position, string iconKey, WayfinderPinCategory category, WayfinderPinSource source, string memberKey)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0158: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b9: 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)
			if (string.IsNullOrEmpty(subtype))
			{
				return null;
			}
			memberKey = (string.IsNullOrEmpty(memberKey) ? BuildPositionKey(subtype, position) : memberKey);
			if (IsSuppressed(memberKey))
			{
				return null;
			}
			for (int i = 0; i < _data.pins.Count; i++)
			{
				WayfinderPinRecord wayfinderPinRecord = _data.pins[i];
				if (wayfinderPinRecord == null || wayfinderPinRecord.category != category || wayfinderPinRecord.subtype != subtype)
				{
					continue;
				}
				if (wayfinderPinRecord.members != null)
				{
					for (int j = 0; j < wayfinderPinRecord.members.Count; j++)
					{
						WayfinderClusterMember wayfinderClusterMember = wayfinderPinRecord.members[j];
						if (wayfinderClusterMember.key == memberKey || HorizontalDistance(wayfinderClusterMember.Position, position) <= 0.75f)
						{
							RepairPointMetadata(wayfinderPinRecord, displayName, iconKey, source);
							return wayfinderPinRecord;
						}
					}
				}
				if (HorizontalDistance(wayfinderPinRecord.Position, position) <= 0.75f)
				{
					RepairPointMetadata(wayfinderPinRecord, displayName, iconKey, source);
					return wayfinderPinRecord;
				}
			}
			WayfinderPinRecord wayfinderPinRecord2 = new WayfinderPinRecord();
			wayfinderPinRecord2.id = Guid.NewGuid().ToString("N");
			wayfinderPinRecord2.displayName = displayName ?? subtype;
			wayfinderPinRecord2.subtype = subtype;
			wayfinderPinRecord2.iconKey = iconKey ?? string.Empty;
			wayfinderPinRecord2.category = category;
			wayfinderPinRecord2.source = source;
			wayfinderPinRecord2.Position = position;
			wayfinderPinRecord2.count = 1;
			wayfinderPinRecord2.isCluster = false;
			float scale;
			switch (category)
			{
			default:
				scale = 1f;
				break;
			case WayfinderPinCategory.Dungeon:
			case WayfinderPinCategory.PointOfInterest:
				scale = 0.95f;
				break;
			case WayfinderPinCategory.Boss:
				scale = Mathf.Max(1f, _config.BossPinScale.Value);
				break;
			}
			wayfinderPinRecord2.scale = scale;
			WayfinderPinRecord wayfinderPinRecord3 = wayfinderPinRecord2;
			wayfinderPinRecord3.members.Add(new WayfinderClusterMember(memberKey, position));
			_data.pins.Add(wayfinderPinRecord3);
			_dirty = true;
			Revision++;
			ScheduleSave();
			return wayfinderPinRecord3;
		}

		internal void BeginPortalObservationPass()
		{
			if (_data == null || _data.pins == null)
			{
				return;
			}
			for (int i = 0; i < _data.pins.Count; i++)
			{
				WayfinderPinRecord wayfinderPinRecord = _data.pins[i];
				if (wayfinderPinRecord != null && wayfinderPinRecord.category == WayfinderPinCategory.Portal)
				{
					wayfinderPinRecord.portalLive = false;
				}
			}
		}

		internal WayfinderPinRecord UpsertPortalObservation(string subtype, string portalTag, Vector3 position, string memberKey, bool connectionKnown, bool connected, bool syncDisplayName)
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0166: 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)
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a8: Unknown result type (might be due to invalid IL or missing references)
			if (string.IsNullOrEmpty(subtype))
			{
				subtype = "Portal";
			}
			memberKey = (string.IsNullOrEmpty(memberKey) ? BuildPositionKey("portal:" + subtype, position) : memberKey);
			if (IsSuppressed(memberKey))
			{
				return null;
			}
			WayfinderPinRecord wayfinderPinRecord = null;
			for (int i = 0; i < _data.pins.Count; i++)
			{
				if (wayfinderPinRecord != null)
				{
					break;
				}
				WayfinderPinRecord wayfinderPinRecord2 = _data.pins[i];
				if (wayfinderPinRecord2 == null || wayfinderPinRecord2.category != WayfinderPinCategory.Portal)
				{
					continue;
				}
				if (wayfinderPinRecord2.members != null)
				{
					for (int j = 0; j < wayfinderPinRecord2.members.Count; j++)
					{
						WayfinderClusterMember wayfinderClusterMember = wayfinderPinRecord2.members[j];
						if (wayfinderClusterMember != null && string.Equals(wayfinderClusterMember.key, memberKey, StringComparison.Ordinal))
						{
							wayfinderPinRecord = wayfinderPinRecord2;
							break;
						}
					}
				}
				if (wayfinderPinRecord == null && HorizontalDistance(wayfinderPinRecord2.Position, position) <= 0.75f)
				{
					wayfinderPinRecord = wayfinderPinRecord2;
				}
			}
			string text = (string.IsNullOrEmpty(portalTag) ? string.Empty : portalTag.Trim());
			string text2 = (string.IsNullOrEmpty(text) ? "Portal" : text);
			long num = WayfinderDynamicState.NowUnixSeconds();
			if (wayfinderPinRecord == null)
			{
				WayfinderPinRecord wayfinderPinRecord3 = new WayfinderPinRecord();
				wayfinderPinRecord3.id = Guid.NewGuid().ToString("N");
				wayfinderPinRecord3.displayName = text2;
				wayfinderPinRecord3.subtype = subtype;
				wayfinderPinRecord3.iconKey = "wayfinder:portal";
				wayfinderPinRecord3.category = WayfinderPinCategory.Portal;
				wayfinderPinRecord3.source = WayfinderPinSource.InteractionDiscovery;
				wayfinderPinRecord3.Position = position;
				wayfinderPinRecord3.count = 1;
				wayfinderPinRecord3.isCluster = false;
				wayfinderPinRecord3.scale = 1f;
				wayfinderPinRecord3.portalTag = text;
				wayfinderPinRecord3.portalConnectionKnown = connectionKnown;
				wayfinderPinRecord3.portalConnected = connectionKnown && connected;
				wayfinderPinRecord3.portalStatusSeenUnix = (connectionKnown ? num : 0);
				wayfinderPinRecord3.portalLive = true;
				WayfinderPinRecord wayfinderPinRecord4 = wayfinderPinRecord3;
				wayfinderPinRecord4.members.Add(new WayfinderClusterMember(memberKey, position));
				_data.pins.Add(wayfinderPinRecord4);
				_dirty = true;
				Revision++;
				ScheduleSave();
				return wayfinderPinRecord4;
			}
			bool flag = false;
			bool flag2 = false;
			wayfinderPinRecord.portalLive = true;
			if (wayfinderPinRecord.category != WayfinderPinCategory.Portal)
			{
				wayfinderPinRecord.category = WayfinderPinCategory.Portal;
				flag = true;
			}
			if (wayfinderPinRecord.source != WayfinderPinSource.InteractionDiscovery)
			{
				wayfinderPinRecord.source = WayfinderPinSource.InteractionDiscovery;
				flag = true;
			}
			if (!string.Equals(wayfinderPinRecord.subtype, subtype, StringComparison.Ordinal))
			{
				wayfinderPinRecord.subtype = subtype;
				flag = true;
			}
			if (!string.Equals(wayfinderPinRecord.iconKey, "wayfinder:portal", StringComparison.OrdinalIgnoreCase))
			{
				wayfinderPinRecord.iconKey = "wayfinder:portal";
				flag = true;
			}
			if (!string.Equals(wayfinderPinRecord.portalTag ?? string.Empty, text, StringComparison.Ordinal))
			{
				wayfinderPinRecord.portalTag = text;
				flag = true;
			}
			if (syncDisplayName && !wayfinderPinRecord.portalNameOverride && !string.Equals(wayfinderPinRecord.displayName, text2, StringComparison.Ordinal))
			{
				wayfinderPinRecord.displayName = text2;
				flag = true;
			}
			else if (string.IsNullOrEmpty(wayfinderPinRecord.displayName))
			{
				wayfinderPinRecord.displayName = text2;
				flag = true;
			}
			if (connectionKnown)
			{
				if (!wayfinderPinRecord.portalConnectionKnown || wayfinderPinRecord.portalConnected != connected)
				{
					wayfinderPinRecord.portalConnectionKnown = true;
					wayfinderPinRecord.portalConnected = connected;
					flag = true;
				}
				if (num > 0 && (wayfinderPinRecord.portalStatusSeenUnix <= 0 || num - wayfinderPinRecord.portalStatusSeenUnix >= 5))
				{
					wayfinderPinRecord.portalStatusSeenUnix = num;
					flag2 = true;
				}
			}
			else if (wayfinderPinRecord.portalConnectionKnown)
			{
				wayfinderPinRecord.portalConnectionKnown = false;
				flag = true;
			}
			if (wayfinderPinRecord.members == null)
			{
				wayfinderPinRecord.members = new List<WayfinderClusterMember>();
			}
			bool flag3 = false;
			for (int k = 0; k < wayfinderPinRecord.members.Count; k++)
			{
				WayfinderClusterMember wayfinderClusterMember2 = wayfinderPinRecord.members[k];
				if (wayfinderClusterMember2 != null && string.Equals(wayfinderClusterMember2.key, memberKey, StringComparison.Ordinal))
				{
					flag3 = true;
					break;
				}
			}
			if (!flag3)
			{
				wayfinderPinRecord.members.Add(new WayfinderClusterMember(memberKey, position));
				flag = true;
			}
			if (flag || flag2)
			{
				_dirty = true;
				ScheduleSave();
				if (flag)
				{
					Revision++;
				}
			}
			return wayfinderPinRecord;
		}

		internal bool RemovePointByMemberKey(WayfinderPinCategory category, string memberKey)
		{
			if (string.IsNullOrEmpty(memberKey))
			{
				return false;
			}
			for (int num = _data.pins.Count - 1; num >= 0; num--)
			{
				WayfinderPinRecord wayfinderPinRecord = _data.pins[num];
				if (wayfinderPinRecord != null && wayfinderPinRecord.category == category && wayfinderPinRecord.members != null)
				{
					for (int i = 0; i < wayfinderPinRecord.members.Count; i++)
					{
						WayfinderClusterMember wayfinderClusterMember = wayfinderPinRecord.members[i];
						if (wayfinderClusterMember != null && string.Equals(wayfinderClusterMember.key, memberKey, StringComparison.Ordinal))
						{
							_data.pins.RemoveAt(num);
							_dirty = true;
							Revision++;
							ScheduleSave();
							return true;
						}
					}
				}
			}
			return false;
		}

		internal void BeginDynamicObservationPass(WayfinderPinCategory category)
		{
			if (_data == null || _data.pins == null)
			{
				return;
			}
			for (int i = 0; i < _data.pins.Count; i++)
			{
				WayfinderPinRecord wayfinderPinRecord = _data.pins[i];
				if (wayfinderPinRecord != null && wayfinderPinRecord.category == category && wayfinderPinRecord.source == WayfinderPinSource.Dynamic)
				{
					wayfinderPinRecord.dynamicLive = false;
				}
			}
		}

		internal bool HasDynamicPointByMemberKey(WayfinderPinCategory category, string memberKey)
		{
			if (string.IsNullOrEmpty(memberKey) || _data == null || _data.pins == null)
			{
				return false;
			}
			for (int i = 0; i < _data.pins.Count; i++)
			{
				WayfinderPinRecord wayfinderPinRecord = _data.pins[i];
				if (wayfinderPinRecord == null || wayfinderPinRecord.category != category || wayfinderPinRecord.source != WayfinderPinSource.Dynamic || wayfinderPinRecord.members == null)
				{
					continue;
				}
				for (int j = 0; j < wayfinderPinRecord.members.Count; j++)
				{
					WayfinderClusterMember wayfinderClusterMember = wayfinderPinRecord.members[j];
					if (wayfinderClusterMember != null && string.Equals(wayfinderClusterMember.key, memberKey, StringComparison.Ordinal))
					{
						return true;
					}
				}
			}
			return false;
		}

		internal int FinalizeDynamicObservationPass(WayfinderPinCategory category, HashSet<string> seenMemberKeys, float staleGraceSeconds)
		{
			if (_data == null || _data.pins == null)
			{
				return 0;
			}
			float unscaledTime = Time.unscaledTime;
			float num = Mathf.Max(0f, staleGraceSeconds);
			int num2 = 0;
			for (int i = 0; i < _data.pins.Count; i++)
			{
				WayfinderPinRecord wayfinderPinRecord = _data.pins[i];
				if (wayfinderPinRecord == null || wayfinderPinRecord.category != category || wayfinderPinRecord.source != WayfinderPinSource.Dynamic)
				{
					continue;
				}
				bool flag = false;
				if (wayfinderPinRecord.members != null && seenMemberKeys != null)
				{
					for (int j = 0; j < wayfinderPinRecord.members.Count; j++)
					{
						WayfinderClusterMember wayfinderClusterMember = wayfinderPinRecord.members[j];
						if (wayfinderClusterMember != null && seenMemberKeys.Contains(wayfinderClusterMember.key))
						{
							flag = true;
							break;
						}
					}
				}
				if (!flag && wayfinderPinRecord.dynamicLive)
				{
					float dynamicLastObservedRealtime = wayfinderPinRecord.dynamicLastObservedRealtime;
					if (!(dynamicLastObservedRealtime > 0f) || !(unscaledTime - dynamicLastObservedRealtime < num))
					{
						wayfinderPinRecord.dynamicLive = false;
						num2++;
					}
				}
			}
			return num2;
		}

		internal WayfinderPinRecord UpsertDynamicPoint(string subtype, string displayName, Vector3 position, string iconKey, WayfinderPinCategory category, string memberKey, float movementTolerance)
		{
			//IL_0116: Unknown result type (might be due to invalid IL or missing references)
			//IL_016d: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_0308: Unknown result type (might be due to invalid IL or missing references)
			//IL_0313: Unknown result type (might be due to invalid IL or missing references)
			if (string.IsNullOrEmpty(subtype) || string.IsNullOrEmpty(memberKey))
			{
				return null;
			}
			if (IsSuppressed(memberKey))
			{
				return null;
			}
			WayfinderPinRecord wayfinderPinRecord = null;
			WayfinderClusterMember wayfinderClusterMember = null;
			for (int i = 0; i < _data.pins.Count; i++)
			{
				if (wayfinderPinRecord != null)
				{
					break;
				}
				WayfinderPinRecord wayfinderPinRecord2 = _data.pins[i];
				if (wayfinderPinRecord2 == null || wayfinderPinRecord2.source != WayfinderPinSource.Dynamic || wayfinderPinRecord2.members == null)
				{
					continue;
				}
				for (int j = 0; j < wayfinderPinRecord2.members.Count; j++)
				{
					WayfinderClusterMember wayfinderClusterMember2 = wayfinderPinRecord2.members[j];
					if (wayfinderClusterMember2 != null && string.Equals(wayfinderClusterMember2.key, memberKey, StringComparison.Ordinal))
					{
						wayfinderPinRecord = wayfinderPinRecord2;
						wayfinderClusterMember = wayfinderClusterMember2;
						break;
					}
				}
			}
			if (wayfinderPinRecord == null)
			{
				WayfinderPinRecord wayfinderPinRecord3 = new WayfinderPinRecord();
				wayfinderPinRecord3.id = Guid.NewGuid().ToString("N");
				wayfinderPinRecord3.displayName = (string.IsNullOrEmpty(displayName) ? subtype : displayName);
				wayfinderPinRecord3.subtype = subtype;
				wayfinderPinRecord3.iconKey = iconKey ?? string.Empty;
				wayfinderPinRecord3.category = category;
				wayfinderPinRecord3.source = WayfinderPinSource.Dynamic;
				wayfinderPinRecord3.Position = position;
				wayfinderPinRecord3.count = 1;
				wayfinderPinRecord3.isCluster = false;
				wayfinderPinRecord3.scale = 1f;
				wayfinderPinRecord3.lastSeenUnix = WayfinderDynamicState.NowUnixSeconds();
				wayfinderPinRecord3.vehicleNameOverride = false;
				wayfinderPinRecord3.dynamicLive = true;
				wayfinderPinRecord3.dynamicLastObservedRealtime = Time.unscaledTime;
				WayfinderPinRecord wayfinderPinRecord4 = wayfinderPinRecord3;
				wayfinderPinRecord4.members.Add(new WayfinderClusterMember(memberKey, position));
				_data.pins.Add(wayfinderPinRecord4);
				_dirty = true;
				Revision++;
				ScheduleSave();
				return wayfinderPinRecord4;
			}
			bool flag = false;
			bool flag2 = false;
			bool flag3 = false;
			wayfinderPinRecord.dynamicLive = true;
			wayfinderPinRecord.dynamicLastObservedRealtime = Time.unscaledTime;
			long num = WayfinderDynamicState.NowUnixSeconds();
			if (num > 0 && (wayfinderPinRecord.lastSeenUnix <= 0 || num - wayfinderPinRecord.lastSeenUnix >= 5))
			{
				wayfinderPinRecord.lastSeenUnix = num;
				flag3 = true;
			}
			if (category == WayfinderPinCategory.Vehicle)
			{
				if (!wayfinderPinRecord.vehicleNameOverride && !string.IsNullOrEmpty(displayName) && !string.Equals(wayfinderPinRecord.displayName, displayName, StringComparison.Ordinal))
				{
					wayfinderPinRecord.displayName = displayName;
					flag = true;
				}
			}
			else if (string.IsNullOrEmpty(wayfinderPinRecord.displayName) && !string.IsNullOrEmpty(displayName))
			{
				wayfinderPinRecord.displayName = displayName;
				flag = true;
			}
			if (!string.Equals(wayfinderPinRecord.subtype, subtype, StringComparison.Ordinal))
			{
				wayfinderPinRecord.subtype = subtype;
				flag = true;
			}
			if (!string.IsNullOrEmpty(iconKey) && !string.Equals(wayfinderPinRecord.iconKey, iconKey, StringComparison.OrdinalIgnoreCase))
			{
				wayfinderPinRecord.iconKey = iconKey;
				flag = true;
			}
			if (wayfinderPinRecord.category != category)
			{
				wayfinderPinRecord.category = category;
				flag = true;
			}
			if (wayfinderPinRecord.source != WayfinderPinSource.Dynamic)
			{
				wayfinderPinRecord.source = WayfinderPinSource.Dynamic;
				flag = true;
			}
			float num2 = Mathf.Max(0f, movementTolerance);
			Vector3 position2 = wayfinderPinRecord.Position;
			float num3 = position2.x - position.x;
			float num4 = position2.y - position.y;
			float num5 = position2.z - position.z;
			if (num3 * num3 + num4 * num4 + num5 * num5 > num2 * num2)
			{
				wayfinderPinRecord.Position = position;
				if (wayfinderClusterMember == null)
				{
					wayfinderClusterMember = new WayfinderClusterMember(memberKey, position);
					wayfinderPinRecord.members.Add(wayfinderClusterMember);
					flag = true;
				}
				else
				{
					wayfinderClusterMember.x = position.x;
					wayfinderClusterMember.y = position.y;
					wayfinderClusterMember.z = position.z;
				}
				flag2 = true;
			}
			if (flag || flag2 || flag3)
			{
				_dirty = true;
				ScheduleSave();
				if (flag)
				{
					Revision++;
				}
			}
			return wayfinderPinRecord;
		}

		internal int CollapseDuplicateDynamicMemberKeys(WayfinderPinCategory category)
		{
			Dictionary<string, WayfinderPinRecord> dictionary = new Dictionary<string, WayfinderPinRecord>(StringComparer.Ordinal);
			int num = 0;
			for (int num2 = _data.pins.Count - 1; num2 >= 0; num2--)
			{
				WayfinderPinRecord wayfinderPinRecord = _data.pins[num2];
				if (wayfinderPinRecord != null && wayfinderPinRecord.category == category && wayfinderPinRecord.source == WayfinderPinSource.Dynamic && wayfinderPinRecord.members != null && wayfinderPinRecord.members.Count != 0)
				{
					string text = ((wayfinderPinRecord.members[0] == null) ? null : wayfinderPinRecord.members[0].key);
					if (!string.IsNullOrEmpty(text))
					{
						if (!dictionary.TryGetValue(text, out var value))
						{
							dictionary[text] = wayfinderPinRecord;
						}
						else
						{
							if (wayfinderPinRecord.tracked && !value.tracked)
							{
								value.tracked = true;
								value.trackSlot = wayfinderPinRecord.trackSlot;
							}
							if (wayfinderPinRecord.favorite)
							{
								value.favorite = true;
							}
							if (wayfinderPinRecord.iconOverride && !value.iconOverride)
							{
								value.iconOverride = true;
								value.iconOverrideKey = wayfinderPinRecord.iconOverrideKey ?? string.Empty;
							}
							if (wayfinderPinRecord.lastSeenUnix > value.lastSeenUnix)
							{
								value.lastSeenUnix = wayfinderPinRecord.lastSeenUnix;
							}
							if (wayfinderPinRecord.dynamicLive)
							{
								value.dynamicLive = true;
							}
							if (wayfinderPinRecord.dynamicLastObservedRealtime > value.dynamicLastObservedRealtime)
							{
								value.dynamicLastObservedRealtime = wayfinderPinRecord.dynamicLastObservedRealtime;
							}
							if (category == WayfinderPinCategory.Vehicle && wayfinderPinRecord.vehicleNameOverride && !value.vehicleNameOverride)
							{
								value.vehicleNameOverride = true;
								value.displayName = wayfinderPinRecord.displayName;
							}
							_data.pins.RemoveAt(num2);
							num++;
						}
					}
				}
			}
			if (num > 0)
			{
				_dirty = true;
				Revision++;
				ScheduleSave();
			}
			return num;
		}

		internal int RemoveStaleDynamicAliasesNear(WayfinderPinCategory category, Vector3 livePosition, float radius, string subtypePrefix, string currentMemberKey, HashSet<string> liveMemberKeys)
		{
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_0103: Unknown result type (might be due to invalid IL or missing references)
			//IL_0118: Unknown result type (might be due to invalid IL or missing references)
			float num = Mathf.Max(0f, radius);
			num *= num;
			int num2 = 0;
			for (int num3 = _data.pins.Count - 1; num3 >= 0; num3--)
			{
				WayfinderPinRecord wayfinderPinRecord = _data.pins[num3];
				if (wayfinderPinRecord != null && wayfinderPinRecord.category == category && wayfinderPinRecord.source == WayfinderPinSource.Dynamic && wayfinderPinRecord.members != null && wayfinderPinRecord.members.Count != 0 && (string.IsNullOrEmpty(subtypePrefix) || (wayfinderPinRecord.subtype != null && wayfinderPinRecord.subtype.StartsWith(subtypePrefix, StringComparison.OrdinalIgnoreCase))))
				{
					string text = ((wayfinderPinRecord.members[0] == null) ? null : wayfinderPinRecord.members[0].key);
					if (!string.IsNullOrEmpty(text) && !string.Equals(text, currentMemberKey, StringComparison.Ordinal) && (liveMemberKeys == null || !liveMemberKeys.Contains(text)))
					{
						float num4 = wayfinderPinRecord.Position.x - livePosition.x;
						float num5 = wayfinderPinRecord.Position.y - livePosition.y;
						float num6 = wayfinderPinRecord.Position.z - livePosition.z;
						float num7 = num4 * num4 + num5 * num5 + num6 * num6;
						if (!(num7 > num))
						{
							WayfinderPinRecord wayfinderPinRecord2 = null;
							for (int i = 0; i < _data.pins.Count; i++)
							{
								WayfinderPinRecord wayfinderPinRecord3 = _data.pins[i];
								if (wayfinderPinRecord3 == null || wayfinderPinRecord3.members == null)
								{
									continue;
								}
								for (int j = 0; j < wayfinderPinRecord3.members.Count; j++)
								{
									WayfinderClusterMember wayfinderClusterMember = wayfinderPinRecord3.members[j];
									if (wayfinderClusterMember != null && string.Equals(wayfinderClusterMember.key, currentMemberKey, StringComparison.Ordinal))
									{
										wayfinderPinRecord2 = wayfinderPinRecord3;
										break;
									}
								}
								if (wayfinderPinRecord2 != null)
								{
									break;
								}
							}
							if (wayfinderPinRecord2 != null)
							{
								if (wayfinderPinRecord.tracked && !wayfinderPinRecord2.tracked)
								{
									wayfinderPinRecord2.tracked = true;
									wayfinderPinRecord2.trackSlot = wayfinderPinRecord.trackSlot;
								}
								if (wayfinderPinRecord.favorite)
								{
									wayfinderPinRecord2.favorite = true;
								}
								if (wayfinderPinRecord.iconOverride && !wayfinderPinRecord2.iconOverride)
								{
									wayfinderPinRecord2.iconOverride = true;
									wayfinderPinRecord2.iconOverrideKey = wayfinderPinRecord.iconOverrideKey ?? string.Empty;
								}
								if (wayfinderPinRecord.lastSeenUnix > wayfinderPinRecord2.lastSeenUnix)
								{
									wayfinderPinRecord2.lastSeenUnix = wayfinderPinRecord.lastSeenUnix;
								}
								if (category == WayfinderPinCategory.Vehicle && wayfinderPinRecord.vehicleNameOverride && !wayfinderPinRecord2.vehicleNameOverride)
								{
									wayfinderPinRecord2.vehicleNameOverride = true;
									wayfinderPinRecord2.displayName = wayfinderPinRecord.displayName;
								}
							}
							_data.pins.RemoveAt(num3);
							num2++;
						}
					}
				}
			}
			if (num2 > 0)
			{
				_dirty = true;
				Revision++;
				ScheduleSave();
			}
			return num2;
		}

		internal bool RemoveDynamicPointByMemberKey(WayfinderPinCategory category, string memberKey)
		{
			if (string.IsNullOrEmpty(memberKey))
			{
				return false;
			}
			for (int num = _data.pins.Count - 1; num >= 0; num--)
			{
				WayfinderPinRecord wayfinderPinRecord = _data.pins[num];
				if (wayfinderPinRecord != null && wayfinderPinRecord.category == category && wayfinderPinRecord.source == WayfinderPinSource.Dynamic && wayfinderPinRecord.members != null)
				{
					for (int i = 0; i < wayfinderPinRecord.members.Count; i++)
					{
						WayfinderClusterMember wayfinderClusterMember = wayfinderPinRecord.members[i];
						if (wayfinderClusterMember != null && string.Equals(wayfinderClusterMember.key, memberKey, StringComparison.Ordinal))
						{
							_data.pins.RemoveAt(num);
							_dirty = true;
							Revision++;
							ScheduleSave();
							return true;
						}
					}
				}
			}
			return false;
		}

		internal bool RemoveNearestDynamicPoint(WayfinderPinCategory category, Vector3 position, float radius, string subtypePrefix)
		{
			//IL_0074: 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_00a0: Unknown result type (might be due to invalid IL or missing references)
			float num = Mathf.Max(0f, radius);
			num *= num;
			int num2 = -1;
			float num3 = num;
			for (int i = 0; i < _data.pins.Count; i++)
			{
				WayfinderPinRecord wayfinderPinRecord = _data.pins[i];
				if (wayfinderPinRecord != null && wayfinderPinRecord.category == category && wayfinderPinRecord.source == WayfinderPinSource.Dynamic && (string.IsNullOrEmpty(subtypePrefix) || (wayfinderPinRecord.subtype != null && wayfinderPinRecord.subtype.StartsWith(subtypePrefix, StringComparison.OrdinalIgnoreCase))))
				{
					float num4 = wayfinderPinRecord.Position.x - position.x;
					float num5 = wayfinderPinRecord.Position.y - position.y;
					float num6 = wayfinderPinRecord.Position.z - position.z;
					float num7 = num4 * num4 + num5 * num5 + num6 * num6;
					if (num7 <= num3)
					{
						num3 = num7;
						num2 = i;
					}
				}
			}
			if (num2 < 0)
			{
				return false;
			}
			_data.pins.RemoveAt(num2);
			_dirty = true;
			Revision++;
			ScheduleSave();
			return true;
		}

		internal int RemoveUnseenDynamicPoints(WayfinderPinCategory category, HashSet<string> seenMemberKeys)
		{
			int num = 0;
			for (int num2 = _data.pins.Count - 1; num2 >= 0; num2--)
			{
				WayfinderPinRecord wayfinderPinRecord = _data.pins[num2];
				if (wayfinderPinRecord != null && wayfinderPinRecord.category == category && wayfinderPinRecord.source == WayfinderPinSource.Dynamic)
				{
					bool flag = false;
					if (wayfinderPinRecord.members != null)
					{
						for (int i = 0; i < wayfinderPinRecord.members.Count; i++)
						{
							WayfinderClusterMember wayfinderClusterMember = wayfinderPinRecord.members[i];
							if (wayfinderClusterMember != null && seenMemberKeys != null && seenMemberKeys.Contains(wayfinderClusterMember.key))
							{
								flag = true;
								break;
							}
						}
					}
					if (!flag && !wayfinderPinRecord.dynamicLive)
					{
						_data.pins.RemoveAt(num2);
						num++;
					}
				}
			}
			if (num > 0)
			{
				_dirty = true;
				Revision++;
				ScheduleSave();
			}
			return num;
		}

		internal void MarkMetadataChanged()
		{
			_dirty = true;
			ScheduleSave();
		}

		internal void AddOrUpdate(WayfinderPinRecord record)
		{
			if (record != null)
			{
				if (string.IsNullOrEmpty(record.id))
				{
					record.id = Guid.NewGuid().ToString("N");
				}
				int num = _data.pins.FindIndex((WayfinderPinRecord p) => p.id == record.id);
				if (num >= 0)
				{
					_data.pins[num] = record;
				}
				else
				{
					_data.pins.Add(record);
				}
				_dirty = true;
				Revision++;
				ScheduleSave();
			}
		}

		internal bool Remove(string id)
		{
			return Remove(id, _config.SuppressRemovedAutoPins.Value);
		}

		internal bool Remove(string id, bool suppressAutoRediscovery)
		{
			WayfinderPinRecord wayfinderPinRecord = _data.pins.Find((WayfinderPinRecord p) => p != null && p.id == id);
			if (wayfinderPinRecord == null)
			{
				return false;
			}
			if (suppressAutoRediscovery && wayfinderPinRecord.source != WayfinderPinSource.Manual && wayfinderPinRecord.source != WayfinderPinSource.Vanilla && wayfinderPinRecord.source != WayfinderPinSource.Imported)
			{
				SuppressMembers(wayfinderPinRecord);
			}
			_data.pins.Remove(wayfinderPinRecord);
			_dirty = true;
			Revision++;
			ScheduleSave();
			return true;
		}

		internal int RemoveResourceMembers(Func<string, Vector3, bool> covered)
		{
			//IL_00cb: 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 (covered == null)
			{
				return 0;
			}
			int num = 0;
			bool flag = false;
			for (int num2 = _data.pins.Count - 1; num2 >= 0; num2--)
			{
				WayfinderPinRecord wayfinderPinRecord = _data.pins[num2];
				if (wayfinderPinRecord != null && wayfinderPinRecord.category == WayfinderPinCategory.Resource)
				{
					if (wayfinderPinRecord.members == null || wayfinderPinRecord.members.Count == 0)
					{
						bool flag2 = false;
						try
						{
							flag2 = covered(wayfinderPinRecord.subtype, wayfinderPinRecord.Position);
						}
						catch
						{
						}
						if (flag2)
						{
							_data.pins.RemoveAt(num2);
							num++;
							flag = true;
						}
					}
					else
					{
						bool flag3 = false;
						for (int num3 = wayfinderPinRecord.members.Count - 1; num3 >= 0; num3--)
						{
							WayfinderClusterMember wayfinderClusterMember = wayfinderPinRecord.members[num3];
							if (wayfinderClusterMember != null)
							{
								bool flag4 = false;
								try
								{
									flag4 = covered(wayfinderPinRecord.subtype, wayfinderClusterMember.Position);
								}
								catch
								{
								}
								if (flag4)
								{
									wayfinderPinRecord.members.RemoveAt(num3);
									num++;
									flag = true;
									flag3 = true;
								}
							}
						}
						if (wayfinderPinRecord.members.Count == 0)
						{
							_data.pins.RemoveAt(num2);
						}
						else if (flag3)
						{
							RecalculateCluster(wayfinderPinRecord);
						}
					}
				}
			}
			if (flag)
			{
				_dirty = true;
				Revision++;
				ScheduleSave();
			}
			return num;
		}

		internal int RemoveSightingMembers(Func<string, Vector3, bool> covered)
		{
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			if (covered == null)
			{
				return 0;
			}
			int num = 0;
			bool flag = false;
			for (int num2 = _data.pins.Count - 1; num2 >= 0; num2--)
			{
				WayfinderPinRecord wayfinderPinRecord = _data.pins[num2];
				if (wayfinderPinRecord != null && wayfinderPinRecord.category == WayfinderPinCategory.Sighting)
				{
					if (wayfinderPinRecord.members == null || wayfinderPinRecord.members.Count == 0)
					{
						bool flag2 = false;
						try
						{
							flag2 = covered(wayfinderPinRecord.subtype, wayfinderPinRecord.Position);
						}
						catch
						{
						}
						if (flag2)
						{
							_data.pins.RemoveAt(num2);
							num++;
							flag = true;
						}
					}
					else
					{
						bool flag3 = false;
						for (int num3 = wayfinderPinRecord.members.Count - 1; num3 >= 0; num3--)
						{
							WayfinderClusterMember wayfinderClusterMember = wayfinderPinRecord.members[num3];
							if (wayfinderClusterMember != null)
							{
								bool flag4 = false;
								try
								{
									flag4 = covered(wayfinderPinRecord.subtype, wayfinderClusterMember.Position);
								}
								catch
								{
								}
								if (flag4)
								{
									wayfinderPinRecord.members.RemoveAt(num3);
									num++;
									flag = true;
									flag3 = true;
								}
							}
						}
						if (wayfinderPinRecord.members.Count == 0)
						{
							_data.pins.RemoveAt(num2);
						}
						else if (flag3)
						{
							RecalculateCluster(wayfinderPinRecord);
						}
					}
				}
			}
			if (flag)
			{
				_dirty = true;
				Revision++;
				ScheduleSave();
			}
			return num;
		}

		internal int RemoveAutoResourceSubtype(string subtype)
		{
			if (string.IsNullOrEmpty(subtype))
			{
				return 0;
			}
			int num = 0;
			for (int num2 = _data.pins.Count - 1; num2 >= 0; num2--)
			{
				WayfinderPinRecord wayfinderPinRecord = _data.pins[num2];
				if (wayfinderPinRecord != null && wayfinderPinRecord.category == WayfinderPinCategory.Resource && string.Equals(wayfinderPinRecord.subtype, subtype, StringComparison.OrdinalIgnoreCase) && wayfinderPinRecord.source != WayfinderPinSource.Manual && wayfinderPinRecord.source != WayfinderPinSource.Imported)
				{
					_data.pins.RemoveAt(num2);
					num++;
				}
			}
			if (num > 0)
			{
				_dirty = true;
				Revision++;
				ScheduleSave();
			}
			return num;
		}

		internal int RemoveAutoResourceSubtypeBySource(string subtype, WayfinderPinSource source)
		{
			if (string.IsNullOrEmpty(subtype))
			{
				return 0;
			}
			int num = 0;
			for (int num2 = _data.pins.Count - 1; num2 >= 0; num2--)
			{
				WayfinderPinRecord wayfinderPinRecord = _data.pins[num2];
				if (wayfinderPinRecord != null && wayfinderPinRecord.category == WayfinderPinCategory.Resource && string.Equals(wayfinderPinRecord.subtype, subtype, StringComparison.OrdinalIgnoreCase) && wayfinderPinRecord.source == source)
				{
					_data.pins.RemoveAt(num2);
					num++;
				}
			}
			if (num > 0)
			{
				_dirty = true;
				Revision++;
				ScheduleSave();
			}
			return num;
		}

		internal int RemoveAutoPointSubtypesContaining(params string[] normalizedNeedles)
		{
			if (normalizedNeedles == null || normalizedNeedles.Length == 0)
			{
				return 0;
			}
			int num = 0;
			for (int num2 = _data.pins.Count - 1; num2 >= 0; num2--)
			{
				WayfinderPinRecord wayfinderPinRecord = _data.pins[num2];
				if (wayfinderPinRecord != null && (wayfinderPinRecord.category == WayfinderPinCategory.PointOfInterest || wayfinderPinRecord.category == WayfinderPinCategory.Dungeon) && wayfinderPinRecord.source != WayfinderPinSource.Manual && wayfinderPinRecord.source != WayfinderPinSource.Imported && wayfinderPinRecord.source != WayfinderPinSource.Vanilla)
				{
					string text = NormalizeKey(wayfinderPinRecord.subtype);
					bool flag = false;
					for (int i = 0; i < normalizedNeedles.Length; i++)
					{
						string value = NormalizeKey(normalizedNeedles[i]);
						if (!string.IsNullOrEmpty(value) && text.Contains(value))
						{
							flag = true;
							break;
						}
					}
					if (flag)
					{
						_data.pins.RemoveAt(num2);
						num++;
					}
				}
			}
			if (num > 0)
			{
				_dirty = true;
				Revision++;
				ScheduleSave();
			}
			return num;
		}

		internal int RemoveAutoResourceSubtypeAboveY(string subtype, float yThreshold)
		{
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			if (string.IsNullOrEmpty(subtype))
			{
				return 0;
			}
			int num = 0;
			bool flag = false;
			for (int num2 = _data.pins.Count - 1; num2 >= 0; num2--)
			{
				WayfinderPinRecord wayfinderPinRecord = _data.pins[num2];
				if (wayfinderPinRecord != null && wayfinderPinRecord.category == WayfinderPinCategory.Resource && string.Equals(wayfinderPinRecord.subtype, subtype, StringComparison.OrdinalIgnoreCase) && wayfinderPinRecord.source != WayfinderPinSource.Manual && wayfinderPinRecord.source != WayfinderPinSource.Imported)
				{
					if (wayfinderPinRecord.members == null || wayfinderPinRecord.members.Count == 0)
					{
						if (wayfinderPinRecord.Position.y > yThreshold)
						{
							_data.pins.RemoveAt(num2);
							num++;
							flag = true;
						}
					}
					else
					{
						bool flag2 = false;
						for (int num3 = wayfinderPinRecord.members.Count - 1; num3 >= 0; num3--)
						{
							WayfinderClusterMember wayfinderClusterMember = wayfinderPinRecord.members[num3];
							if (wayfinderClusterMember != null && wayfinderClusterMember.Position.y > yThreshold)
							{
								wayfinderPinRecord.members.RemoveAt(num3);
								num++;
								flag2 = true;
								flag = true;
							}
						}
						if (wayfinderPinRecord.members.Count == 0)
						{
							_data.pins.RemoveAt(num2);
						}
						else if (flag2)
						{
							RecalculateCluster(wayfinderPinRecord);
						}
					}
				}
			}
			if (flag)
			{
				_dirty = true;
				Revision++;
				ScheduleSave();
			}
			return num;
		}

		internal int RemoveAutoDungeonResources(float interiorYThreshold)
		{
			//IL_006c: 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)
			int num = 0;
			bool flag = false;
			for (int num2 = _data.pins.Count - 1; num2 >= 0; num2--)
			{
				WayfinderPinRecord wayfinderPinRecord = _data.pins[num2];
				if (wayfinderPinRecord != null && wayfinderPinRecord.category == WayfinderPinCategory.Resource && wayfinderPinRecord.source != WayfinderPinSource.Manual && wayfinderPinRecord.source != WayfinderPinSource.Imported)
				{
					if (wayfinderPinRecord.members == null || wayfinderPinRecord.members.Count == 0)
					{
						if (wayfinderPinRecord.Position.y > interiorYThreshold)
						{
							_data.pins.RemoveAt(num2);
							num++;
							flag = true;
						}
					}
					else
					{
						bool flag2 = false;
						for (int num3 = wayfinderPinRecord.members.Count - 1; num3 >= 0; num3--)
						{
							WayfinderClusterMember wayfinderClusterMember = wayfinderPinRecord.members[num3];
							if (wayfinderClusterMember != null && wayfinderClusterMember.Position.y > interiorYThreshold)
							{
								wayfinderPinRecord.members.RemoveAt(num3);
								num++;
								flag2 = true;
								flag = true;
							}
						}
						if (wayfinderPinRecord.members.Count == 0)
						{
							_data.pins.RemoveAt(num2);
						}
						else if (flag2)
						{
							RecalculateCluster(wayfinderPinRecord);
						}
					}
				}
			}
			if (flag)
			{
				_dirty = true;
				Revision++;
				ScheduleSave();
			}
			return num;
		}

		internal bool IsSuppressed(string memberKey)
		{
			if (!_config.SuppressRemovedAutoPins.Value)
			{
				return false;
			}
			if (string.IsNullOrEmpty(memberKey))
			{
				return false;
			}
			return _suppressedKeyCache.Contains(memberKey);
		}

		private void RepairResourceMetadata(WayfinderPinRecord record, string displayName, string iconKey, WayfinderPinSource source)
		{
			if (record != null)
			{
				bool flag = false;
				if (!string.IsNullOrEmpty(displayName) && !string.Equals(record.displayName, displayName, StringComparison.Ordinal))
				{
					record.displayName = displayName;
					flag = true;
				}
				if (!string.IsNullOrEmpty(iconKey) && !string.Equals(record.iconKey, iconKey, StringComparison.OrdinalIgnoreCase))
				{
					record.iconKey = iconKey;
					flag = true;
				}
				if (source == WayfinderPinSource.InteractionDiscovery && record.source != source)
				{
					record.source = source;
					flag = true;
				}
				if (flag)
				{
					_dirty = true;
					Revision++;
					ScheduleSave();
				}
			}
		}

		private void RepairPointMetadata(WayfinderPinRecord record, string displayName, string iconKey, WayfinderPinSource source)
		{
			if (record != null)
			{
				bool flag = false;
				if (!string.IsNullOrEmpty(displayName) && !string.Equals(record.displayName, displayName, StringComparison.Ordinal))
				{
					record.displayName = displayName;
					flag = true;
				}
				if (!string.IsNullOrEmpty(iconKey) && !string.Equals(record.iconKey, iconKey, StringComparison.OrdinalIgnoreCase))
				{
					record.iconKey = iconKey;
					flag = true;
				}
				if (source == WayfinderPinSource.InteractionDiscovery && record.source != source)
				{
					record.source = source;
					flag = true;
				}
				if (flag)
				{
					_dirty = true;
					Revision++;
					ScheduleSave();
				}
			}
		}

		private static string NormalizeKey(string value)
		{
			if (string.IsNullOrEmpty(value))
			{
				return string.Empty;
			}
			char[] array = new char[value.Length];
			int length = 0;
			for (int i = 0; i < value.Length; i++)
			{
				char c = char.ToLowerInvariant(value[i]);
				if (char.IsLetterOrDigit(c))
				{
					array[length++] = c;
				}
			}
			return new string(array, 0, length);
		}

		private void SuppressMembers(WayfinderPinRecord record)
		{
			if (_data.suppressedKeys == null)
			{
				_data.suppressedKeys = new List<string>();
			}
			if (record.members == null)
			{
				return;
			}
			for (int i = 0; i < record.members.Count; i++)
			{
				string text = ((record.members[i] == null) ? null : record.members[i].key);
				if (!string.IsNullOrEmpty(text) && !IsSuppressed(text))
				{
					_data.suppressedKeys.Add(text);
					_suppressedKeyCache.Add(text);
				}
			}
		}

		private static WayfinderPinRecord NewResourceRecord(string resourceKey, string displayName, Vector3 position, string iconKey, WayfinderPinSource source)
		{
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			WayfinderPinRecord wayfinderPinRecord = new WayfinderPinRecord();
			wayfinderPinRecord.id = Guid.NewGuid().ToString("N");
			wayfinderPinRecord.displayName = displayName ?? resourceKey;
			wayfinderPinRecord.subtype = resourceKey;
			wayfinderPinRecord.iconKey = iconKey ?? string.Empty;
			wayfinderPinRecord.category = WayfinderPinCategory.Resource;
			wayfinderPinRecord.source = source;
			wayfinderPinRecord.Position = position;
			wayfinderPinRecord.isCluster = false;
			wayfinderPinRecord.count = 1;
			return wayfinderPinRecord;
		}

		private static bool ClusterTouches(WayfinderPinRecord record, Vector3 position, float linkDistance)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_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)
			if (record.members == null || record.members.Count == 0)
			{
				return HorizontalDistance(record.Position, position) <= linkDistance;
			}
			for (int i = 0; i < record.members.Count; i++)
			{
				if (HorizontalDistance(record.members[i].Position, position) <= linkDistance)
				{
					return true;
				}
			}
			return false;
		}

		private static void RecalculateCluster(WayfinderPinRecord record)
		{
			//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)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: 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)
			if (record.members == null || record.members.Count == 0)
			{
				record.count = 1;
				record.isCluster = false;
				return;
			}
			Vector3 val = Vector3.zero;
			for (int i = 0; i < record.members.Count; i++)
			{
				val += record.members[i].Position;
			}
			record.Position = val / (float)record.members.Count;
			record.count = record.members.Count;
			record.isCluster = record.count > 1;
		}

		private static float HorizontalDistance(Vector3 a, Vector3 b)
		{
			float num = a.x - b.x;
			float num2 = a.z - b.z;
			return Mathf.Sqrt(num * num + num2 * num2);
		}

		private static string BuildPositionKey(string key, Vector3 position)
		{
			int num = Mathf.RoundToInt(position.x * 10f);
			int num2 = Mathf.RoundToInt(position.y * 10f);
			int num3 = Mathf.RoundToInt(position.z * 10f);
			return key + "@" + num + ":" + num2 + ":" + num3;
		}
	}
	internal enum WayfinderPinCategory
	{
		Resource,
		Creature,
		Boss,
		Dungeon,
		PointOfInterest,
		Spawner,
		Habitat,
		Sighting,
		Vehicle,
		Trader,
		Portal,
		Base,
		Outpost,
		Farm,
		Dock,
		Road,
		Bridge,
		Camp,
		Storage,
		Danger,
		Custom,
		Unknown
	}
	internal enum WayfinderPinSource
	{
		Manual,
		Vanilla,
		InteractionDiscovery,
		AreaScan,
		Dynamic,
		Imported
	}
	[Serializable]
	internal sealed class WayfinderClusterMember
	{
		public string key;

		public float x;

		public float y;

		public float z;

		public Vector3 Position => new Vector3(x, y, z);

		public WayfinderClusterMember()
		{
		}

		public WayfinderClusterMember(string memberKey, Vector3 position)
		{
			key = memberKey ?? string.Empty;
			x = position.x;
			y = position.y;
			z = position.z;
		}
	}
	[Serializable]
	internal sealed class WayfinderPinRecord
	{
		public string id;

		public string displayName;

		public string subtype;

		public string iconKey;

		public bool iconOverride;

		public string iconOverrideKey;

		public WayfinderPinCategory category;

		public WayfinderPinSource source;

		public float x;

		public float y;

		public float z;

		public float scale = 1f;

		public float colorR = 1f;

		public float colorG = 1f;

		public float colorB = 1f;

		public float colorA = 1f;

		public int count = 1;

		public bool isCluster;

		public bool favorite;

		public bool tracked;

		public int trackSlot = -1;

		public long lastSeenUnix;

		public bool vehicleNameOverride;

		[NonSerialized]
		public bool dynamicLive;

		[NonSerialized]
		public float dynamicLastObservedRealtime;

		public string portalTag;

		public bool portalConnectionKnown;

		public bool portalConnected;

		public long portalStatusSeenUnix;

		public bool portalNameOverride;

		[NonSerialized]
		public bool portalLive;

		public List<WayfinderClusterMember> members = new List<WayfinderClusterMember>();

		public Vector3 Position
		{
			get
			{
				//IL_0012: Unknown result type (might be due to invalid IL or missing references)
				return new Vector3(x, y, z);
			}
			set
			{
				x = value.x;
				y = value.y;
				z = value.z;
			}
		}

		public Color Color
		{
			get
			{
				//IL_0018: Unknown result type (might be due to invalid IL or missing references)
				return new Color(colorR, colorG, colorB, colorA);
			}
			set
			{
				colorR = value.r;
				colorG = value.g;
				colorB = value.b;
				colorA = value.a;
			}
		}
	}
	[Serializable]
	internal sealed class WayfinderWorldData
	{
		public int schemaVersion = 10;

		public long worldUid;

		public string worldName;

		public List<WayfinderPinRecord> pins = new List<WayfinderPinRecord>();

		public List<string> suppressedKeys = new List<string>();
	}
	internal static class WayfinderPortalState
	{
		internal static bool IsPortal(WayfinderPinRecord record)
		{
			if (record != null)
			{
				return record.category == WayfinderPinCategory.Portal;
			}
			return false;
		}

		internal static string GetTagLabel(WayfinderPinRecord record)
		{
			if (record == null || string.IsNullOrEmpty(record.portalTag))
			{
				return "Untagged";
			}
			return record.portalTag;
		}

		internal static string GetConnectionLabel(WayfinderPinRecord record)
		{
			if (!IsPortal(record))
			{
				return string.Empty;
			}
			if (!record.portalConnectionKnown)
			{
				if (!record.portalLive)
				{
					return "Not currently verified";
				}
				return "Unknown";
			}
			string text = (record.portalConnected ? "Connected" : "Unconnected");
			if (record.portalLive)
			{
				return text + " (live)";
			}
			string text2 = FormatStatusAge(record);
			return "Last observed " + text.ToLowerInvariant() + (string.IsNullOrEmpty(text2) ? string.Empty : (" — " + text2));
		}

		internal static string FormatStatusAge(WayfinderPinRecord record)
		{
			if (record == null || record.portalStatusSeenUnix <= 0)
			{
				return string.Empty;
			}
			long num = WayfinderDynamicState.NowUnixSeconds();
			if (num <= 0)
			{
				return string.Empty;
			}
			long num2 = num - record.portalStatusSeenUnix;
			if (num2 < 0)
			{
				num2 = 0L;
			}
			if (num2 < 10)
			{
				return "just now";
			}
			if (num2 < 60)
			{
				return num2 + "s ago";
			}
			long num3 = num2 / 60;
			if (num3 < 60)
			{
				return num3 + "m ago";
			}
			long num4 = num3 / 60;
			if (num4 < 24)
			{
				return num4 + "h ago";
			}
			long num5 = num4 / 24;
			if (num5 < 30)
			{
				return num5 + "d ago";
			}
			long num6 = num5 / 30;
			if (num6 < 12)
			{
				return num6 + "mo ago";
			}
			return num5 / 365 + "y ago";
		}
	}
	internal static class WayfinderSaveCodec
	{
		private const string Magic = "JOEYS_WAYFINDER";

		private const int FormatVersion = 10;

		internal static void Write(string path, WayfinderWorldData data)
		{
			if (string.IsNullOrEmpty(path) || data == null)
			{
				return;
			}
			StringBuilder stringBuilder = new StringBuilder(8192);
			stringBuilder.Append("JOEYS_WAYFINDER").Append('|').Append(10)
				.Append('|')
				.Append(data.worldUid.ToString(CultureInfo.InvariantCulture))
				.Append('|')
				.Append(Encode(data.worldName))
				.AppendLine();
			if (data.suppressedKeys != null)
			{
				for (int i = 0; i < data.suppressedKeys.Count; i++)
				{
					string value = data.suppressedKeys[i];
					if (!string.IsNullOrEmpty(value))
					{
						stringBuilder.Append("S|").Append(Encode(value)).AppendLine();
					}
				}
			}
			if (data.pins != null)
			{
				for (int j = 0; j < data.pins.Count; j++)
				{
					WayfinderPinRecord wayfinderPinRecord = data.pins[j];
					if (wayfinderPinRecord == null)
					{
						continue;
					}
					StringBuilder stringBuilder2 = stringBuilder.Append("P|").Append(Encode(wayfinderPinRecord.id)).Append('|')
						.Append(Encode(wayfinderPinRecord.displayName))
						.Append('|')
						.Append(Encode(wayfinderPinRecord.subtype))
						.Append('|')
						.Append(Encode(wayfinderPinRecord.iconKey))
						.Append('|');
					int category = (int)wayfinderPinRecord.category;
					StringBuilder stringBuilder3 = stringBuilder2.Append(category.ToString(CultureInfo.InvariantCulture)).Append('|');
					int source = (int)wayfinderPinRecord.source;
					stringBuilder3.Append(source.ToString(CultureInfo.InvariantCulture)).Append('|').Append(F(wayfinderPinRecord.x))
						.Append('|')
						.Append(F(wayfinderPinRecord.y))
						.Append('|')
						.Append(F(wayfinderPinRecord.z))
						.Append('|')
						.Append(F(wayfinderPinRecord.scale))
						.Append('|')
						.Append(F(wayfinderPinRecord.colorR))
						.Append('|')
						.Append(F(wayfinderPinRecord.colorG))
						.Append('|')
						.Append(F(wayfinderPinRecord.colorB))
						.Append('|')
						.Append(F(wayfinderPinRecord.colorA))
						.Append('|')
						.Append(wayfinderPinRecord.count.ToString(CultureInfo.InvariantCulture))
						.Append('|')
						.Append(wayfinderPinRecord.isCluster ? "1" : "0")
						.Append('|')
						.Append(wayfinderPinRecord.favorite ? "1" : "0")
						.Append('|')
						.Append(wayfinderPinRecord.tracked ? "1" : "0")
						.Append('|')
						.Append(wayfinderPinRecord.trackSlot.ToString(CultureInfo.InvariantCulture))
						.Append('|')
						.Append(wayfinderPinRecord.lastSeenUnix.ToString(CultureInfo.InvariantCulture))
						.Append('|')
						.Append(Encode(wayfinderPinRecord.portalTag))
						.Append('|')
						.Append(wayfinderPinRecord.portalConnectionKnown ? "1" : "0")
						.Append('|')
						.Append(wayfinderPinRecord.portalConnected ? "1" : "0")
						.Append('|')
						.Append(wayfinderPinRecord.portalStatusSeenUnix.ToString(CultureInfo.InvariantCulture))
						.Append('|')
						.Append(wayfinderPinRecord.portalNameOverride ? "1" : "0")
						.Append('|')
						.Append(wayfinderPinRecord.vehicleNameOverride ? "1" : "0")
						.Append('|')
						.Append(wayfinderPinRecord.iconOverride ? "1" : "0")
						.Append('|')
						.Append(Encode(wayfinderPinRecord.iconOverrideKey))
						.AppendLine();
					if (wayfinderPinRecord.members == null)
					{
						continue;
					}
					for (int k = 0; k < wayfinderPinRecord.members.Count; k++)
					{
						WayfinderClusterMember wayfinderClusterMember = wayfinderPinRecord.members[k];
						if (wayfinderClusterMember != null)
						{
							stringBuilder.Append("M|").Append(Encode(wayfinderPinRecord.id)).Append('|')
								.Append(Encode(wayfinderClusterMember.key))
								.Append('|')
								.Append(F(wayfinderClusterMember.x))
								.Append('|')
								.Append(F(wayfinderClusterMember.y))
								.Append('|')
								.Append(F(wayfinderClusterMember.z))
								.AppendLine();
						}
					}
				}
			}
			string text = path + ".tmp";
			File.WriteAllText(text, stringBuilder.ToString(), new UTF8Encoding(encoderShouldEmitUTF8Identifier: false));
			if (File.Exists(path))
			{
				string text2 = path + ".bak";
				try
				{
					File.Replace(text, path, text2, ignoreMetadataErrors: true);
					return;
				}
				catch
				{
					try
					{
						File.Copy(path, text2, overwrite: true);
					}
					catch
					{
					}
					try
					{
						File.Copy(text, path, overwrite: true);
						File.Delete(text);
						return;
					}
					catch
					{
						throw;
					}
				}
			}
			File.Move(text, path);
		}

		internal static WayfinderWorldData Read(string path, long expectedWorldUid, string fallbackWorldName)
		{
			if (string.IsNullOrEmpty(path) || !File.Exists(path))
			{
				return null;
			}
			string[] array = File.ReadAllLines(path);
			if (array == null || array.Length == 0)
			{
				return null;
			}
			string[] array2 = array[0].Split(new char[1] { '|' });
			if (array2.Length < 4 || !string.Equals(array2[0], "JOEYS_WAYFINDER", StringComparison.Ordinal))
			{
				return null;
			}
			if (!long.TryParse(array2[2], NumberStyles.Integer, CultureInfo.InvariantCulture, out var result))
			{
				return null;
			}
			if (expectedWorldUid != 0 && result != expectedWorldUid)
			{
				return null;
			}
			int schemaVersion = I(array2[1], 1);
			WayfinderWorldData wayfinderWorldData = new WayfinderWorldData();
			wayfinderWorldData.schemaVersion = schemaVersion;
			wayfinderWorldData.worldUid = result;
			wayfinderWorldData.worldName = Decode(array2[3]);
			if (string.IsNullOrEmpty(wayfinderWorldData.worldName))
			{
				wayfinderWorldData.worldName = fallbackWorldName ?? string.Empty;
			}
			wayfinderWorldData.pins = new List<WayfinderPinRecord>();
			wayfinderWorldData.suppressedKeys = new List<string>();
			Dictionary<string, WayfinderPinRecord> dictionary = new Dictionary<string, WayfinderPinRecord>(StringComparer.Ordinal);
			for (int i = 1; i < array.Length; i++)
			{
				string text = array[i];
				if (string.IsNullOrEmpty(text))
				{
					continue;
				}
				string[] array3 = text.Split(new char[1] { '|' });
				if (array3.Length == 0)
				{
					continue;
				}
				if (array3[0] == "S" && array3.Length >= 2)
				{
					string text2 = Decode(array3[1]);
					if (!string.IsNullOrEmpty(text2))
					{
						wayfinderWorldData.suppressedKeys.Add(text2);
					}
				}
				else if (array3[0] == "P" && array3.Length >= 18)
				{
					WayfinderPinRecord wayfinderPinRecord = new WayfinderPinRecord();
					wayfinderPinRecord.id = Decode(array3[1]);
					wayfinderPinRecord.displayName = Decode(array3[2]);
					wayfinderPinRecord.subtype = Decode(array3[3]);
					wayfinderPinRecord.iconKey = Decode(array3[4]);
					wayfinderPinRecord.category = (WayfinderPinCategory)I(array3[5], 0);
					wayfinderPinRecord.source = (WayfinderPinSource)I(array3[6], 0);
					wayfinderPinRecord.x = V(array3[7], 0f);
					wayfinderPinRecord.y = V(array3[8], 0f);
					wayfinderPinRecord.z = V(array3[9], 0f);
					wayfinderPinRecord.scale = V(array3[10], 1f);
					wayfinderPinRecord.colorR = V(array3[11], 1f);
					wayfinderPinRecord.colorG = V(array3[12], 1f);
					wayfinderPinRecord.colorB = V(array3[13], 1f);
					wayfinderPinRecord.colorA = V(array3[14], 1f);
					wayfinderPinRecord.count = I(array3[15], 1);
					wayfinderPinRecord.isCluster = array3[16] == "1";
					wayfinderPinRecord.favorite = array3[17] == "1";
					wayfinderPinRecord.tracked = array3.Length >= 19 && array3[18] == "1";
					wayfinderPinRecord.trackSlot = ((array3.Length >= 20) ? I(array3[19], -1) : (-1));
					wayfinderPinRecord.lastSeenUnix = ((array3.Length >= 21) ? L(array3[20], 0L) : 0);
					wayfinderPinRecord.dynamicLive = false;
					wayfinderPinRecord.portalTag = ((array3.Length >= 22) ? Decode(array3[21]) : string.Empty);
					wayfinderPinRecord.portalConnectionKnown = array3.Length >= 23 && array3[22] == "1";
					wayfinderPinRecord.portalConnected = array3.Length >= 24 && array3[23] == "1";
					wayfinderPinRecord.portalStatusSeenUnix = ((array3.Length >= 25) ? L(array3[24], 0L) : 0);
					wayfinderPinRecord.portalNameOverride = array3.Length >= 26 && array3[25] == "1";
					wayfinderPinRecord.vehicleNameOverride = array3.Length >= 27 && array3[26] == "1";
					wayfinderPinRecord.iconOverride = array3.Length >= 28 && array3[27] == "1";
					wayfinderPinRecord.iconOverrideKey = ((array3.Length >= 29) ? Decode(array3[28]) : string.Empty);
					wayfinderPinRecord.portalLive = false;
					if (!wayfinderPinRecord.tracked)
					{
						wayfinderPinRecord.trackSlot = -1;
					}
					wayfinderPinRecord.members = new List<WayfinderClusterMember>();
					if (string.IsNullOrEmpty(wayfinderPinRecord.id))
					{
						wayfinderPinRecord.id = Guid.NewGuid().ToString("N");
					}
					wayfinderWorldData.pins.Add(wayfinderPinRecord);
					dictionary[wayfinderPinRecord.id] = wayfinderPinRecord;
				}
				else if (array3[0] == "M" && array3.Length >= 6)
				{
					string key = Decode(array3[1]);
					if (dictionary.TryGetValue(key, out var value))
					{
						value?.members.Add(new WayfinderClusterMember
						{
							key = Decode(array3[2]),
							x = V(array3[3], 0f),
							y = V(array3[4], 0f),
							z = V(array3[5], 0f)
						});
					}
				}
			}
			return wayfinderWorldData;
		}

		private static string Encode(string value)
		{
			if (string.IsNullOrEmpty(value))
			{
				return string.Empty;
			}
			return Convert.ToBase64String(Encoding.UTF8.GetBytes(value));
		}

		private static string Decode(string value)
		{
			if (string.IsNullOrEmpty(value))
			{
				return string.Empty;
			}
			try
			{
				return Encoding.UTF8.GetString(Convert.FromBase64String(value));
			}
			catch
			{
				return string.Empty;
			}
		}

		private static string F(float value)
		{
			return value.ToString("R", CultureInfo.InvariantCulture);
		}

		private static float V(string value, float fallback)
		{
			if (!float.TryParse(value, NumberStyles.Float, CultureInfo.InvariantCulture, out var result))
			{
				return fallback;
			}
			return result;
		}

		private static int I(string value, int fallback)
		{
			if (!int.TryParse(value, NumberStyles.Integer, CultureInfo.InvariantCulture, out var result))
			{
				return fallback;
			}
			return result;
		}

		private static long L(string value, long fallback)
		{
			if (!long.TryParse(value, NumberStyles.Integer, CultureInfo.InvariantCulture, out var result))
			{
				return fallback;
			}
			return result;
		}
	}
	internal static class WayfinderVehicleNaming
	{
		internal static string GetAutomaticDisplayName(string kind, string prefabName)
		{
			string text = Normalize(kind);
			string text2 = Normalize(prefabName);
			if (text == "cart" || text2.Contains("vagon") || text2.Contains("cart"))
			{
				return "Cart";
			}
			if (text2.Contains("raft"))
			{
				return "Raft";
			}
			if (text2.Contains("karve"))
			{
				return "Karve";
			}
			if (text2.Contains("drakkar") || text2.Contains("ashland") || text2.Contains("ashlands"))
			{
				return "Drakkar";
			}
			if (text2.Contains("longship") || text2.Contains("vikingship") || text2.Contains("viking"))
			{
				return "Longship";
			}
			if (!(text == "cart"))
			{
				return "Boat";
			}
			return "Cart";
		}

		internal static string GetAutomaticDisplayName(WayfinderPinRecord record)
		{
			if (record == null)
			{
				return "Vehicle";
			}
			string kindFromSubtype = GetKindFromSubtype(record.subtype);
			string prefabFromSubtype = GetPrefabFromSubtype(record.subtype);
			return GetAutomaticDisplayName(kindFromSubtype, prefabFromSubtype);
		}

		internal static bool LooksLikeAutomaticOrLegacyName(WayfinderPinRecord record)
		{
			if (record == null)
			{
				return true;
			}
			string text = (string.IsNullOrEmpty(record.displayName) ? string.Empty : record.displayName.Trim());
			if (string.IsNullOrEmpty(text))
			{
				return true;
			}
			string automaticDisplayName = GetAutomaticDisplayName(record);
			if (string.Equals(text, automaticDisplayName, StringComparison.OrdinalIgnoreCase))
			{
				return true;
			}
			if (string.Equals(text, "Vehicle", StringComparison.OrdinalIgnoreCase))
			{
				return true;
			}
			string kindFromSubtype = GetKindFromSubtype(record.subtype);
			if (string.Equals(kindFromSubtype, "boat", StringComparison.OrdinalIgnoreCase) && string.Equals(text, "Boat", StringComparison.OrdinalIgnoreCase))
			{
				return true;
			}
			if (string.Equals(kindFromSubtype, "cart", StringComparison.OrdinalIgnoreCase) && string.Equals(text, "Cart", StringComparison.OrdinalIgnoreCase))
			{
				return true;
			}
			return false;
		}

		private static string GetKindFromSubtype(string subtype)
		{
			if (string.IsNullOrEmpty(subtype))
			{
				return "boat";
			}
			string[] array = subtype.Split(new char[1] { ':' });
			if (array.Length >= 2 && string.Equals(array[0], "vehicle", StringComparison.OrdinalIgnoreCase))
			{
				return array[1];
			}
			string text = Normalize(subtype);
			if (text.Contains("cart") || text.Contains("vagon"))
			{
				return "cart";
			}
			return "boat";
		}

		private static string GetPrefabFromSubtype(string subtype)
		{
			if (string.IsNullOrEmpty(subtype))
			{
				return string.Empty;
			}
			int num = subtype.IndexOf(':');
			if (num < 0)
			{
				return subtype;
			}
			int num2 = subtype.IndexOf(':', num + 1);
			if (num2 < 0 || num2 + 1 >= subtype.Length)
			{
				return subtype;
			}
			return subtype.Substring(num2 + 1);
		}

		private static string Normalize(string value)
		{
			if (string.IsNullOrEmpty(value))
			{
				return string.Empty;
			}
			char[] array = new char[value.Length];
			int length = 0;
			for (int i = 0; i < value.Length; i++)
			{
				char c = char.ToLowerInvariant(value[i]);
				if (char.IsLetterOrDigit(c))
				{
					array[length++] = c;
				}
			}
			return new string(array, 0, length);
		}
	}
}
namespace JoeyBadManners.Wayfinder.Tracking
{
	internal sealed class TrackedBeaconController
	{
		private sealed class Beam
		{
			internal GameObject GameObject;

			internal LineRenderer Line;

			internal Material Material;
		}

		private readonly ManualLogSource _log;

		private readonly WayfinderConfig _config;

		private readonly WayfinderPinManagementService _manager;

		private readonly Dictionary<string, Beam> _beams = new Dictionary<string, Beam>(StringComparer.Ordinal);

		internal TrackedBeaconController(ManualLogSource log, WayfinderConfig config, WayfinderPinManagementService manager)
		{
			_log = log;
			_config = config;
			_manager = manager;
		}

		internal void Tick()
		{
			if (!_config.Enabled.Value || !_config.BeaconEnabled.Value || (Object)(object)Player.m_localPlayer == (Object)null || (Object)(object)ZNet.instance == (Object)null)
			{
				Clear();
				return;
			}
			List<WayfinderPinRecord> trackedPins = _manager.GetTrackedPins();
			HashSet<string> hashSet = new HashSet<string>(StringComparer.Ordinal);
			for (int i = 0; i < trackedPins.Count; i++)
			{
				WayfinderPinRecord wayfinderPinRecord = trackedPins[i];
				if (wayfinderPinRecord == null || string.IsNullOrEmpty(wayfinderPinRecord.id))
				{
					continue;
				}
				hashSet.Add(wayfinderPinRecord.id);
				if (!_beams.TryGetValue(wayfinderPinRecord.id, out var value) || value == null || (Object)(object)value.GameObject == (Object)null || (Object)(object)value.Line == (Object)null)
				{
					value = CreateBeam(wayfinderPinRecord.id);
					if (value == null)
					{
						continue;
					}
					_beams[wayfinderPinRecord.id] = value;
				}
				UpdateBeam(value, wayfinderPinRecord);
			}
			List<string> list = new List<string>();
			foreach (KeyValuePair<string, Beam> beam in _beams)
			{
				if (!hashSet.Contains(beam.Key))
				{
					list.Add(beam.Key);
				}
			}
			for (int j = 0; j < list.Count; j++)
			{
				DestroyBeam(_beams[list[j]]);
				_beams.Remove(list[j]);
			}
		}

		internal void Clear()
		{
			foreach (Beam value in _beams.Values)
			{
				DestroyBeam(value);
			}
			_beams.Clear();
		}

		private Beam CreateBeam(string id)
		{
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Expected O, but got Unknown
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Expected O, but got Unknown
			Shader val = Shader.Find("Sprites/Default");
			if ((Object)(object)val == (Object)null)
			{
				val = Shader.Find("Unlit/Transparent");
			}
			if ((Object)(object)val == (Object)null)
			{
				if (_config.DebugLogging.Value)
				{
					_log.LogWarning((object)"Tracked beacon could not find a transparent Unity shader.");
				}
				return null;
			}
			GameObject val2 = new GameObject("Wayfinder Tracked Beacon " + id);
			LineRenderer val3 = val2.AddComponent<LineRenderer>();
			Material val4 = new Material(val);
			((Object)val4).name = "Wayfinder Tracked Beacon Material";
			val4.renderQueue = 4000;
			((Renderer)val3).material = val4;
			val3.positionCount = 2;
			val3.useWorldSpace = true;
			val3.loop = false;
			val3.numCapVertices = 4;
			val3.textureMode = (LineTextureMode)0;
			val3.alignment = (LineAlignment)0;
			((Renderer)val3).receiveShadows = false;
			Beam beam = new Beam();
			beam.GameObject = val2;
			beam.Line = val3;
			beam.Material = val4;
			return beam;
		}

		private void UpdateBeam(Beam beam, WayfinderPinRecord record)
		{
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0104: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: Unknown result type (might be due to invalid IL or missing references)
			//IL_011b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0121: Unknown result type (might be due to invalid IL or missing references)
			//IL_0126: Unknown result type (might be due to invalid IL or missing references)
			//IL_0144: Unknown result type (might be due to invalid IL or missing references)
			if (beam != null && !((Object)(object)beam.Line == (Object)null) && record != null)
			{
				float num = Mathf.Clamp01(_config.BeaconOpacity.Value);
				bool flag = WayfinderDynamicState.IsLastKnownVehicle(record);
				if (flag)
				{
					num *= Mathf.Clamp01(_config.LastKnownVehicleOpacity.Value);
				}
				float num2 = Mathf.Max(0.08f, _config.BeaconWidth.Value);
				float num3 = Mathf.Max(5f, _config.BeaconHeight.Value);
				if (flag)
				{
					num2 *= 0.82f;
				}
				Color color = TrackedColorPalette.GetColor(record.trackSlot, num);
				Color color2 = TrackedColorPalette.GetColor(record.trackSlot, num * 0.15f);
				beam.Line.startWidth = num2;
				beam.Line.endWidth = num2 * 0.55f;
				beam.Line.startColor = color;
				beam.Line.endColor = color2;
				beam.Line.SetPosition(0, record.Position + Vector3.up * 0.5f);
				beam.Line.SetPosition(1, record.Position + Vector3.up * num3);
				if ((Object)(object)beam.Material != (Object)null)
				{
					beam.Material.color = color;
				}
			}
		}

		private static void DestroyBeam(Beam beam)
		{
			if (beam != null)
			{
				if ((Object)(object)beam.GameObject != (Object)null)
				{
					Object.Destroy((Object)(object)beam.GameObject);
				}
				if ((Object)(object)beam.Material != (Object)null)
				{
					Object.Destroy((Object)(object)beam.Material);
				}
			}
		}
	}
	internal static class TrackedColorPalette
	{
		internal const int SlotCount = 5;

		internal static Color GetColor(int slot, float alpha)
		{
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			Color result = default(Color);
			switch (slot)
			{
			case 0:
				((Color)(ref result))..ctor(0.32f, 1f, 0.34f, 1f);
				break;
			case 1:
				((Color)(ref result))..ctor(0.18f, 0.82f, 1f, 1f);
				break;
			case 2:
				((Color)(ref result))..ctor(1f, 0.72f, 0.18f, 1f);
				break;
			case 3:
				((Color)(ref result))..ctor(0.82f, 0.38f, 1f, 1f);
				break;
			case 4:
				((Color)(ref result))..ctor(1f, 0.28f, 0.22f, 1f);
				break;
			default:
				((Color)(ref result))..ctor(0.32f, 1f, 0.34f, 1f);
				break;
			}
			result.a = Mathf.Clamp01(alpha);
			return result;
		}

		internal static string GetName(int slot)
		{
			return slot switch
			{
				0 => "Green", 
				1 => "Cyan", 
				2 => "Gold", 
				3 => "Violet", 
				4 => "Red", 
				_ => "Green", 
			};
		}
	}
}