using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using HexResourceTracker.Core;
using HexResourceTracker.Core.PinManagers;
using HexResourceTracker.Core.Tracking;
using HexResourceTracker.Models;
using HexResourceTracker.UI;
using Splatform;
using TMPro;
using UnityEngine;
using UnityEngine.EventSystems;
using UnityEngine.Events;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("HexResourceTracker")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("HexResourceTracker")]
[assembly: AssemblyCopyright("Copyright ©  2026")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("8e0d6812-c80a-4f2c-a0a3-1a47b8270a86")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: AssemblyVersion("1.0.0.0")]
internal class ResourcePinModel
{
	internal ZDOID ZdoId { get; }

	internal TrackedResourceDefinition ResourceDefinition { get; }

	internal string IconItemPrefabName { get; }

	internal Vector3 Position { get; }

	internal PinData Pin { get; set; }

	internal RectTransform LastSizedUiElement { get; set; }

	internal float LastAppliedSize { get; set; } = -1f;

	internal ResourcePinModel(ZDOID zdoId, TrackedResourceDefinition resourceDefinition, string iconItemPrefabName, Vector3 position)
	{
		//IL_0012: 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_0027: 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)
		ZdoId = zdoId;
		ResourceDefinition = resourceDefinition;
		IconItemPrefabName = iconItemPrefabName;
		Position = position;
	}
}
namespace HexResourceTracker
{
	internal class DungeonPinModel
	{
		internal Theme Theme { get; }

		internal string LocationPrefabName { get; }

		internal Vector3 Position { get; }

		internal bool IsChecked { get; set; }

		internal PinData Pin { get; set; }

		internal DungeonPinModel(Theme theme, string locationPrefabName, Vector3 position)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: 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)
			Theme = theme;
			LocationPrefabName = locationPrefabName;
			Position = position;
		}
	}
	[BepInPlugin("com.hex.resourcetracker", "HexResourceTracker", "1.5.0")]
	public class Plugin : BaseUnityPlugin
	{
		private const string PluginGuid = "com.hex.resourcetracker";

		private const string PluginName = "HexResourceTracker";

		private const string PluginVersion = "1.5.0";

		private Harmony _harmonyInstance;

		internal static ManualLogSource Log;

		internal static Plugin Instance;

		private void Awake()
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Expected O, but got Unknown
			Instance = this;
			Log = ((BaseUnityPlugin)this).Logger;
			PluginConfig.Initialize(((BaseUnityPlugin)this).Config);
			Assembly executingAssembly = Assembly.GetExecutingAssembly();
			_harmonyInstance = new Harmony("com.hex.resourcetracker");
			_harmonyInstance.PatchAll(executingAssembly);
			Log.LogInfo((object)"HexResourceTracker v1.5.0 loaded.");
		}

		private void OnDestroy()
		{
			Log.LogInfo((object)"HexResourceTracker v1.5.0 unloaded.");
			Harmony harmonyInstance = _harmonyInstance;
			if (harmonyInstance != null)
			{
				harmonyInstance.UnpatchSelf();
			}
			_harmonyInstance = null;
			Instance = null;
			Log = null;
		}
	}
	internal static class PluginConfig
	{
		private sealed class ConfigurationManagerAttributes
		{
			public int? Order;
		}

		private const string GeneralSection = "General";

		private const string ResourcesSection = "Resources To Track";

		private const string DungeonsSection = "Dungeons To Track";

		private const string TrackingModeSection = "Tracking Mode";

		private const string DungeonLabelsSection = "Dungeon Labels";

		private const string DepositLabelsSection = "Deposit Labels";

		private const int HideLabelOrder = 1000;

		private const int LabelOrder = 900;

		internal static readonly Dictionary<string, ConfigEntry<bool>> ResourceConfigs = new Dictionary<string, ConfigEntry<bool>>();

		internal static readonly Dictionary<Theme, ConfigEntry<bool>> DungeonConfigs = new Dictionary<Theme, ConfigEntry<bool>>();

		internal static readonly Dictionary<string, ConfigEntry<string>> DepositLabelConfigs = new Dictionary<string, ConfigEntry<string>>();

		internal static readonly Dictionary<Theme, ConfigEntry<string>> DungeonLabelConfigs = new Dictionary<Theme, ConfigEntry<string>>();

		internal static ConfigEntry<bool> IsModEnabled { get; private set; }

		internal static ConfigEntry<float> TrackingRange { get; private set; }

		internal static ConfigEntry<TrackingModeEnum> TrackingMode { get; private set; }

		internal static ConfigEntry<bool> HideDungeonLabels { get; private set; }

		internal static ConfigEntry<bool> HideDepositLabels { get; private set; }

		internal static void Initialize(ConfigFile config)
		{
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Expected O, but got Unknown
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Expected O, but got Unknown
			//IL_01ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b6: Expected O, but got Unknown
			IsModEnabled = config.Bind<bool>("General", "Enable", true, "Enable or disable the HexResourceTracker mod.");
			TrackingMode = config.Bind<TrackingModeEnum>("Tracking Mode", "Tracking Mode", TrackingModeEnum.ZoneBased, "Controls how tracked map objects are discovered. ZoneBased adds pins as Valheim loads zones. RangeScanner only displays tracked objects within the configured range of the player.");
			TrackingMode.SettingChanged += delegate
			{
				MapTrackingScanner.HandleTrackingModeChanged();
			};
			TrackingRange = config.Bind<float>("Tracking Mode", "Tracking Range", 50f, new ConfigDescription("Maximum distance in meters from the player to track resources and dungeons when using RangeScanner mode.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(50f, 2000f), Array.Empty<object>()));
			TrackingRange.SettingChanged += delegate
			{
				MapTrackingScanner.ForceRescan();
			};
			HideDungeonLabels = config.Bind<bool>("Dungeon Labels", "Hide Dungeon Labels", false, new ConfigDescription("Hide labels on tracked dungeon pins.", (AcceptableValueBase)null, new object[1]
			{
				new ConfigurationManagerAttributes
				{
					Order = 1000
				}
			}));
			HideDungeonLabels.SettingChanged += delegate
			{
				DungeonPinManager.UpdateDungeonLabels();
			};
			BindDungeonLabel(config, (Theme)8, "Burial Chamber");
			BindDungeonLabel(config, (Theme)2, "Sunken Crypt");
			BindDungeonLabel(config, (Theme)4, "Frost Cave");
			BindDungeonLabel(config, (Theme)128, "Infested Mine");
			BindDungeonLabel(config, (Theme)131072, "Morkhalla");
			BindDungeonLabel(config, (Theme)16384, "Winding Tunnel");
			HideDepositLabels = config.Bind<bool>("Deposit Labels", "Hide Deposit Labels", false, new ConfigDescription("Hide labels on tracked deposit pins.", (AcceptableValueBase)null, new object[1]
			{
				new ConfigurationManagerAttributes
				{
					Order = 1000
				}
			}));
			HideDepositLabels.SettingChanged += delegate
			{
				ResourcePinManager.UpdateDepositLabels();
			};
			foreach (TrackedResourceDefinition item in TrackedResources.AllTrackedResources.OrderBy((TrackedResourceDefinition resource) => resource.SortOrder))
			{
				BindResource(config, item.ResourcePrefabName, item.DisplayName);
				if (item.ResourceType == TrackedResourceTypeEnum.Deposit)
				{
					BindDepositLabel(config, item);
				}
			}
			BindDungeon(config, (Theme)8, "Burial Chambers");
			BindDungeon(config, (Theme)2, "Sunken Crypts");
			BindDungeon(config, (Theme)4, "Frost Caves");
			BindDungeon(config, (Theme)128, "Infested Mines");
			BindDungeon(config, (Theme)131072, "Morkhalla");
			BindDungeon(config, (Theme)16384, "Winding Tunnel");
		}

		internal static bool IsResourceTrackingEnabled(string prefabName)
		{
			if (IsModEnabled.Value && ResourceConfigs.TryGetValue(prefabName, out var value))
			{
				return value.Value;
			}
			return false;
		}

		internal static bool IsDungeonTrackingEnabled(Theme theme)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			if (IsModEnabled.Value && DungeonConfigs.TryGetValue(theme, out var value))
			{
				return value.Value;
			}
			return false;
		}

		internal static string GetDepositLabel(string prefabName)
		{
			if (HideDepositLabels.Value)
			{
				return string.Empty;
			}
			if (!DepositLabelConfigs.TryGetValue(prefabName, out var value))
			{
				return string.Empty;
			}
			return value.Value;
		}

		internal static string GetDungeonLabel(Theme theme)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			if (HideDungeonLabels.Value)
			{
				return string.Empty;
			}
			if (!DungeonLabelConfigs.TryGetValue(theme, out var value))
			{
				return string.Empty;
			}
			return value.Value;
		}

		private static void BindResource(ConfigFile config, string prefabName, string displayName)
		{
			ConfigEntry<bool> entry = config.Bind<bool>("Resources To Track", "Track " + displayName, true, "Enable or disable tracking for " + displayName + ".");
			entry.SettingChanged += delegate
			{
				ResourceTrackerMapOverlay.HandleResourceTrackingChanged(prefabName, entry.Value);
				PickableResourcePinService.HandleResourceTrackingChanged(prefabName, entry.Value);
				OreResourcePinService.HandleResourceTrackingChanged(prefabName, entry.Value);
				ContainerResourcePinService.HandleResourceTrackingChanged(prefabName, entry.Value);
			};
			ResourceConfigs[prefabName] = entry;
		}

		private static void BindDepositLabel(ConfigFile config, TrackedResourceDefinition resource)
		{
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Expected O, but got Unknown
			ConfigEntry<string> val = config.Bind<string>("Deposit Labels", resource.DisplayName + " Label", resource.DisplayName, new ConfigDescription("Label displayed for " + resource.DisplayName + " deposits.", (AcceptableValueBase)null, new object[1]
			{
				new ConfigurationManagerAttributes
				{
					Order = 900
				}
			}));
			val.SettingChanged += delegate
			{
				ResourcePinManager.UpdateDepositLabels();
			};
			DepositLabelConfigs[resource.ResourcePrefabName] = val;
		}

		private static void BindDungeonLabel(ConfigFile config, Theme theme, string displayName)
		{
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Expected O, but got Unknown
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			ConfigEntry<string> val = config.Bind<string>("Dungeon Labels", displayName + " Label", displayName, new ConfigDescription("Label displayed for " + displayName + ".", (AcceptableValueBase)null, new object[1]
			{
				new ConfigurationManagerAttributes
				{
					Order = 900
				}
			}));
			val.SettingChanged += delegate
			{
				DungeonPinManager.UpdateDungeonLabels();
			};
			DungeonLabelConfigs[theme] = val;
		}

		private static void BindDungeon(ConfigFile config, Theme theme, string displayName)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			ConfigEntry<bool> entry = config.Bind<bool>("Dungeons To Track", "Track " + displayName, true, "Enable or disable tracking for " + displayName + ".");
			entry.SettingChanged += delegate
			{
				//IL_0001: 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)
				ResourceTrackerMapOverlay.HandleDungeonTrackingChanged(theme, entry.Value);
				DungeonPinManager.HandleDungeonTrackingChanged(theme, entry.Value);
			};
			DungeonConfigs[theme] = entry;
		}
	}
}
namespace HexResourceTracker.UI
{
	internal class ResourceTrackerDragHandler : MonoBehaviour, IBeginDragHandler, IEventSystemHandler, IDragHandler
	{
		private RectTransform _rectTransform;

		private Vector2 _startPanelPosition;

		private Vector2 _startMousePosition;

		private void Awake()
		{
			ref RectTransform rectTransform = ref _rectTransform;
			Transform parent = ((Component)this).transform.parent;
			rectTransform = (RectTransform)(object)((parent is RectTransform) ? parent : null);
		}

		public void OnBeginDrag(PointerEventData eventData)
		{
			//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_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)_rectTransform == (Object)null))
			{
				_startPanelPosition = _rectTransform.anchoredPosition;
				_startMousePosition = eventData.position;
			}
		}

		public void OnDrag(PointerEventData eventData)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)_rectTransform == (Object)null))
			{
				Vector2 val = eventData.position - _startMousePosition;
				_rectTransform.anchoredPosition = _startPanelPosition + val;
			}
		}
	}
	internal static class ResourceTrackerMapOverlay
	{
		private static GameObject _panel;

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

		private static readonly Dictionary<Theme, Toggle> DungeonToggles = new Dictionary<Theme, Toggle>();

		internal static void Create()
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Expected O, but got Unknown
			//IL_0071: 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_009b: 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_00c4: 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)
			if (!((Object)(object)_panel != (Object)null) && !((Object)(object)Minimap.instance == (Object)null) && !((Object)(object)Minimap.instance.m_largeRoot == (Object)null))
			{
				_panel = new GameObject("HexResourceTrackerOverlay");
				_panel.transform.SetParent(Minimap.instance.m_largeRoot.transform, false);
				RectTransform obj = _panel.AddComponent<RectTransform>();
				obj.anchorMin = new Vector2(1f, 1f);
				obj.anchorMax = new Vector2(1f, 1f);
				obj.pivot = new Vector2(1f, 1f);
				obj.anchoredPosition = new Vector2(-20f, -50f);
				obj.sizeDelta = new Vector2(180f, 885f);
				((Graphic)_panel.AddComponent<Image>()).color = new Color(0.22f, 0.16f, 0.1f, 0.75f);
				AddTitle();
				AddSectionHeader("Resources", -32f);
				AddResourceToggle("Pickable_Mushroom", "Mushrooms", -60f);
				AddResourceToggle("Pickable_Dandelion", "Dandelions", -85f);
				AddResourceToggle("RaspberryBush", "Raspberries", -110f);
				AddResourceToggle("BlueberryBush", "Blueberries", -135f);
				AddResourceToggle("Pickable_Thistle", "Thistle", -160f);
				AddResourceToggle("Pickable_SeedCarrot", "Carrot Seeds", -185f);
				AddResourceToggle("Pickable_SeedTurnip", "Turnip Seeds", -210f);
				AddResourceToggle("Pickable_DragonEgg", "Dragon Eggs", -235f);
				AddResourceToggle("OnionSeeds", "Onion Seeds", -260f);
				AddResourceToggle("Pickable_Flax_Wild", "Flax", -285f);
				AddResourceToggle("Pickable_Barley_Wild", "Barley", -310f);
				AddResourceToggle("CloudberryBush", "Cloudberries", -335f);
				AddResourceToggle("Pickable_Mushroom_JotunPuffs", "Jotun Puffs", -360f);
				AddResourceToggle("Pickable_Mushroom_Magecap", "Magecap", -385f);
				AddResourceToggle("VineAsh", "Vineberries", -410f);
				AddResourceToggle("Pickable_SmokePuff", "Smoke Puffs", -435f);
				AddResourceToggle("Pickable_Fiddlehead", "Fiddleheads", -460f);
				AddResourceToggle("LingonberryBush", "Lingonberries", -485f);
				AddResourceToggle("Pickable_SeedKale", "Kale Seeds", -510f);
				AddSectionHeader("Deposits", -540f);
				AddResourceToggle("rock4_copper", "Copper", -568f);
				AddResourceToggle("silvervein", "Silver", -593f);
				AddResourceToggle("giant_skull", "Giant Skull", -618f);
				AddResourceToggle("LeviathanLava", "Flametal", -643f);
				AddSectionHeader("Dungeons", -673f);
				AddDungeonToggle((Theme)8, "Burial Chambers", -701f);
				AddDungeonToggle((Theme)2, "Sunken Crypts", -726f);
				AddDungeonToggle((Theme)4, "Frost Caves", -751f);
				AddDungeonToggle((Theme)128, "Infested Mines", -776f);
				AddDungeonToggle((Theme)131072, "Morkhalla", -801f);
				AddDungeonToggle((Theme)16384, "Winding Tunnels", -826f);
			}
		}

		internal static void HandleResourceTrackingChanged(string prefabName, bool isEnabled)
		{
			if (!string.IsNullOrWhiteSpace(prefabName) && ResourceToggles.TryGetValue(prefabName, out var value) && (Object)(object)value != (Object)null)
			{
				value.SetIsOnWithoutNotify(isEnabled);
			}
		}

		internal static void HandleDungeonTrackingChanged(Theme theme, bool isEnabled)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			if (DungeonToggles.TryGetValue(theme, out var value) && (Object)(object)value != (Object)null)
			{
				value.SetIsOnWithoutNotify(isEnabled);
			}
		}

		private static void AddTitle()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Expected O, but got Unknown
			//IL_0032: 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_005c: 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_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: 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_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_013f: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("Title");
			val.transform.SetParent(_panel.transform, false);
			RectTransform obj = val.AddComponent<RectTransform>();
			obj.anchorMin = new Vector2(0f, 1f);
			obj.anchorMax = new Vector2(1f, 1f);
			obj.pivot = new Vector2(0.5f, 1f);
			obj.anchoredPosition = Vector2.zero;
			obj.sizeDelta = new Vector2(0f, 28f);
			Image obj2 = val.AddComponent<Image>();
			((Graphic)obj2).color = new Color(0.1f, 0.07f, 0.04f, 0.95f);
			((Graphic)obj2).raycastTarget = true;
			val.AddComponent<ResourceTrackerDragHandler>();
			GameObject val2 = new GameObject("TitleText");
			val2.transform.SetParent(val.transform, false);
			RectTransform obj3 = val2.AddComponent<RectTransform>();
			obj3.anchorMin = Vector2.zero;
			obj3.anchorMax = Vector2.one;
			obj3.offsetMin = Vector2.zero;
			obj3.offsetMax = Vector2.zero;
			TextMeshProUGUI obj4 = val2.AddComponent<TextMeshProUGUI>();
			((TMP_Text)obj4).font = Minimap.instance.m_biomeNameLarge.font;
			((TMP_Text)obj4).text = "Map Tracking";
			((TMP_Text)obj4).fontSize = 12f;
			((TMP_Text)obj4).alignment = (TextAlignmentOptions)514;
			((Graphic)obj4).color = Color.white;
			AddSeparator(val);
		}

		private static void AddSectionHeader(string text, float yPosition)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Expected O, but got Unknown
			//IL_0038: 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_0062: 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)
			//IL_0087: 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_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: 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_0140: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject(text + "Header");
			val.transform.SetParent(_panel.transform, false);
			RectTransform obj = val.AddComponent<RectTransform>();
			obj.anchorMin = new Vector2(0f, 1f);
			obj.anchorMax = new Vector2(1f, 1f);
			obj.pivot = new Vector2(0.5f, 1f);
			obj.anchoredPosition = new Vector2(0f, yPosition);
			obj.sizeDelta = new Vector2(0f, 24f);
			Image obj2 = val.AddComponent<Image>();
			((Graphic)obj2).color = new Color(0.14f, 0.1f, 0.06f, 0.9f);
			((Graphic)obj2).raycastTarget = false;
			GameObject val2 = new GameObject("Text");
			val2.transform.SetParent(val.transform, false);
			RectTransform obj3 = val2.AddComponent<RectTransform>();
			obj3.anchorMin = Vector2.zero;
			obj3.anchorMax = Vector2.one;
			obj3.offsetMin = Vector2.zero;
			obj3.offsetMax = Vector2.zero;
			TextMeshProUGUI obj4 = val2.AddComponent<TextMeshProUGUI>();
			((TMP_Text)obj4).font = Minimap.instance.m_biomeNameLarge.font;
			((TMP_Text)obj4).text = text;
			((TMP_Text)obj4).fontSize = 12f;
			((TMP_Text)obj4).alignment = (TextAlignmentOptions)514;
			((Graphic)obj4).color = Color.white;
			AddSeparator(val);
		}

		private static void AddSeparator(GameObject parent)
		{
			//IL_0005: 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)
			//IL_001c: 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_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: 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_008f: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("Separator");
			val.transform.SetParent(parent.transform, false);
			RectTransform obj = val.AddComponent<RectTransform>();
			obj.anchorMin = new Vector2(0f, 0f);
			obj.anchorMax = new Vector2(1f, 0f);
			obj.pivot = new Vector2(0.5f, 0f);
			obj.sizeDelta = new Vector2(0f, 2f);
			Image obj2 = val.AddComponent<Image>();
			((Graphic)obj2).color = new Color(0.6f, 0.5f, 0.3f, 0.8f);
			((Graphic)obj2).raycastTarget = false;
		}

		private static void AddResourceToggle(string prefabName, string displayName, float yPosition)
		{
			Toggle val = CreateToggle(prefabName + "_Toggle", displayName, yPosition);
			bool value = PluginConfig.ResourceConfigs[prefabName].Value;
			val.SetIsOnWithoutNotify(value);
			ResourceToggles[prefabName] = val;
			((UnityEvent<bool>)(object)val.onValueChanged).AddListener((UnityAction<bool>)delegate(bool value2)
			{
				PluginConfig.ResourceConfigs[prefabName].Value = value2;
			});
		}

		private static void AddDungeonToggle(Theme theme, string displayName, float yPosition)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: 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_004d: Unknown result type (might be due to invalid IL or missing references)
			Toggle val = CreateToggle($"{theme}_Toggle", displayName, yPosition);
			bool value = PluginConfig.DungeonConfigs[theme].Value;
			val.SetIsOnWithoutNotify(value);
			DungeonToggles[theme] = val;
			((UnityEvent<bool>)(object)val.onValueChanged).AddListener((UnityAction<bool>)delegate(bool value2)
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				PluginConfig.DungeonConfigs[theme].Value = value2;
			});
		}

		private static Toggle CreateToggle(string objectName, string displayName, float yPosition)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			//IL_002e: 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_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: 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_0098: Expected O, but got Unknown
			//IL_00bb: 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_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_010e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0120: 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_0134: Unknown result type (might be due to invalid IL or missing references)
			//IL_0146: Unknown result type (might be due to invalid IL or missing references)
			//IL_014d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0158: 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_0181: Unknown result type (might be due to invalid IL or missing references)
			//IL_0192: Unknown result type (might be due to invalid IL or missing references)
			//IL_01af: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c6: 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)
			//IL_01d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_0201: Unknown result type (might be due to invalid IL or missing references)
			//IL_0242: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject(objectName);
			val.transform.SetParent(_panel.transform, false);
			RectTransform obj = val.AddComponent<RectTransform>();
			obj.anchorMin = new Vector2(0f, 1f);
			obj.anchorMax = new Vector2(1f, 1f);
			obj.pivot = new Vector2(0.5f, 1f);
			obj.anchoredPosition = new Vector2(0f, yPosition);
			obj.sizeDelta = new Vector2(0f, 24f);
			Toggle obj2 = val.AddComponent<Toggle>();
			GameObject val2 = new GameObject("Background");
			val2.transform.SetParent(val.transform, false);
			RectTransform obj3 = val2.AddComponent<RectTransform>();
			obj3.anchorMin = new Vector2(0f, 0.5f);
			obj3.anchorMax = new Vector2(0f, 0.5f);
			obj3.pivot = new Vector2(0f, 0.5f);
			obj3.anchoredPosition = new Vector2(12f, 0f);
			obj3.sizeDelta = new Vector2(14f, 14f);
			Image val3 = val2.AddComponent<Image>();
			((Graphic)val3).color = Color.white;
			GameObject val4 = new GameObject("Checkmark");
			val4.transform.SetParent(val2.transform, false);
			RectTransform obj4 = val4.AddComponent<RectTransform>();
			obj4.anchorMin = Vector2.zero;
			obj4.anchorMax = Vector2.one;
			obj4.offsetMin = new Vector2(3f, 3f);
			obj4.offsetMax = new Vector2(-3f, -3f);
			Image val5 = val4.AddComponent<Image>();
			((Graphic)val5).color = Color.green;
			((Selectable)obj2).targetGraphic = (Graphic)(object)val3;
			obj2.graphic = (Graphic)(object)val5;
			GameObject val6 = new GameObject("Label");
			val6.transform.SetParent(val.transform, false);
			RectTransform obj5 = val6.AddComponent<RectTransform>();
			obj5.anchorMin = Vector2.zero;
			obj5.anchorMax = Vector2.one;
			obj5.offsetMin = new Vector2(34f, 0f);
			obj5.offsetMax = new Vector2(-10f, 0f);
			TextMeshProUGUI obj6 = val6.AddComponent<TextMeshProUGUI>();
			((TMP_Text)obj6).font = Minimap.instance.m_biomeNameLarge.font;
			((TMP_Text)obj6).text = displayName;
			((TMP_Text)obj6).fontSize = 14f;
			((TMP_Text)obj6).alignment = (TextAlignmentOptions)513;
			((Graphic)obj6).color = Color.white;
			return obj2;
		}
	}
}
namespace HexResourceTracker.Patches
{
	[HarmonyPatch(typeof(Container), "Awake")]
	internal static class PatchContainerAwake
	{
		private const string MountainChestPrefabName = "TreasureChest_mountains";

		private static void Postfix(Container __instance)
		{
			if (PluginConfig.IsModEnabled.Value && !((Object)(object)__instance == (Object)null) && !(((Object)((Component)__instance).gameObject).name.Replace("(Clone)", string.Empty).Trim() != "TreasureChest_mountains"))
			{
				TrackedMapObject.TryAdd(((Component)__instance).gameObject, "OnionSeeds");
				TrackedMapObject trackedObject = default(TrackedMapObject);
				if (PluginConfig.TrackingMode.Value == TrackingModeEnum.ZoneBased && ((Component)__instance).gameObject.TryGetComponent<TrackedMapObject>(ref trackedObject))
				{
					ContainerResourcePinService.ReconcileTrackedContainer(trackedObject);
				}
			}
		}
	}
	[HarmonyPatch(typeof(Container), "OnContainerChanged")]
	internal static class PatchContainerOnContainerChanged
	{
		private const string MountainChestPrefabName = "TreasureChest_mountains";

		private static void Postfix(Container __instance)
		{
			TrackedMapObject trackedObject = default(TrackedMapObject);
			if (PluginConfig.IsModEnabled.Value && !((Object)(object)__instance == (Object)null) && !(((Object)((Component)__instance).gameObject).name.Replace("(Clone)", string.Empty).Trim() != "TreasureChest_mountains") && ((Component)__instance).gameObject.TryGetComponent<TrackedMapObject>(ref trackedObject))
			{
				ContainerResourcePinService.ReconcileTrackedContainer(trackedObject);
			}
		}
	}
	[HarmonyPatch(typeof(Destructible), "Awake")]
	internal static class PatchDestructibleAwake
	{
		private static void Postfix(Destructible __instance)
		{
			if (!PluginConfig.IsModEnabled.Value || (Object)(object)__instance == (Object)null)
			{
				return;
			}
			string text = ((Object)((Component)__instance).gameObject).name.Replace("(Clone)", string.Empty).Trim();
			if (TrackedResourceDefinitions.DestructibleResourcesByPrefabName.ContainsKey(text))
			{
				TrackedMapObject.TryAdd(((Component)__instance).gameObject, text);
				if (PluginConfig.TrackingMode.Value != TrackingModeEnum.RangeScanner)
				{
					OreResourcePinService.TryAddResourcePinFromDestructibleOre(__instance);
				}
			}
		}
	}
	[HarmonyPatch(typeof(Destructible), "Destroy")]
	internal static class PatchDestructibleDestroy
	{
		private static void Prefix(Destructible __instance)
		{
			if (PluginConfig.IsModEnabled.Value && !((Object)(object)__instance == (Object)null))
			{
				OreResourcePinService.TryRemoveResourcePinFromDestructibleOre(__instance);
			}
		}
	}
	[HarmonyPatch(typeof(Location), "Awake")]
	internal static class PatchLocationAwake
	{
		private static void Postfix(Location __instance)
		{
			if (PluginConfig.IsModEnabled.Value && !((Object)(object)__instance == (Object)null))
			{
				TrackedDungeonLocation.TryAdd(__instance);
				if (PluginConfig.TrackingMode.Value != TrackingModeEnum.RangeScanner)
				{
					DungeonPinManager.TryAddDungeonPin(__instance);
				}
			}
		}
	}
	[HarmonyPatch(typeof(MineRock), "AllDestroyed")]
	internal static class PatchMineRockAllDestroyed
	{
		private static void Postfix(MineRock __instance, bool __result)
		{
			if (PluginConfig.IsModEnabled.Value && !((Object)(object)__instance == (Object)null) && __result)
			{
				OreResourcePinService.TryRemoveResourcePinFromMineRock(__instance);
			}
		}
	}
	[HarmonyPatch(typeof(MineRock), "Start")]
	internal static class PatchMineRockStart
	{
		private static void Postfix(MineRock __instance)
		{
			if (PluginConfig.IsModEnabled.Value && !((Object)(object)__instance == (Object)null) && TrackedResourceDefinitions.MineRockResourcesByName.TryGetValue(__instance.m_name, out var value))
			{
				TrackedMapObject.TryAdd(((Component)__instance).gameObject, value.ResourcePrefabName);
				if (PluginConfig.TrackingMode.Value != TrackingModeEnum.RangeScanner)
				{
					OreResourcePinService.TryAddResourcePinFromMineRock(__instance);
				}
			}
		}
	}
	[HarmonyPatch(typeof(Minimap), "OnMapLeftClick")]
	internal static class PatchMinimapOnMapLeftClick
	{
		[HarmonyPostfix]
		private static void Postfix()
		{
			DungeonPinManager.UpdateCheckedStates();
		}
	}
	[HarmonyPatch(typeof(Minimap), "RemovePin", new Type[]
	{
		typeof(Vector3),
		typeof(float)
	})]
	internal static class PatchMinimapRemovePin
	{
		private static bool Prefix(Vector3 pos, float radius, ref bool __result)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			if (!PluginConfig.IsModEnabled.Value)
			{
				return true;
			}
			if (ResourcePinManager.RemoveClosestResourcePin(pos, radius))
			{
				__result = true;
				return false;
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(Minimap), "Start")]
	internal static class PatchMinimapStart
	{
		private static void Postfix()
		{
			if (PluginConfig.IsModEnabled.Value)
			{
				ResourceTrackerMapOverlay.Create();
			}
		}
	}
	[HarmonyPatch(typeof(Pickable), "SetPicked")]
	internal static class PatchPickableSetPicked
	{
		private static void Prefix(Pickable __instance, bool picked, ref ZDOID __state)
		{
			//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_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			if (!PluginConfig.IsModEnabled.Value)
			{
				return;
			}
			__state = ZDOID.None;
			if (!picked || (Object)(object)__instance == (Object)null)
			{
				return;
			}
			ZNetView component = ((Component)__instance).GetComponent<ZNetView>();
			if (!((Object)(object)component == (Object)null))
			{
				ZDO zDO = component.GetZDO();
				if (zDO != null)
				{
					__state = zDO.m_uid;
				}
			}
		}

		private static void Postfix(Pickable __instance, bool picked, ZDOID __state)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			if (!PluginConfig.IsModEnabled.Value)
			{
				return;
			}
			if (picked)
			{
				if (!(__state == ZDOID.None))
				{
					ResourcePinManager.RemoveResourcePin(__state);
				}
			}
			else if (PluginConfig.TrackingMode.Value != TrackingModeEnum.RangeScanner)
			{
				PickableResourcePinService.TryAddResourcePinFromPickable(__instance);
			}
		}
	}
	[HarmonyPatch(typeof(Pickable), "Awake")]
	internal static class PatchPickableAwake
	{
		private static void Postfix(Pickable __instance)
		{
			if (PluginConfig.IsModEnabled.Value)
			{
				string text = ((Object)((Component)__instance).gameObject).name.Replace("(Clone)", string.Empty).Trim();
				if (PluginConfig.ResourceConfigs.ContainsKey(text))
				{
					TrackedMapObject.TryAdd(((Component)__instance).gameObject, text);
				}
				if (PluginConfig.TrackingMode.Value != TrackingModeEnum.RangeScanner)
				{
					PickableResourcePinService.TryAddResourcePinFromPickable(__instance);
				}
			}
		}
	}
	[HarmonyPatch(typeof(Player), "SetLocalPlayer")]
	internal static class PatchPlayerSetLocalPlayer
	{
		private static void Postfix()
		{
			if (PluginConfig.IsModEnabled.Value)
			{
				MapTrackingScanner.HandleTrackingModeChanged();
			}
		}
	}
	[HarmonyPatch(typeof(Minimap), "UpdatePins")]
	internal static class PatchMinimapUpdatePins
	{
		private static void Postfix(Minimap __instance)
		{
			if (PluginConfig.IsModEnabled.Value)
			{
				ResourcePinManager.UpdateResourcePinVisuals(__instance);
			}
		}
	}
}
namespace HexResourceTracker.Models
{
	[Obsolete("Delete this class after refactor")]
	internal class ResourceDefinitionModel
	{
		internal string ResourcePrefabName { get; }

		internal string ItemPrefabName { get; }

		internal ResourceDefinitionModel(string resourcePrefabName, string itemPrefabName)
		{
			ResourcePrefabName = resourcePrefabName;
			ItemPrefabName = itemPrefabName;
		}
	}
	internal sealed class TrackedResourceDefinition
	{
		internal string ResourcePrefabName { get; }

		internal string DisplayName { get; }

		internal int SortOrder { get; }

		internal TrackedResourceTypeEnum ResourceType { get; }

		internal string IconItemPrefabName { get; }

		internal string MineRock5Name { get; }

		internal string MineRockName { get; }

		internal TrackedResourceDefinition(string resourcePrefabName, string displayName, int sortOrder, TrackedResourceTypeEnum resourceType, string iconItemPrefabName = null, string mineRock5Name = null, string mineRockName = null)
		{
			ResourcePrefabName = resourcePrefabName;
			DisplayName = displayName;
			SortOrder = sortOrder;
			ResourceType = resourceType;
			IconItemPrefabName = iconItemPrefabName;
			MineRock5Name = mineRock5Name;
			MineRockName = mineRockName;
		}
	}
	internal enum TrackedResourceTypeEnum
	{
		Pickable,
		Deposit,
		Container
	}
}
namespace HexResourceTracker.Core
{
	internal static class ContainerResourcePinService
	{
		internal static void ReconcileTrackedContainer(TrackedMapObject trackedObject)
		{
			//IL_0055: 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_006f: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)trackedObject == (Object)null || (Object)(object)trackedObject.Container == (Object)null || (Object)(object)trackedObject.ZNetView == (Object)null)
			{
				return;
			}
			ZDO zDO = trackedObject.ZNetView.GetZDO();
			if (zDO != null)
			{
				if (!TryGetTrackedContainerResource(trackedObject.Container, out var definition, out var iconItemPrefabName) || !PluginConfig.IsResourceTrackingEnabled(definition.ResourcePrefabName))
				{
					ResourcePinManager.RemoveResourcePin(zDO.m_uid);
				}
				else
				{
					ResourcePinManager.TryAddResourcePin(new ResourcePinModel(zDO.m_uid, definition, iconItemPrefabName, ((Component)trackedObject).transform.position));
				}
			}
		}

		internal static void HandleResourceTrackingChanged(string prefabName, bool isEnabled)
		{
			if (!TrackedResources.TryGetByPrefabName(prefabName, out var definition) || definition.ResourceType != TrackedResourceTypeEnum.Container)
			{
				return;
			}
			if (!isEnabled)
			{
				ResourcePinManager.RemoveResourcePins(definition.ResourcePrefabName);
				return;
			}
			foreach (TrackedMapObject trackedObject in TrackedMapObject.GetTrackedObjects())
			{
				if (!((Object)(object)trackedObject == (Object)null) && !((Object)(object)trackedObject.Container == (Object)null))
				{
					ReconcileTrackedContainer(trackedObject);
				}
			}
		}

		private static bool TryGetTrackedContainerResource(Container container, out TrackedResourceDefinition definition, out string iconItemPrefabName)
		{
			Inventory inventory = container.GetInventory();
			if (inventory == null)
			{
				definition = null;
				iconItemPrefabName = null;
				return false;
			}
			foreach (ItemData allItem in inventory.GetAllItems())
			{
				if (!((Object)(object)allItem.m_dropPrefab == (Object)null))
				{
					string name = ((Object)allItem.m_dropPrefab).name;
					if (TrackedResources.TryGetByPrefabName(name, out definition) && definition.ResourceType == TrackedResourceTypeEnum.Container)
					{
						iconItemPrefabName = name;
						return true;
					}
				}
			}
			definition = null;
			iconItemPrefabName = null;
			return false;
		}
	}
	internal static class OreResourcePinService
	{
		private const float ResourcePinRadius = 35f;

		private static readonly MethodInfo MineRockAllDestroyedMethod = AccessTools.Method(typeof(MineRock), "AllDestroyed", (Type[])null, (Type[])null);

		internal static bool TryAddResourcePinFromDestructibleOre(Destructible destructible)
		{
			//IL_0081: 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)
			if ((Object)(object)destructible == (Object)null || (Object)(object)Minimap.instance == (Object)null)
			{
				return false;
			}
			if (!TrackedResources.TryGetByPrefabName(((Object)((Component)destructible).gameObject).name.Replace("(Clone)", string.Empty).Trim(), out var definition) || definition.ResourceType != TrackedResourceTypeEnum.Deposit)
			{
				return false;
			}
			if (!PluginConfig.IsResourceTrackingEnabled(definition.ResourcePrefabName))
			{
				return false;
			}
			ZNetView component = ((Component)destructible).GetComponent<ZNetView>();
			if ((Object)(object)component == (Object)null || !component.IsValid())
			{
				return false;
			}
			ZDO zDO = component.GetZDO();
			if (zDO == null)
			{
				return false;
			}
			return ResourcePinManager.TryAddResourcePin(new ResourcePinModel(zDO.m_uid, definition, definition.IconItemPrefabName, ((Component)destructible).transform.position));
		}

		internal static bool TryAddOrRelinkResourcePinFromMineRock5Ore(MineRock5 mineRock)
		{
			//IL_0068: 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_0093: 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)
			if ((Object)(object)mineRock == (Object)null || (Object)(object)Minimap.instance == (Object)null)
			{
				return false;
			}
			if (!TrackedResources.TryGetByMineRock5(mineRock.m_name, out var definition) || definition.ResourceType != TrackedResourceTypeEnum.Deposit)
			{
				return false;
			}
			if (!PluginConfig.IsResourceTrackingEnabled(definition.ResourcePrefabName))
			{
				return false;
			}
			ZNetView component = ((Component)mineRock).GetComponent<ZNetView>();
			if ((Object)(object)component == (Object)null || !component.IsValid())
			{
				return false;
			}
			ZDO zDO = component.GetZDO();
			if (zDO == null)
			{
				return false;
			}
			if (ResourcePinManager.HasResourcePin(zDO.m_uid))
			{
				return true;
			}
			ResourcePinManager.RemoveClosestResourcePin(definition.ResourcePrefabName, ((Component)mineRock).transform.position, 35f);
			return ResourcePinManager.TryAddResourcePin(new ResourcePinModel(zDO.m_uid, definition, definition.IconItemPrefabName, ((Component)mineRock).transform.position));
		}

		internal static bool TryAddResourcePinFromMineRock(MineRock mineRock)
		{
			//IL_007e: 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_0070: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)mineRock == (Object)null || (Object)(object)Minimap.instance == (Object)null)
			{
				return false;
			}
			if (!TrackedResources.TryGetByMineRock(mineRock.m_name, out var definition) || definition.ResourceType != TrackedResourceTypeEnum.Deposit)
			{
				return false;
			}
			if (!PluginConfig.IsResourceTrackingEnabled(definition.ResourcePrefabName))
			{
				return false;
			}
			ZNetView component = ((Component)mineRock).GetComponent<ZNetView>();
			if ((Object)(object)component == (Object)null || !component.IsValid())
			{
				return false;
			}
			ZDO zDO = component.GetZDO();
			if (zDO == null)
			{
				return false;
			}
			if (IsMineRockFullyDestroyed(mineRock))
			{
				ResourcePinManager.RemoveResourcePin(zDO.m_uid);
				return false;
			}
			return ResourcePinManager.TryAddResourcePin(new ResourcePinModel(zDO.m_uid, definition, definition.IconItemPrefabName, ((Component)mineRock).transform.position));
		}

		internal static bool TryRemoveResourcePinFromDestructibleOre(Destructible destructible)
		{
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)destructible == (Object)null)
			{
				return false;
			}
			if (!TrackedResources.TryGetByPrefabName(((Object)((Component)destructible).gameObject).name.Replace("(Clone)", string.Empty).Trim(), out var definition) || definition.ResourceType != TrackedResourceTypeEnum.Deposit)
			{
				return false;
			}
			ZNetView component = ((Component)destructible).GetComponent<ZNetView>();
			if ((Object)(object)component == (Object)null || !component.IsValid())
			{
				return false;
			}
			ZDO zDO = component.GetZDO();
			if (zDO == null)
			{
				return false;
			}
			return ResourcePinManager.RemoveResourcePin(zDO.m_uid);
		}

		internal static bool TryRemoveResourcePinFromMineRock(MineRock mineRock)
		{
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)mineRock == (Object)null)
			{
				return false;
			}
			if (!TrackedResources.TryGetByMineRock(mineRock.m_name, out var definition) || definition.ResourceType != TrackedResourceTypeEnum.Deposit)
			{
				return false;
			}
			ZNetView component = ((Component)mineRock).GetComponent<ZNetView>();
			if ((Object)(object)component == (Object)null || !component.IsValid())
			{
				return false;
			}
			ZDO zDO = component.GetZDO();
			if (zDO == null)
			{
				return false;
			}
			return ResourcePinManager.RemoveResourcePin(zDO.m_uid);
		}

		internal static void HandleResourceTrackingChanged(string prefabName, bool isEnabled)
		{
			if (!string.IsNullOrWhiteSpace(prefabName) && TrackedResources.TryGetByPrefabName(prefabName, out var definition) && definition.ResourceType == TrackedResourceTypeEnum.Deposit)
			{
				if (!isEnabled)
				{
					ResourcePinManager.RemoveResourcePins(prefabName);
				}
				else if (!((Object)(object)Minimap.instance == (Object)null))
				{
					RescanLoadedDestructibles(prefabName);
					RescanLoadedMineRock5(prefabName);
					RescanLoadedMineRock(prefabName);
				}
			}
		}

		internal static void ReconcileTrackedOre(TrackedMapObject trackedObject)
		{
			//IL_0045: 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_00a5: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)trackedObject == (Object)null)
			{
				return;
			}
			ZNetView zNetView = trackedObject.ZNetView;
			if ((Object)(object)zNetView == (Object)null || !zNetView.IsValid())
			{
				return;
			}
			ZDO zDO = zNetView.GetZDO();
			if (zDO == null)
			{
				return;
			}
			if ((Object)(object)trackedObject.Destructible != (Object)null)
			{
				if (!trackedObject.IsInTrackingRange)
				{
					ResourcePinManager.RemoveResourcePin(zDO.m_uid);
				}
				else
				{
					TryAddResourcePinFromDestructibleOre(trackedObject.Destructible);
				}
			}
			else if ((Object)(object)trackedObject.MineRock5 != (Object)null)
			{
				if (!trackedObject.IsInTrackingRange)
				{
					ResourcePinManager.RemoveResourcePin(zDO.m_uid);
				}
				else
				{
					TryAddOrRelinkResourcePinFromMineRock5Ore(trackedObject.MineRock5);
				}
			}
			else if ((Object)(object)trackedObject.MineRock != (Object)null)
			{
				if (!trackedObject.IsInTrackingRange)
				{
					ResourcePinManager.RemoveResourcePin(zDO.m_uid);
				}
				else
				{
					TryAddResourcePinFromMineRock(trackedObject.MineRock);
				}
			}
		}

		private static void RescanLoadedDestructibles(string prefabName)
		{
			Destructible[] array = Object.FindObjectsByType<Destructible>((FindObjectsSortMode)0);
			foreach (Destructible val in array)
			{
				if (!((Object)(object)val == (Object)null) && !(((Object)((Component)val).gameObject).name.Replace("(Clone)", string.Empty).Trim() != prefabName))
				{
					TryAddResourcePinFromDestructibleOre(val);
				}
			}
		}

		private static void RescanLoadedMineRock5(string prefabName)
		{
			MineRock5[] array = Object.FindObjectsByType<MineRock5>((FindObjectsSortMode)0);
			foreach (MineRock5 val in array)
			{
				if (!((Object)(object)val == (Object)null) && TrackedResources.TryGetByMineRock5(val.m_name, out var definition) && !(definition.ResourcePrefabName != prefabName))
				{
					TryAddOrRelinkResourcePinFromMineRock5Ore(val);
				}
			}
		}

		private static void RescanLoadedMineRock(string prefabName)
		{
			MineRock[] array = Object.FindObjectsByType<MineRock>((FindObjectsSortMode)0);
			foreach (MineRock val in array)
			{
				if (!((Object)(object)val == (Object)null) && TrackedResources.TryGetByMineRock(val.m_name, out var definition) && !(definition.ResourcePrefabName != prefabName))
				{
					TryAddResourcePinFromMineRock(val);
				}
			}
		}

		private static bool IsMineRockFullyDestroyed(MineRock mineRock)
		{
			if ((Object)(object)mineRock == (Object)null || MineRockAllDestroyedMethod == null)
			{
				return false;
			}
			object obj = MineRockAllDestroyedMethod.Invoke(mineRock, null);
			bool flag = default(bool);
			int num;
			if (obj is bool)
			{
				flag = (bool)obj;
				num = 1;
			}
			else
			{
				num = 0;
			}
			return (byte)((uint)num & (flag ? 1u : 0u)) != 0;
		}
	}
	internal static class PickableResourcePinService
	{
		internal static bool TryAddResourcePinFromPickable(Pickable pickable)
		{
			//IL_0098: 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)
			if ((Object)(object)pickable == (Object)null || (Object)(object)Minimap.instance == (Object)null || (Object)(object)pickable.m_itemPrefab == (Object)null)
			{
				return false;
			}
			ZNetView component = ((Component)pickable).GetComponent<ZNetView>();
			if ((Object)(object)component == (Object)null || !component.IsValid())
			{
				return false;
			}
			if (!pickable.CanBePicked())
			{
				return false;
			}
			if (!TrackedResources.TryGetByPrefabName(((Object)((Component)pickable).gameObject).name.Replace("(Clone)", string.Empty).Trim(), out var definition) || definition.ResourceType != TrackedResourceTypeEnum.Pickable)
			{
				return false;
			}
			if (!PluginConfig.IsResourceTrackingEnabled(definition.ResourcePrefabName))
			{
				return false;
			}
			ZDO zDO = component.GetZDO();
			if (zDO == null)
			{
				return false;
			}
			return ResourcePinManager.TryAddResourcePin(new ResourcePinModel(zDO.m_uid, definition, ((Object)pickable.m_itemPrefab).name, ((Component)pickable).transform.position));
		}

		internal static void HandleResourceTrackingChanged(string prefabName, bool isEnabled)
		{
			if (string.IsNullOrWhiteSpace(prefabName) || !TrackedResources.TryGetByPrefabName(prefabName, out var definition) || definition.ResourceType != TrackedResourceTypeEnum.Pickable)
			{
				return;
			}
			if (!isEnabled)
			{
				ResourcePinManager.RemoveResourcePins(definition.ResourcePrefabName);
			}
			else
			{
				if ((Object)(object)Minimap.instance == (Object)null)
				{
					return;
				}
				Pickable[] array = Object.FindObjectsByType<Pickable>((FindObjectsSortMode)0);
				foreach (Pickable val in array)
				{
					if (!((Object)(object)val == (Object)null) && !(((Object)((Component)val).gameObject).name.Replace("(Clone)", string.Empty).Trim() != definition.ResourcePrefabName))
					{
						TryAddResourcePinFromPickable(val);
					}
				}
			}
		}

		internal static void ReconcileTrackedPickable(TrackedMapObject trackedObject)
		{
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)trackedObject == (Object)null || (Object)(object)trackedObject.Pickable == (Object)null)
			{
				return;
			}
			ZNetView zNetView = trackedObject.ZNetView;
			if ((Object)(object)zNetView == (Object)null || !zNetView.IsValid())
			{
				return;
			}
			ZDO zDO = zNetView.GetZDO();
			if (zDO != null)
			{
				if (!trackedObject.IsInTrackingRange)
				{
					ResourcePinManager.RemoveResourcePin(zDO.m_uid);
				}
				else
				{
					TryAddResourcePinFromPickable(trackedObject.Pickable);
				}
			}
		}
	}
	internal static class TrackedResources
	{
		internal static readonly List<TrackedResourceDefinition> AllTrackedResources;

		private static readonly Dictionary<string, TrackedResourceDefinition> ByPrefabName;

		private static readonly Dictionary<string, TrackedResourceDefinition> ByMineRock5Name;

		private static readonly Dictionary<string, TrackedResourceDefinition> ByMineRockName;

		static TrackedResources()
		{
			AllTrackedResources = new List<TrackedResourceDefinition>
			{
				new TrackedResourceDefinition("Pickable_Mushroom", "Mushrooms", 100, TrackedResourceTypeEnum.Pickable),
				new TrackedResourceDefinition("Pickable_Dandelion", "Dandelions", 110, TrackedResourceTypeEnum.Pickable),
				new TrackedResourceDefinition("RaspberryBush", "Raspberries", 120, TrackedResourceTypeEnum.Pickable),
				new TrackedResourceDefinition("BlueberryBush", "Blueberries", 200, TrackedResourceTypeEnum.Pickable),
				new TrackedResourceDefinition("Pickable_Thistle", "Thistle", 210, TrackedResourceTypeEnum.Pickable),
				new TrackedResourceDefinition("Pickable_SeedCarrot", "Carrot Seeds", 220, TrackedResourceTypeEnum.Pickable),
				new TrackedResourceDefinition("rock4_copper", "Copper", 230, TrackedResourceTypeEnum.Deposit, "CopperOre", "$piece_deposit_copper"),
				new TrackedResourceDefinition("Pickable_SeedTurnip", "Turnip Seeds", 300, TrackedResourceTypeEnum.Pickable),
				new TrackedResourceDefinition("Pickable_DragonEgg", "Dragon Eggs", 400, TrackedResourceTypeEnum.Pickable),
				new TrackedResourceDefinition("OnionSeeds", "Onion Seeds", 410, TrackedResourceTypeEnum.Container),
				new TrackedResourceDefinition("silvervein", "Silver", 420, TrackedResourceTypeEnum.Deposit, "SilverOre", "$piece_deposit_silvervein"),
				new TrackedResourceDefinition("Pickable_Flax_Wild", "Flax", 500, TrackedResourceTypeEnum.Pickable),
				new TrackedResourceDefinition("Pickable_Barley_Wild", "Barley", 510, TrackedResourceTypeEnum.Pickable),
				new TrackedResourceDefinition("CloudberryBush", "Cloudberries", 520, TrackedResourceTypeEnum.Pickable),
				new TrackedResourceDefinition("Pickable_Mushroom_JotunPuffs", "Jotun Puffs", 600, TrackedResourceTypeEnum.Pickable),
				new TrackedResourceDefinition("Pickable_Mushroom_Magecap", "Magecap", 610, TrackedResourceTypeEnum.Pickable),
				new TrackedResourceDefinition("giant_skull", "Giant Skull", 620, TrackedResourceTypeEnum.Deposit, "Softtissue", "$piece_giant_bone"),
				new TrackedResourceDefinition("VineAsh", "Vineberries", 700, TrackedResourceTypeEnum.Pickable),
				new TrackedResourceDefinition("Pickable_SmokePuff", "Smoke Puffs", 710, TrackedResourceTypeEnum.Pickable),
				new TrackedResourceDefinition("Pickable_Fiddlehead", "Fiddleheads", 720, TrackedResourceTypeEnum.Pickable),
				new TrackedResourceDefinition("LeviathanLava", "Flametal", 730, TrackedResourceTypeEnum.Deposit, "FlametalOreNew", null, "$item_flametalore"),
				new TrackedResourceDefinition("LingonberryBush", "Lingonberries", 800, TrackedResourceTypeEnum.Pickable),
				new TrackedResourceDefinition("Pickable_SeedKale", "Kale Seeds", 810, TrackedResourceTypeEnum.Pickable)
			};
			ByPrefabName = new Dictionary<string, TrackedResourceDefinition>();
			ByMineRock5Name = new Dictionary<string, TrackedResourceDefinition>();
			ByMineRockName = new Dictionary<string, TrackedResourceDefinition>();
			BuildResourceLookups();
		}

		internal static bool TryGetByPrefabName(string prefabName, out TrackedResourceDefinition definition)
		{
			return ByPrefabName.TryGetValue(prefabName, out definition);
		}

		internal static bool TryGetByMineRock5(string mineRockName, out TrackedResourceDefinition definition)
		{
			return ByMineRock5Name.TryGetValue(mineRockName, out definition);
		}

		internal static bool TryGetByMineRock(string mineRockName, out TrackedResourceDefinition definition)
		{
			return ByMineRockName.TryGetValue(mineRockName, out definition);
		}

		private static void BuildResourceLookups()
		{
			foreach (TrackedResourceDefinition allTrackedResource in AllTrackedResources)
			{
				ByPrefabName[allTrackedResource.ResourcePrefabName] = allTrackedResource;
				if (!string.IsNullOrWhiteSpace(allTrackedResource.MineRock5Name))
				{
					ByMineRock5Name[allTrackedResource.MineRock5Name] = allTrackedResource;
				}
				if (!string.IsNullOrWhiteSpace(allTrackedResource.MineRockName))
				{
					ByMineRockName[allTrackedResource.MineRockName] = allTrackedResource;
				}
			}
		}
	}
	internal sealed class MapTrackingScanner : MonoBehaviour
	{
		private const float RescanDistance = 25f;

		private const float RescanDistanceSquared = 625f;

		private Vector3 _lastScanPosition;

		private bool _hasScanned;

		private void Update()
		{
			//IL_0013: 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_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			if (PluginConfig.IsModEnabled.Value)
			{
				Vector3 position = ((Component)this).transform.position;
				if (!_hasScanned || HasMovedEnough(position))
				{
					Scan(position);
				}
			}
		}

		private bool HasMovedEnough(Vector3 currentPosition)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			float num = currentPosition.x - _lastScanPosition.x;
			float num2 = currentPosition.z - _lastScanPosition.z;
			return num * num + num2 * num2 >= 625f;
		}

		private void Scan(Vector3 currentPosition)
		{
			//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_003e: 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_00bc: 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)
			float value = PluginConfig.TrackingRange.Value;
			float num = value * value;
			foreach (TrackedMapObject trackedObject in TrackedMapObject.GetTrackedObjects())
			{
				if (!((Object)(object)trackedObject == (Object)null))
				{
					Vector3 position = ((Component)trackedObject).transform.position;
					float num2 = position.x - currentPosition.x;
					float num3 = position.z - currentPosition.z;
					bool isInTrackingRange = num2 * num2 + num3 * num3 <= num;
					trackedObject.IsInTrackingRange = isInTrackingRange;
					if ((Object)(object)trackedObject.Container != (Object)null)
					{
						ContainerResourcePinService.ReconcileTrackedContainer(trackedObject);
					}
					else if ((Object)(object)trackedObject.Pickable != (Object)null)
					{
						PickableResourcePinService.ReconcileTrackedPickable(trackedObject);
					}
					else
					{
						OreResourcePinService.ReconcileTrackedOre(trackedObject);
					}
				}
			}
			DungeonPinManager.ReconcileTrackingRange();
			_lastScanPosition = currentPosition;
			_hasScanned = true;
		}

		internal static void HandleTrackingModeChanged()
		{
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null)
			{
				return;
			}
			if (PluginConfig.TrackingMode.Value == TrackingModeEnum.RangeScanner)
			{
				MapTrackingScanner mapTrackingScanner = default(MapTrackingScanner);
				if (!((Component)localPlayer).TryGetComponent<MapTrackingScanner>(ref mapTrackingScanner))
				{
					mapTrackingScanner = ((Component)localPlayer).gameObject.AddComponent<MapTrackingScanner>();
				}
				mapTrackingScanner.ForceScan();
			}
			else
			{
				MapTrackingScanner mapTrackingScanner2 = default(MapTrackingScanner);
				if (((Component)localPlayer).TryGetComponent<MapTrackingScanner>(ref mapTrackingScanner2))
				{
					Object.Destroy((Object)(object)mapTrackingScanner2);
				}
				RescanZoneBasedObjects();
			}
		}

		internal static void ForceRescan()
		{
			if (PluginConfig.TrackingMode.Value == TrackingModeEnum.RangeScanner)
			{
				Player localPlayer = Player.m_localPlayer;
				MapTrackingScanner mapTrackingScanner = default(MapTrackingScanner);
				if (!((Object)(object)localPlayer == (Object)null) && ((Component)localPlayer).TryGetComponent<MapTrackingScanner>(ref mapTrackingScanner))
				{
					mapTrackingScanner.ForceScan();
				}
			}
		}

		private void ForceScan()
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			_hasScanned = false;
			Scan(((Component)this).transform.position);
		}

		private static void RescanZoneBasedObjects()
		{
			foreach (TrackedMapObject trackedObject in TrackedMapObject.GetTrackedObjects())
			{
				if (!((Object)(object)trackedObject == (Object)null))
				{
					if ((Object)(object)trackedObject.Container != (Object)null)
					{
						ContainerResourcePinService.ReconcileTrackedContainer(trackedObject);
					}
					else if ((Object)(object)trackedObject.Pickable != (Object)null)
					{
						PickableResourcePinService.TryAddResourcePinFromPickable(trackedObject.Pickable);
					}
					else if ((Object)(object)trackedObject.Destructible != (Object)null)
					{
						OreResourcePinService.TryAddResourcePinFromDestructibleOre(trackedObject.Destructible);
					}
					else if ((Object)(object)trackedObject.MineRock5 != (Object)null)
					{
						OreResourcePinService.TryAddOrRelinkResourcePinFromMineRock5Ore(trackedObject.MineRock5);
					}
					else if ((Object)(object)trackedObject.MineRock != (Object)null)
					{
						OreResourcePinService.TryAddResourcePinFromMineRock(trackedObject.MineRock);
					}
				}
			}
			DungeonPinManager.AddLoadedDungeonPins();
		}
	}
	[Obsolete("Delete this class after refactor")]
	internal static class TrackedResourceDefinitions
	{
		internal static readonly Dictionary<string, ResourceDefinitionModel> DestructibleResourcesByPrefabName = new Dictionary<string, ResourceDefinitionModel>
		{
			{
				"rock4_copper",
				new ResourceDefinitionModel("rock4_copper", "CopperOre")
			},
			{
				"silvervein",
				new ResourceDefinitionModel("silvervein", "SilverOre")
			},
			{
				"giant_skull",
				new ResourceDefinitionModel("giant_skull", "Softtissue")
			}
		};

		internal static readonly Dictionary<string, ResourceDefinitionModel> MineRock5ResourcesByName = new Dictionary<string, ResourceDefinitionModel>
		{
			{
				"$piece_deposit_copper",
				new ResourceDefinitionModel("rock4_copper", "CopperOre")
			},
			{
				"$piece_deposit_silvervein",
				new ResourceDefinitionModel("silvervein", "SilverOre")
			},
			{
				"$piece_giant_bone",
				new ResourceDefinitionModel("giant_skull", "Softtissue")
			}
		};

		internal static readonly Dictionary<string, ResourceDefinitionModel> MineRockResourcesByName = new Dictionary<string, ResourceDefinitionModel> { 
		{
			"$item_flametalore",
			new ResourceDefinitionModel("LeviathanLava", "FlametalOreNew")
		} };
	}
}
namespace HexResourceTracker.Core.Tracking
{
	internal sealed class TrackedDungeonLocation : MonoBehaviour
	{
		private static readonly HashSet<TrackedDungeonLocation> TrackedLocations = new HashSet<TrackedDungeonLocation>();

		internal Location Location { get; private set; }

		internal static IReadOnlyCollection<TrackedDungeonLocation> GetTrackedLocations()
		{
			return TrackedLocations;
		}

		internal void Initialize(Location location)
		{
			Location = location;
			TrackedLocations.Add(this);
		}

		private void OnDestroy()
		{
			TrackedLocations.Remove(this);
		}

		internal static void TryAdd(Location location)
		{
			TrackedDungeonLocation trackedDungeonLocation = default(TrackedDungeonLocation);
			if (!((Object)(object)location == (Object)null) && DungeonPinManager.TryGetSupportedDungeonTheme(location, out var _) && !((Component)location).TryGetComponent<TrackedDungeonLocation>(ref trackedDungeonLocation))
			{
				trackedDungeonLocation = ((Component)location).gameObject.AddComponent<TrackedDungeonLocation>();
				trackedDungeonLocation.Initialize(location);
			}
		}
	}
	internal sealed class TrackedMapObject : MonoBehaviour
	{
		private static readonly HashSet<TrackedMapObject> TrackedObjects = new HashSet<TrackedMapObject>();

		internal string PrefabName { get; private set; }

		internal bool IsInTrackingRange { get; set; }

		internal Pickable Pickable { get; private set; }

		internal Destructible Destructible { get; private set; }

		internal MineRock5 MineRock5 { get; private set; }

		internal MineRock MineRock { get; private set; }

		internal ZNetView ZNetView { get; private set; }

		internal Container Container { get; private set; }

		internal static IReadOnlyCollection<TrackedMapObject> GetTrackedObjects()
		{
			return TrackedObjects;
		}

		internal void Initialize(string prefabName)
		{
			PrefabName = prefabName;
			Pickable pickable = default(Pickable);
			((Component)this).TryGetComponent<Pickable>(ref pickable);
			Destructible destructible = default(Destructible);
			((Component)this).TryGetComponent<Destructible>(ref destructible);
			MineRock5 mineRock = default(MineRock5);
			((Component)this).TryGetComponent<MineRock5>(ref mineRock);
			MineRock mineRock2 = default(MineRock);
			((Component)this).TryGetComponent<MineRock>(ref mineRock2);
			ZNetView zNetView = default(ZNetView);
			((Component)this).TryGetComponent<ZNetView>(ref zNetView);
			Container container = default(Container);
			((Component)this).TryGetComponent<Container>(ref container);
			Pickable = pickable;
			Destructible = destructible;
			MineRock5 = mineRock;
			MineRock = mineRock2;
			ZNetView = zNetView;
			Container = container;
			TrackedObjects.Add(this);
		}

		private void OnDestroy()
		{
			TrackedObjects.Remove(this);
		}

		internal static void TryAdd(GameObject gameObject, string prefabName)
		{
			TrackedMapObject trackedMapObject = default(TrackedMapObject);
			if (!((Object)(object)gameObject == (Object)null) && !string.IsNullOrWhiteSpace(prefabName) && !gameObject.TryGetComponent<TrackedMapObject>(ref trackedMapObject))
			{
				trackedMapObject = gameObject.AddComponent<TrackedMapObject>();
				trackedMapObject.Initialize(prefabName);
			}
		}
	}
	internal static class TrackingRangeService
	{
		internal static bool IsWithinTrackingRange(Vector3 position)
		{
			//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_003d: 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)
			if (PluginConfig.TrackingMode.Value == TrackingModeEnum.ZoneBased)
			{
				return true;
			}
			if ((Object)(object)Player.m_localPlayer == (Object)null)
			{
				return false;
			}
			float value = PluginConfig.TrackingRange.Value;
			Vector3 position2 = ((Component)Player.m_localPlayer).transform.position;
			float num = position2.x - position.x;
			float num2 = position2.z - position.z;
			return num * num + num2 * num2 <= value * value;
		}
	}
	internal enum TrackingModeEnum
	{
		ZoneBased,
		RangeScanner
	}
}
namespace HexResourceTracker.Core.PinManagers
{
	internal static class DungeonPinManager
	{
		private const float DuplicateRadius = 5f;

		private const float ExistingPinMatchRadius = 0.1f;

		private static readonly List<DungeonPinModel> DungeonPins = new List<DungeonPinModel>();

		private static readonly FieldRef<Minimap, List<PinData>> MinimapPins = AccessTools.FieldRefAccess<Minimap, List<PinData>>("m_pins");

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

		private static Minimap _trackedMinimap;

		private static readonly Dictionary<Theme, string> SupportedDungeons = new Dictionary<Theme, string>
		{
			{
				(Theme)8,
				"Burial Chamber"
			},
			{
				(Theme)2,
				"Sunken Crypt"
			},
			{
				(Theme)4,
				"Frost Cave"
			},
			{
				(Theme)128,
				"Infested Mine"
			},
			{
				(Theme)131072,
				"Morkhalla"
			},
			{
				(Theme)16384,
				"Winding Tunnel"
			}
		};

		internal static bool TryAddDungeonPin(Location location)
		{
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: 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_0057: 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_0062: 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_006b: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)location == (Object)null)
			{
				return false;
			}
			EnsureMinimapState();
			if ((Object)(object)Minimap.instance == (Object)null)
			{
				return false;
			}
			if (!TryGetSupportedDungeonTheme(location, out var theme))
			{
				return false;
			}
			string prefabName = Utils.GetPrefabName(((Component)location).gameObject);
			Vector3 position = ((Component)location).transform.position;
			if (!PluginConfig.IsDungeonTrackingEnabled(theme))
			{
				return false;
			}
			if (!TrackingRangeService.IsWithinTrackingRange(position))
			{
				return false;
			}
			if (HasDungeonPin(theme, position))
			{
				return false;
			}
			DungeonPinModel dungeonPinModel = new DungeonPinModel(theme, prefabName, position);
			PinData val = FindExistingDungeonPin(position);
			if (val != null)
			{
				dungeonPinModel.Pin = val;
				dungeonPinModel.IsChecked = val.m_checked;
			}
			else if (!CreatePin(dungeonPinModel))
			{
				return false;
			}
			DungeonPins.Add(dungeonPinModel);
			return true;
		}

		internal static void HandleDungeonTrackingChanged(Theme theme, bool isEnabled)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			EnsureMinimapState();
			RemoveExistingDungeonPins(theme);
			if (isEnabled)
			{
				AddLoadedDungeonPins(theme);
			}
		}

		internal static void UpdateCheckedStates()
		{
			EnsureMinimapState();
			foreach (DungeonPinModel dungeonPin in DungeonPins)
			{
				if (dungeonPin.Pin != null && dungeonPin.IsChecked != dungeonPin.Pin.m_checked)
				{
					dungeonPin.IsChecked = dungeonPin.Pin.m_checked;
				}
			}
		}

		internal static void RedrawDungeonPins()
		{
			EnsureMinimapState();
			if ((Object)(object)Minimap.instance == (Object)null)
			{
				return;
			}
			foreach (DungeonPinModel dungeonPin in DungeonPins)
			{
				if (dungeonPin.Pin != null)
				{
					Minimap.instance.RemovePin(dungeonPin.Pin);
					dungeonPin.Pin = null;
				}
				CreatePin(dungeonPin);
			}
		}

		internal static void ReconcileTrackingRange()
		{
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			EnsureMinimapState();
			if ((Object)(object)Minimap.instance == (Object)null || (Object)(object)Player.m_localPlayer == (Object)null)
			{
				return;
			}
			for (int num = DungeonPins.Count - 1; num >= 0; num--)
			{
				DungeonPinModel dungeonPinModel = DungeonPins[num];
				if (!TrackingRangeService.IsWithinTrackingRange(dungeonPinModel.Position))
				{
					if (dungeonPinModel.Pin != null)
					{
						Minimap.instance.RemovePin(dungeonPinModel.Pin);
						dungeonPinModel.Pin = null;
					}
					DungeonPins.RemoveAt(num);
				}
			}
			foreach (TrackedDungeonLocation trackedLocation in TrackedDungeonLocation.GetTrackedLocations())
			{
				if (!((Object)(object)trackedLocation == (Object)null) && !((Object)(object)trackedLocation.Location == (Object)null))
				{
					TryAddDungeonPin(trackedLocation.Location);
				}
			}
		}

		internal static void AddLoadedDungeonPins()
		{
			EnsureMinimapState();
			if ((Object)(object)Minimap.instance == (Object)null)
			{
				return;
			}
			foreach (TrackedDungeonLocation trackedLocation in TrackedDungeonLocation.GetTrackedLocations())
			{
				if (!((Object)(object)trackedLocation == (Object)null) && !((Object)(object)trackedLocation.Location == (Object)null))
				{
					TryAddDungeonPin(trackedLocation.Location);
				}
			}
		}

		internal static bool TryGetSupportedDungeonTheme(Location location, out Theme theme)
		{
			//IL_0028: 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_0039: Expected I4, but got Unknown
			theme = (Theme)0;
			if ((Object)(object)location == (Object)null || !location.m_hasInterior)
			{
				return false;
			}
			DungeonGenerator componentInChildren = ((Component)location).GetComponentInChildren<DungeonGenerator>(true);
			if ((Object)(object)componentInChildren == (Object)null || (int)componentInChildren.m_algorithm != 0)
			{
				return false;
			}
			theme = (Theme)(int)componentInChildren.m_themes;
			return SupportedDungeons.ContainsKey(theme);
		}

		internal static void UpdateDungeonLabels()
		{
			//IL_0037: 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)
			EnsureMinimapState();
			if ((Object)(object)Minimap.instance == (Object)null)
			{
				return;
			}
			foreach (DungeonPinModel dungeonPin in DungeonPins)
			{
				if (dungeonPin.Pin != null)
				{
					string dungeonLabel = PluginConfig.GetDungeonLabel(dungeonPin.Theme);
					dungeonPin.Pin.m_name = dungeonLabel;
					if (dungeonPin.Pin.m_NamePinData != null && (Object)(object)dungeonPin.Pin.m_NamePinData.PinNameText != (Object)null)
					{
						dungeonPin.Pin.m_NamePinData.PinNameText.text = dungeonLabel;
					}
					dungeonPin.Pin.m_NamePinData = (PinNameData)(string.IsNullOrEmpty(dungeonLabel) ? null : (((object)dungeonPin.Pin.m_NamePinData) ?? ((object)new PinNameData(dungeonPin.Pin))));
				}
			}
			MinimapPinUpdateRequiredField.SetValue(Minimap.instance, true);
		}

		private static bool CreatePin(DungeonPinModel model)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			if (model == null || (Object)(object)Minimap.instance == (Object)null)
			{
				return false;
			}
			PinData val = Minimap.instance.AddPin(model.Position, (PinType)2, PluginConfig.GetDungeonLabel(model.Theme), true, model.IsChecked, 0L, default(PlatformUserID));
			if (val == null)
			{
				return false;
			}
			model.Pin = val;
			return true;
		}

		private static void AddLoadedDungeonPins(Theme theme)
		{
			//IL_004a: 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)
			if ((Object)(object)Minimap.instance == (Object)null)
			{
				return;
			}
			foreach (TrackedDungeonLocation trackedLocation in TrackedDungeonLocation.GetTrackedLocations())
			{
				if (!((Object)(object)trackedLocation == (Object)null) && !((Object)(object)trackedLocation.Location == (Object)null))
				{
					Location location = trackedLocation.Location;
					if (TryGetSupportedDungeonTheme(location, out var theme2) && theme2 == theme)
					{
						TryAddDungeonPin(location);
					}
				}
			}
		}

		private static bool HasDungeonPin(Theme theme, Vector3 position)
		{
			//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_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)
			float radiusSqr = 25f;
			foreach (DungeonPinModel dungeonPin in DungeonPins)
			{
				if (dungeonPin.Theme == theme && IsWithinRadius(dungeonPin.Position, position, radiusSqr))
				{
					return true;
				}
			}
			return false;
		}

		private static PinData FindExistingDungeonPin(Vector3 position)
		{
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Invalid comparison between Unknown and I4
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: 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_004f: Invalid comparison between Unknown and I4
			if ((Object)(object)Minimap.instance == (Object)null)
			{
				return null;
			}
			List<PinData> list = MinimapPins.Invoke(Minimap.instance);
			if (list == null)
			{
				return null;
			}
			float radiusSqr = 0.010000001f;
			foreach (PinData item in list)
			{
				if (item != null && ((int)item.m_type == 2 || (int)item.m_type == 3) && IsWithinRadius(item.m_pos, position, radiusSqr))
				{
					return item;
				}
			}
			return null;
		}

		private static bool IsWithinRadius(Vector3 firstPosition, Vector3 secondPosition, float radiusSqr)
		{
			//IL_0000: 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_000d: 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)
			float num = firstPosition.x - secondPosition.x;
			float num2 = firstPosition.z - secondPosition.z;
			return num * num + num2 * num2 <= radiusSqr;
		}

		private static void RemoveExistingDungeonPins(Theme theme)
		{
			//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_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			for (int num = DungeonPins.Count - 1; num >= 0; num--)
			{
				DungeonPinModel dungeonPinModel = DungeonPins[num];
				if (dungeonPinModel.Theme == theme)
				{
					if (dungeonPinModel.Pin != null && (Object)(object)Minimap.instance != (Object)null)
					{
						Minimap.instance.RemovePin(dungeonPinModel.Pin);
					}
					DungeonPins.RemoveAt(num);
				}
			}
			if ((Object)(object)Minimap.instance == (Object)null)
			{
				return;
			}
			foreach (TrackedDungeonLocation trackedLocation in TrackedDungeonLocation.GetTrackedLocations())
			{
				if ((Object)(object)trackedLocation == (Object)null || (Object)(object)trackedLocation.Location == (Object)null)
				{
					continue;
				}
				Location location = trackedLocation.Location;
				if (TryGetSupportedDungeonTheme(location, out var theme2) && theme2 == theme)
				{
					PinData val = FindExistingDungeonPin(((Component)location).transform.position);
					if (val != null)
					{
						Minimap.instance.RemovePin(val);
					}
				}
			}
		}

		private static void EnsureMinimapState()
		{
			if (!((Object)(object)_trackedMinimap == (Object)(object)Minimap.instance))
			{
				DungeonPins.Clear();
				_trackedMinimap = Minimap.instance;
			}
		}
	}
	internal static class ResourcePinManager
	{
		private const float ResourcePinSize = 20f;

		private const float ClusterRadius = 25f;

		private const float OnionSeedsBorderPadding = -16f;

		private const string OnionSeedsPrefabName = "OnionSeeds";

		private const string OnionSeedsBorderName = "OnionSeedsBorder";

		private static readonly Color OnionSeedsBorderColor = new Color(1f, 0.75f, 0.15f, 1f);

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

		private static readonly Dictionary<ZDOID, ResourcePinModel> ResourcePinByZdoId = new Dictionary<ZDOID, ResourcePinModel>();

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

		private static readonly Dictionary<string, float> ResourceIconSizeOverrides = new Dictionary<string, float>
		{
			{ "TurnipSeeds", 32f },
			{ "CarrotSeeds", 32f },
			{ "Dandelion", 32f },
			{ "CopperOre", 32f },
			{ "SilverOre", 32f },
			{ "Softtissue", 32f },
			{ "OnionSeeds", 32f }
		};

		internal static bool TryAddResourcePin(ResourcePinModel model)
		{
			//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_002d: 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_006b: 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_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			if (model == null || model.ResourceDefinition == null || (Object)(object)Minimap.instance == (Object)null || model.ZdoId == ZDOID.None)
			{
				return false;
			}
			if (!TrackingRangeService.IsWithinTrackingRange(model.Position))
			{
				return false;
			}
			if (ResourcePinByZdoId.ContainsKey(model.ZdoId))
			{
				return false;
			}
			if (HasNearbyResourcePin(model))
			{
				return false;
			}
			string resourcePinLabel = GetResourcePinLabel(model.ResourceDefinition);
			PinData val = Minimap.instance.AddPin(model.Position, (PinType)8, resourcePinLabel, false, false, 0L, default(PlatformUserID));
			Sprite sprite = GetSprite(model.IconItemPrefabName);
			if ((Object)(object)sprite != (Object)null)
			{
				val.m_icon = sprite;
			}
			model.Pin = val;
			ResourcePinByZdoId[model.ZdoId] = model;
			SetPinUpdateRequired();
			return true;
		}

		internal static void UpdateResourcePinVisuals(Minimap minimap)
		{
			if ((Object)(object)minimap == (Object)null)
			{
				return;
			}
			foreach (ResourcePinModel value in ResourcePinByZdoId.Values)
			{
				PinData pin = value.Pin;
				if (pin == null || (Object)(object)pin.m_uiElement == (Object)null)
				{
					value.LastSizedUiElement = null;
					continue;
				}
				float resourcePinSize = GetResourcePinSize(value.IconItemPrefabName);
				if (!((Object)(object)value.LastSizedUiElement == (Object)(object)pin.m_uiElement) || value.LastAppliedSize != resourcePinSize)
				{
					pin.m_uiElement.SetSizeWithCurrentAnchors((Axis)0, resourcePinSize);
					pin.m_uiElement.SetSizeWithCurrentAnchors((Axis)1, resourcePinSize);
					if (value.ResourceDefinition.ResourcePrefabName == "OnionSeeds")
					{
						AddOnionSeedsBorder(pin.m_uiElement, resourcePinSize);
					}
					value.LastSizedUiElement = pin.m_uiElement;
					value.LastAppliedSize = resourcePinSize;
				}
			}
		}

		internal static bool RemoveResourcePin(ZDOID zdoId)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0001: 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_004a: Unknown result type (might be due to invalid IL or missing references)
			if (zdoId == ZDOID.None)
			{
				return false;
			}
			if (!ResourcePinByZdoId.TryGetValue(zdoId, out var value))
			{
				return false;
			}
			if (value.Pin != null && (Object)(object)Minimap.instance != (Object)null)
			{
				Minimap.instance.RemovePin(value.Pin);
			}
			ResourcePinByZdoId.Remove(zdoId);
			SetPinUpdateRequired();
			return true;
		}

		internal static void RemoveResourcePins(string prefabName)
		{
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			if (string.IsNullOrWhiteSpace(prefabName))
			{
				return;
			}
			List<ZDOID> list = new List<ZDOID>();
			foreach (KeyValuePair<ZDOID, ResourcePinModel> item in ResourcePinByZdoId)
			{
				if (item.Value.ResourceDefinition.ResourcePrefabName == prefabName)
				{
					list.Add(item.Key);
				}
			}
			foreach (ZDOID item2 in list)
			{
				RemoveResourcePin(item2);
			}
		}

		internal static bool RemoveClosestResourcePin(Vector3 position, float radius)
		{
			//IL_0021: 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)
			//IL_0035: 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_007e: Unknown result type (might be due to invalid IL or missing references)
			ResourcePinModel resourcePinModel = null;
			float num = radius * radius;
			foreach (ResourcePinModel value in ResourcePinByZdoId.Values)
			{
				float num2 = value.Position.x - position.x;
				float num3 = value.Position.z - position.z;
				float num4 = num2 * num2 + num3 * num3;
				if (num4 <= num)
				{
					num = num4;
					resourcePinModel = value;
				}
			}
			if (resourcePinModel == null)
			{
				return false;
			}
			return RemoveResourcePin(resourcePinModel.ZdoId);
		}

		internal static bool RemoveClosestResourcePin(string prefabName, Vector3 position, float radius)
		{
			//IL_0034: 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_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			ResourcePinModel resourcePinModel = null;
			float num = radius * radius;
			foreach (ResourcePinModel value in ResourcePinByZdoId.Values)
			{
				if (!(value.ResourceDefinition.ResourcePrefabName != prefabName))
				{
					float num2 = value.Position.x - position.x;
					float num3 = value.Position.z - position.z;
					float num4 = num2 * num2 + num3 * num3;
					if (num4 <= num)
					{
						num = num4;
						resourcePinModel = value;
					}
				}
			}
			if (resourcePinModel == null)
			{
				return false;
			}
			return RemoveResourcePin(resourcePinModel.ZdoId);
		}

		internal static bool HasResourcePin(ZDOID zdoId)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			if (zdoId != ZDOID.None)
			{
				return ResourcePinByZdoId.ContainsKey(zdoId);
			}
			return false;
		}

		internal static void UpdateDepositLabels()
		{
			foreach (ResourcePinModel value in ResourcePinByZdoId.Values)
			{
				if (value.ResourceDefinition.ResourceType == TrackedResourceTypeEnum.Deposit && value.Pin != null)
				{
					value.Pin.m_name = PluginConfig.GetDepositLabel(value.ResourceDefinition.ResourcePrefabName);
				}
			}
			SetPinUpdateRequired();
		}

		private static bool HasNearbyResourcePin(ResourcePinModel model)
		{
			//IL_003e: 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_0056: 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)
			float num = 625f;
			foreach (ResourcePinModel value in ResourcePinByZdoId.Values)
			{
				if (!(value.ResourceDefinition.ResourcePrefabName != model.ResourceDefinition.ResourcePrefabName))
				{
					float num2 = value.Position.x - model.Position.x;
					float num3 = value.Position.z - model.Position.z;
					if (num2 * num2 + num3 * num3 <= num)
					{
						return true;
					}
				}
			}
			return false;
		}

		private static Sprite GetSprite(string prefabName)
		{
			if (string.IsNullOrWhiteSpace(prefabName))
			{
				return null;
			}
			if (ResourceSprites.TryGetValue(prefabName, out var value))
			{
				return value;
			}
			GameObject itemPrefab = ObjectDB.instance.GetItemPrefab(prefabName);
			if ((Object)(object)itemPrefab == (Object)null)
			{
				return null;
			}
			ItemDrop component = itemPrefab.GetComponent<ItemDrop>();
			if ((Object)(object)component == (Object)null)
			{
				return null;
			}
			Sprite icon = component.m_itemData.GetIcon();
			ResourceSprites[prefabName] = icon;
			return icon;
		}

		private static float GetResourcePinSize(string iconItemPrefabName)
		{
			if (!string.IsNullOrWhiteSpace(iconItemPrefabName) && ResourceIconSizeOverrides.TryGetValue(iconItemPrefabName, out var value))
			{
				return value;
			}
			return 20f;
		}

		private static void AddOnionSeedsBorder(RectTransform pinUiElement, float iconSize)
		{
			//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_002b: 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_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: 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_00aa: 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_00c8: 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)
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_010f: 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_0138: Unknown result type (might be due to invalid IL or missing references)
			//IL_0147: 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_0165: Unknown result type (might be due to invalid IL or missing references)
			//IL_017e: Unknown result type (might be due to invalid IL or missing references)
			//IL_018d: 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_01ab: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)((Transform)pinUiElement).Find("OnionSeedsBorder") != (Object)null))
			{
				GameObject val = new GameObject("OnionSeedsBorder");
				val.transform.SetParent((Transform)(object)pinUiElement, false);
				val.transform.SetAsFirstSibling();
				RectTransform obj = val.AddComponent<RectTransform>();
				obj.anchorMin = new Vector2(0.5f, 0.5f);
				obj.anchorMax = new Vector2(0.5f, 0.5f);
				obj.pivot = new Vector2(0.5f, 0.5f);
				obj.anchoredPosition = Vector2.zero;
				float num = iconSize + -16f;
				obj.sizeDelta = new Vector2(num, num);
				AddBorderEdge(obj, "Top", new Vector2(0f, 1f), new Vector2(1f, 1f), new Vector2(0f, -2f), new Vector2(0f, 2f));
				AddBorderEdge(obj, "Bottom", new Vector2(0f, 0f), new Vector2(1f, 0f), new Vector2(0f, 0f), new Vector2(0f, 2f));
				AddBorderEdge(obj, "Left", new Vector2(0f, 0f), new Vector2(0f, 1f), new Vector2(0f, 0f), new Vector2(2f, 0f));
				AddBorderEdge(obj, "Right", new Vector2(1f, 0f), new Vector2(1f, 1f), new Vector2(-2f, 0f), new Vector2(2f, 0f));
			}
		}

		private static void AddBorderEdge(RectTransform parent, string name, Vector2 anchorMin, Vector2 anchorMax, Vector2 anchoredPosition, Vector2 sizeDelta)
		{
			//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_0013: 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_0021: 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_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject(name);
			val.transform.SetParent((Transform)(object)parent, false);
			RectTransform obj = val.AddComponent<RectTransform>();
			obj.anchorMin = anchorMin;
			obj.anchorMax = anchorMax;
			obj.pivot = new Vector2(0.5f, 0.5f);
			obj.anchoredPosition = anchoredPosition;
			obj.sizeDelta = sizeDelta;
			Image obj2 = val.AddComponent<Image>();
			((Graphic)obj2).color = OnionSeedsBorderColor;
			((Graphic)obj2).raycastTarget = false;
		}

		private static void SetPinUpdateRequired()
		{
			if (!((Object)(object)Minimap.instance == (Object)null))
			{
				MPinUpdateRequired.SetValue(Minimap.instance, true);
			}
		}

		private static string GetResourcePinLabel(TrackedResourceDefinition definition)
		{
			if (definition.ResourceType != TrackedResourceTypeEnum.Deposit)
			{
				return string.Empty;
			}
			return PluginConfig.GetDepositLabel(definition.ResourcePrefabName);
		}
	}
}