using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.Linq;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security.Permissions;
using System.Text;
using System.Text.RegularExpressions;
using BepInEx;
using BepInEx.Configuration;
using GUIFramework;
using HarmonyLib;
using JetBrains.Annotations;
using Jotunn.Configs;
using Jotunn.Entities;
using Jotunn.Managers;
using Jotunn.Utils;
using Microsoft.CodeAnalysis;
using Splatform;
using TMPro;
using UnityEngine;
using UnityEngine.Events;
using UnityEngine.UI;
using Zen;
using Zen.Interop;
using Zen.Lib;
using Zen.Lib.Config;
using Zen.Lib.Controls;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("ZenMap")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("ZenMap")]
[assembly: AssemblyCopyright("Copyright \ufffd  2021")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("e3243d22-4307-4008-ba36-9f326008cde5")]
[assembly: AssemblyFileVersion("0.0.1.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.0.1.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

		public NullableAttribute(byte P_0)
		{
			NullableFlags = new byte[1] { P_0 };
		}

		public NullableAttribute(byte[] P_0)
		{
			NullableFlags = P_0;
		}
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableContextAttribute : Attribute
	{
		public readonly byte Flag;

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace ZenMap
{
	internal static class ColorExt
	{
		public static uint ToUInt(this Color color)
		{
			//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)
			return Color32.op_Implicit(color).ToUInt();
		}

		public static uint ToUInt(this Color32 color)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: 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)
			return (uint)((color.r << 24) | (color.g << 16) | (color.b << 8) | color.a);
		}

		public static Color ToColor(this uint rgba)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			return Color32.op_Implicit(new Color32((byte)(rgba >> 24), (byte)(rgba >> 16), (byte)(rgba >> 8), (byte)rgba));
		}
	}
	internal static class DataKey
	{
		public const int CurrentVersion = 1;

		public const string MapID = "ZenMap_id";

		public const string Seed = "ZenMap_seed";

		public const string Label = "ZenMap_label";

		public const string Position = "ZenMap_position";

		public const string Radius = "ZenMap_radius";

		public const string Pins = "ZenMap_pins";

		public const string Timestamp = "ZenMap_timestamp";

		public const string Version = "ZenMap_version";

		public const string LastUsedMapID = "ZenMap_LastUsedMapID";
	}
	[HarmonyPatch]
	internal static class FireplaceUtils
	{
		[HarmonyPostfix]
		[HarmonyPatch(typeof(Fireplace), "Interact")]
		private static void Fireplace_Interact(Fireplace __instance)
		{
			if (StringExtensionMethods.GetStableHashCode(GameObjectExt.GetPrefabName(((Component)__instance).gameObject)) == MapTrack.Pin.Bonfire)
			{
				Minimap.instance.m_pinUpdateRequired = true;
			}
		}

		public static bool IsLit(ZDO zdo)
		{
			Fireplace prefab = GlobalStatic.GetPrefab<Fireplace>(ZdoExt.GetPrefabName(zdo), true);
			if (prefab.m_infiniteFuel)
			{
				return true;
			}
			if (prefab.m_secPerFuel <= 0f)
			{
				return false;
			}
			float @float = zdo.GetFloat(ZDOVars.s_fuel, 0f);
			DateTime time = ZNet.instance.GetTime();
			DateTime dateTime = new DateTime(zdo.GetLong(ZDOVars.s_lastTime, time.Ticks));
			double num = Math.Max(0.0, (time - dateTime).TotalSeconds) / (double)prefab.m_secPerFuel;
			return (double)@float - num > 0.0;
		}
	}
	[HarmonyPatch]
	internal static class InventoryCheck
	{
		private static bool _isFound;

		public static bool HaveMap { get; private set; }

		internal static void Init()
		{
			HaveMap = InventoryExt.ContainsItemByPrefab(((Humanoid)Player.m_localPlayer).GetInventory(), "ZenMap");
			_isFound = false;
		}

		private static bool IsValid(Inventory inv)
		{
			if (Object.op_Implicit((Object)(object)Player.m_localPlayer))
			{
				return inv == ((Humanoid)Player.m_localPlayer).GetInventory();
			}
			return false;
		}

		private static void Reset(Inventory inv)
		{
			if (IsValid(inv))
			{
				_isFound = false;
			}
		}

		private static void CheckIfHadMap(Inventory inv)
		{
			if (IsValid(inv) && Object.op_Implicit((Object)(object)Minimap.instance) && Minimap.instance.m_visibleIconTypes == MapPinType.VisibleTypes.CompassWithMap && !_isFound)
			{
				RequirePinUpdate();
			}
		}

		private static void CheckMapItem(Inventory inv, ItemData item)
		{
			if (IsValid(inv) && !_isFound)
			{
				HaveMap = ItemDataExt.GetPrefabName(item) == "ZenMap";
				if (HaveMap)
				{
					_isFound = true;
					RequirePinUpdate();
				}
			}
		}

		private static void RequirePinUpdate()
		{
			if (Object.op_Implicit((Object)(object)Minimap.instance))
			{
				Minimap.instance.m_pinUpdateRequired = true;
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(Player), "OnSpawned")]
		private static void Player_OnSpawned()
		{
			Init();
		}

		[HarmonyTranspiler]
		[HarmonyPatch(typeof(Inventory), "UpdateTotalWeight")]
		private static IEnumerable<CodeInstruction> Inventory_UpdateTotalWeight_Transpiler(IEnumerable<CodeInstruction> codes)
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Expected O, but got Unknown
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Expected O, but got Unknown
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Expected O, but got Unknown
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Expected O, but got Unknown
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Expected O, but got Unknown
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Expected O, but got Unknown
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: Expected O, but got Unknown
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Expected O, but got Unknown
			//IL_012d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0133: Expected O, but got Unknown
			//IL_0141: Unknown result type (might be due to invalid IL or missing references)
			//IL_0147: Expected O, but got Unknown
			//IL_014b: Unknown result type (might be due to invalid IL or missing references)
			CodeMatch[] array = (CodeMatch[])(object)new CodeMatch[3]
			{
				new CodeMatch((OpCode?)OpCodes.Callvirt, (object)AccessTools.Method(typeof(ItemData), "GetWeight", (Type[])null, (Type[])null), (string)null),
				new CodeMatch((OpCode?)OpCodes.Add, (object)null, (string)null),
				new CodeMatch((OpCode?)OpCodes.Stfld, (object)AccessTools.Field(typeof(Inventory), "m_totalWeight"), (string)null)
			};
			Action<Inventory> action = Reset;
			CodeInstruction[] array2 = (CodeInstruction[])(object)new CodeInstruction[2]
			{
				new CodeInstruction(OpCodes.Ldarg_0, (object)null),
				new CodeInstruction(OpCodes.Call, (object)action.Method)
			};
			Action<Inventory, ItemData> action2 = CheckMapItem;
			CodeInstruction[] array3 = (CodeInstruction[])(object)new CodeInstruction[3]
			{
				new CodeInstruction(OpCodes.Ldarg_0, (object)null),
				new CodeInstruction(OpCodes.Ldloc_1, (object)null),
				new CodeInstruction(OpCodes.Call, (object)action2.Method)
			};
			Action<Inventory> action3 = CheckIfHadMap;
			CodeInstruction[] array4 = (CodeInstruction[])(object)new CodeInstruction[2]
			{
				new CodeInstruction(OpCodes.Ldarg_0, (object)null),
				new CodeInstruction(OpCodes.Call, (object)action3.Method)
			};
			return new CodeMatcher(codes, (ILGenerator)null).Start().Insert(array2).MatchEndForward(array)
				.ThrowIfInvalid("Unable to match IL")
				.Advance(1)
				.Insert(array3)
				.End()
				.Insert(array4)
				.InstructionEnumeration();
		}
	}
	[HarmonyPatch]
	internal static class MapClouds
	{
		private static Texture2D? _cloudsCache;

		private static readonly Texture2D NoClouds;

		private static bool _isVisible;

		private static readonly int CloudTexID;

		static MapClouds()
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Expected O, but got Unknown
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			_isVisible = true;
			CloudTexID = Shader.PropertyToID("_CloudTex");
			NoClouds = new Texture2D(1, 1);
			NoClouds.SetPixel(0, 0, Color.clear);
			NoClouds.Apply();
		}

		public static void ResetState()
		{
			if (Object.op_Implicit((Object)(object)Minimap.instance) && Object.op_Implicit((Object)(object)_cloudsCache))
			{
				Minimap.instance.m_mapLargeShader.SetTexture(CloudTexID, (Texture)(object)_cloudsCache);
			}
			_isVisible = true;
			_cloudsCache = null;
		}

		internal static void Shutdown()
		{
			if (Object.op_Implicit((Object)(object)_cloudsCache) && Object.op_Implicit((Object)(object)Minimap.instance))
			{
				Minimap.instance.m_mapLargeShader.SetTexture(CloudTexID, (Texture)(object)_cloudsCache);
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(Minimap), "Start")]
		private static void Minimap_Start()
		{
			ResetState();
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(Minimap), "UpdateMap")]
		private static void Minimap_UpdateMap(Minimap __instance)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Invalid comparison between Unknown and I4
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Expected O, but got Unknown
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			if ((int)__instance.m_mode != 2)
			{
				return;
			}
			Material mapLargeShader = __instance.m_mapLargeShader;
			if (!Object.op_Implicit((Object)(object)_cloudsCache))
			{
				_cloudsCache = (Texture2D)mapLargeShader.GetTexture(CloudTexID);
			}
			if ((Configs.HideMapItemClouds.Value && MapLocation.IsMapItem()) || (Configs.HideMapTableClouds.Value && MapLocation.IsMapTable()))
			{
				if (_isVisible)
				{
					mapLargeShader.SetTexture(CloudTexID, (Texture)(object)NoClouds);
					_isVisible = false;
				}
				return;
			}
			bool flag = ZInput.GetKey(Configs.InputHideMapCloudsKey.Value, true) || ZInput.GetButton("JoyRStick");
			if (flag == _isVisible)
			{
				_isVisible = !flag;
				mapLargeShader.SetTexture(CloudTexID, (Texture)(_isVisible ? ((object)_cloudsCache) : ((object)NoClouds)));
			}
		}
	}
	[HarmonyPatch]
	internal static class MapFog
	{
		private static Texture2D? _fogAll;

		private static Texture2D? _fogNone;

		private static bool[] _exploreAll = Array.Empty<bool>();

		private static bool _isInit;

		private const int PrioritySuperLast = -1000;

		[HarmonyPostfix]
		[HarmonyPatch(typeof(Minimap), "Start")]
		[HarmonyPriority(-1000)]
		private static void Minimap_Start(Minimap __instance)
		{
			InitFogCache();
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(Minimap), "OnDestroy")]
		private static void Minimap_OnDestroy()
		{
			RemoveFogCache();
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(Minimap), "ExploreAll")]
		private static void Minimap_ExploreAll(ref bool __runOriginal)
		{
			if (_isInit)
			{
				__runOriginal = false;
				FastExploreAll();
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(Minimap), "Reset")]
		private static void Minimap_Reset(ref bool __runOriginal)
		{
			if (_isInit)
			{
				__runOriginal = false;
				FastReset();
				Minimap.instance.m_sharedMapHint.gameObject.SetActive(false);
			}
		}

		private static bool IsValidMinimap()
		{
			if (Object.op_Implicit((Object)(object)Minimap.instance) && Object.op_Implicit((Object)(object)Minimap.instance.m_fogTexture) && Minimap.instance.m_explored != null && Minimap.instance.m_explored.Length != 0)
			{
				return true;
			}
			Logging<Plugin>.Error((object)"Minimap instance is not valid", (ushort)0);
			return false;
		}

		private static bool ValidateFogCache()
		{
			if (Configs.DisableFogCache.Value)
			{
				return false;
			}
			if (!IsValidMinimap())
			{
				return false;
			}
			int width = ((Texture)Minimap.instance.m_fogTexture).width;
			int height = ((Texture)Minimap.instance.m_fogTexture).height;
			int num = Minimap.instance.m_explored.Length;
			int num2 = (Object.op_Implicit((Object)(object)_fogAll) ? ((Texture)_fogAll).width : 0);
			int num3 = (Object.op_Implicit((Object)(object)_fogAll) ? ((Texture)_fogAll).height : 0);
			int num4 = _exploreAll.Length;
			if (width == num2 && height == num3 && num == num4 && IsFogCacheTexturesSizesEqual())
			{
				Logging<Plugin>.Info((object)"Fog cache sizes OK", 0);
				return true;
			}
			Logging<Plugin>.Warning((object)$"Map: {width}x{height} Cache: {num2}x{num3}, MapExplored: {num}, CacheExplored: {num4}", 0);
			Logging<Plugin>.Warning((object)"Fog cache is missing or invalid. Reinitializing...", 0);
			return InitFogCache();
			static bool IsFogCacheTexturesSizesEqual()
			{
				if (Object.op_Implicit((Object)(object)_fogAll) && Object.op_Implicit((Object)(object)_fogNone) && ((Texture)_fogNone).width == ((Texture)_fogAll).width)
				{
					return ((Texture)_fogNone).height == ((Texture)_fogAll).height;
				}
				return false;
			}
		}

		internal static void RemoveFogCache()
		{
			Logging<Plugin>.Info((object)"Remove existing fog cache", 0);
			if (Object.op_Implicit((Object)(object)_fogAll))
			{
				Object.Destroy((Object)(object)_fogAll);
			}
			if (Object.op_Implicit((Object)(object)_fogNone))
			{
				Object.Destroy((Object)(object)_fogNone);
			}
			_fogAll = null;
			_fogNone = null;
			_exploreAll = Array.Empty<bool>();
			_isInit = false;
		}

		private static void InitFog(this Texture2D texture, Color32 color)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			Color32[] array = (Color32[])(object)new Color32[((Texture)texture).width * ((Texture)texture).height];
			for (int i = 0; i < array.Length; i++)
			{
				array[i] = color;
			}
			texture.SetPixels32(array);
			texture.Apply();
		}

		internal static bool InitFogCache()
		{
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			_isInit = false;
			if (Configs.DisableFogCache.Value)
			{
				Logging<Plugin>.Warning((object)"Fog cache is disabled", 0);
				return false;
			}
			if (!IsValidMinimap())
			{
				return false;
			}
			Logging<Plugin>.Info((object)"Initialize the fog cache", 0);
			if (Object.op_Implicit((Object)(object)ZNet.instance) && ZNet.instance.IsDedicated())
			{
				Logging<Plugin>.Info((object)"Dedicated server, no UI, aborting fog cache creation", 0);
				return false;
			}
			RemoveFogCache();
			_fogAll = Create(Minimap.instance.m_fogTexture, "All");
			_fogNone = Create(Minimap.instance.m_fogTexture, "None");
			_fogAll.InitFog(Color32.op_Implicit(Color.white));
			_fogNone.InitFog(Color32.op_Implicit(Color.clear));
			Logging<Plugin>.Info((object)$"ExploreAll array size m_explored: {Minimap.instance.m_explored.Length}", 0);
			_exploreAll = Enumerable.Repeat(element: true, Minimap.instance.m_explored.Length).ToArray();
			return _isInit = true;
			static Texture2D Create(Texture2D tex, string name)
			{
				//IL_0034: 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_0047: Expected O, but got Unknown
				Logging<Plugin>.Info((object)$"Initialize texture {name} size {((Texture)tex).width}x{((Texture)tex).height}", 0);
				return new Texture2D(((Texture)tex).width, ((Texture)tex).height, tex.format, ((Texture)tex).mipmapCount, false, true);
			}
		}

		private static void FastExploreAll()
		{
			if (ValidateFogCache())
			{
				Logging<Plugin>.Info((object)"Set the fog texture to no fog", 0);
				Graphics.CopyTexture((Texture)(object)_fogNone, (Texture)(object)Minimap.instance.m_fogTexture);
				Minimap.instance.m_fogTexture.Apply();
				Logging<Plugin>.Info((object)"Set the explored area to all", 0);
				_exploreAll.CopyTo(Minimap.instance.m_explored, 0);
			}
		}

		private static void FastReset()
		{
			if (ValidateFogCache())
			{
				Logging<Plugin>.Info((object)"Set the fog texture to all fog", 0);
				Graphics.CopyTexture((Texture)(object)_fogAll, (Texture)(object)Minimap.instance.m_fogTexture);
				Minimap.instance.m_fogTexture.Apply();
				Logging<Plugin>.Info((object)"Reset the explored area to none", 0);
				ArrayClear(Minimap.instance.m_explored);
				ArrayClear(Minimap.instance.m_exploredOthers);
			}
			static void ArrayClear(Array? ar)
			{
				if (ar != null)
				{
					Array.Clear(ar, 0, ar.Length);
				}
			}
		}
	}
	[HarmonyPatch]
	internal static class MapItem
	{
		public const string PrefabName = "ZenMap";

		private const int VariantCount = 10;

		private static Guid LastUsedMapID
		{
			get
			{
				if (!Player.m_localPlayer.m_customData.TryGetValue("ZenMap_LastUsedMapID", out var value))
				{
					return Guid.Empty;
				}
				return Guid.Parse(value);
			}
			set
			{
				Player.m_localPlayer.m_customData["ZenMap_LastUsedMapID"] = value.ToString("N");
			}
		}

		internal static Action? AddCraftingItem()
		{
			//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_004d: 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_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Expected O, but got Unknown
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Expected O, but got Unknown
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			Sprite[] array = (Sprite[])(object)new Sprite[10];
			for (int i = 0; i < array.Length; i++)
			{
				array[i] = AssetIO.LoadSpriteFromResource((BaseUnityPlugin)(object)ZenMod<Plugin>.Instance, $"ItemIcons.map_item{i:00}.png");
			}
			CustomItem val = new CustomItem("ZenMap", "ArmorRagsChest", new ItemConfig
			{
				Name = "$map_item",
				Description = "$map_item_description",
				CraftingStation = CraftingStations.None,
				MinStationLevel = 0,
				Requirements = Array.Empty<RequirementConfig>(),
				Icons = array,
				Amount = 1,
				Weight = 0.1f,
				StackSize = 1
			});
			CustomItemExt.ApplyTextureToPrefab(val, array[0].texture, 0.5f, Vector2.one * 2f, Vector2.zero, "map", true, (Color?)null);
			ItemManager.Instance.AddItem(val);
			return null;
		}

		public static void ShowLastUsed()
		{
			Logging<Plugin>.Info((object)$"Last used map: {LastUsedMapID}", 0);
			Inventory inventory = ((Humanoid)Player.m_localPlayer).GetInventory();
			Guid guid2;
			ItemData val = ((IEnumerable<ItemData>)inventory.GetAllItems()).FirstOrDefault((Func<ItemData, bool>)((ItemData item) => item.TryGetMapID(out guid2) && guid2 == LastUsedMapID)) ?? inventory.GetItem("ZenMap", -1, true);
			if (val == null)
			{
				MapMissing();
				return;
			}
			val.TryGetMapID(out var guid);
			Logging<Plugin>.Info((object)$"Showing map: {guid}", 0);
			LastUsedMapID = guid;
			MapLocation mapLocation = MapLocation.ReadFrom(val);
			if (mapLocation == null)
			{
				MapMissing();
			}
			else
			{
				mapLocation.Show();
			}
			static void MapMissing()
			{
				Logging<Plugin>.Info((object)"Map not found", 0);
				((Character)Player.m_localPlayer).Message((MessageType)2, "$map_error_missing", 0, (Sprite)null);
			}
		}

		public static int GetNextVariant()
		{
			Dictionary<string, string> customData = Player.m_localPlayer.m_customData;
			string value;
			int num = (customData.TryGetValue("ZenMap_MapItemNextVariant", out value) ? int.Parse(value) : 0);
			customData["ZenMap_MapItemNextVariant"] = ((num + 1) % 10).ToString();
			return num;
		}

		public static bool IsMapItem(this ItemData? item)
		{
			return ((item != null) ? ItemDataExt.GetPrefabName(item) : null) == "ZenMap";
		}

		public static bool IsNear(this ItemData? item, Vector3 position, float maxDistance, out string mapItemLabel)
		{
			//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)
			mapItemLabel = string.Empty;
			if (item == null)
			{
				return false;
			}
			MapLocation mapLocation = MapLocation.ReadFrom(item);
			if (mapLocation == null)
			{
				return false;
			}
			mapItemLabel = mapLocation.Label;
			bool flag = MathExt.DistanceToXZ(mapLocation.Position, position) < maxDistance;
			Logging<Plugin>.Info((object)$"Is near origin table? {flag}", 0);
			return flag;
		}

		public static bool IsValidSeed(this ItemData item)
		{
			if (!item.m_customData.TryGetValue("ZenMap_seed", out var value))
			{
				return false;
			}
			return int.Parse(value) == WorldGenerator.instance.GetSeed();
		}

		private static bool TryGetMapID(this ItemData mapItem, out Guid guid)
		{
			guid = Guid.Empty;
			if (!mapItem.IsMapItem())
			{
				return false;
			}
			if (mapItem.m_customData.TryGetValue("ZenMap_id", out var value))
			{
				guid = Guid.Parse(value);
			}
			return guid != Guid.Empty;
		}

		internal static void CreateMapID(this ItemData mapItem)
		{
			if (!mapItem.IsMapItem())
			{
				throw new ArgumentException("Item is not a MapItem");
			}
			mapItem.m_customData["ZenMap_id"] = Guid.NewGuid().ToString("D");
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(Humanoid), "UseItem")]
		[HarmonyPriority(100)]
		private static void Humanoid_UseItem(Humanoid __instance, Inventory? inventory, ItemData? item, bool fromInventoryGui, ref bool __runOriginal)
		{
			if ((Object)(object)__instance != (Object)(object)Player.m_localPlayer || item == null || !item.IsMapItem() || !fromInventoryGui)
			{
				return;
			}
			if (inventory == null)
			{
				inventory = __instance.m_inventory;
			}
			if (!inventory.ContainsItem(item))
			{
				return;
			}
			__runOriginal = false;
			if (!item.IsValidSeed())
			{
				((Character)__instance).Message((MessageType)2, "$map_error_alien", 0, (Sprite)null);
				return;
			}
			if (inventory == __instance.GetInventory() && item.TryGetMapID(out var guid))
			{
				LastUsedMapID = guid;
			}
			MapLocation.ReadFrom(item)?.Show();
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(InventoryGrid), "CreateItemTooltip")]
		private static void InventoryGrid_CreateItemTooltip(InventoryGrid __instance, ItemData item)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: 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_0013: Invalid comparison between Unknown and I4
			if (item.IsMapItem())
			{
				HintType activeType = KeyHint.ActiveType;
				if (activeType - 4 <= 1)
				{
					KeyHint.SetLabelOneFrame((HintName)15, StringExt.Localize("$hud_rename"));
				}
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(ItemData), "GetTooltip", new Type[] { typeof(int) })]
		private static void ItemDrop_ItemData_GetTooltip(ItemData __instance, ref string __result)
		{
			if (!__instance.IsMapItem())
			{
				return;
			}
			__instance.m_customData.TryGetValue("ZenMap_label", out var value);
			string text = "$map_item_description";
			string text2 = string.Empty;
			if (!Utility.IsNullOrWhiteSpace(value))
			{
				text2 += $"\n\n<color={UIColor.ValheimBeige}>{value}</color>";
			}
			if (Configs.CalendarShow.Value)
			{
				string text3 = MapLocation.ReadFrom(__instance)?.GetCalendarString();
				if (text3 != null)
				{
					if (Utility.IsNullOrWhiteSpace(value))
					{
						text2 += "\n";
					}
					text2 += $"\n<color={UIColor.ValheimBeige}>{text3}</color>";
				}
			}
			if (!__instance.IsValidSeed())
			{
				text2 += $"\n\n<color={UIColor.Red}>$map_error_alien</color>";
			}
			__result = __result.Replace("$map_item_description", text + text2);
			ItemDataExt.SetTooltipExtra(__instance, text2);
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(InventoryGui), "OnSelectedItem")]
		private static void InventoryGui_OnSelectedItem(InventoryGui __instance, ItemData item, Modifier mod, ref bool __runOriginal)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Invalid comparison between Unknown and I4
			ItemData item2 = item;
			if (item2.IsMapItem() && (int)mod == 1)
			{
				__runOriginal = false;
				MapLocation map = MapLocation.ReadFrom(item2, ignoreSeed: true);
				map?.PromptLabel(delegate
				{
					map.WriteTo(item2);
				});
			}
		}
	}
	internal class MapLocation
	{
		private static MapLocation? _active;

		public readonly Vector3 Position;

		public readonly float Radius;

		public readonly float Percent;

		public readonly int WorldSeed;

		private double _timestamp;

		private string? _pinsBase64;

		private List<MapLocationPins.PinInfo>? _pins;

		public static bool InUse => _active != null;

		public static MapLocation Active => _active ?? throw new InvalidOperationException("No active map location");

		public string Label { get; private set; }

		public MapLocation(string label, Vector3 position, float radius)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			Label = label;
			Position = position;
			if (!(radius > 0f))
			{
				throw new ArgumentOutOfRangeException("radius", "must be positive");
			}
			Radius = radius;
			Percent = Mathf.Clamp(Radius / (float)Configs.MapTableFullRadius.Value, 0f, 1f);
			WorldSeed = WorldGenerator.instance.GetSeed();
		}

		private MapLocation(string label, Vector3 position, float radius, int worldSeed)
			: this(label, position, radius)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			WorldSeed = worldSeed;
		}

		public static bool IsMapTable()
		{
			if (InUse)
			{
				return !IsMapItem();
			}
			return false;
		}

		public static bool IsMapItem()
		{
			List<MapLocationPins.PinInfo> pins;
			return IsMapItem(out pins);
		}

		public static bool IsMapItem(out List<MapLocationPins.PinInfo> pins)
		{
			pins = _active?._pins;
			return pins != null;
		}

		public void WriteTo(ItemData target)
		{
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			Logging<Plugin>.Info((object)"Write map location to item", 0);
			target.CreateMapID();
			Dictionary<string, string> customData = target.m_customData;
			int worldSeed = WorldSeed;
			customData["ZenMap_seed"] = worldSeed.ToString();
			target.m_customData["ZenMap_position"] = JsonUtility.ToJson((object)Position);
			Dictionary<string, string> customData2 = target.m_customData;
			float radius = Radius;
			customData2["ZenMap_radius"] = radius.ToString("F");
			target.m_customData["ZenMap_label"] = Label;
			target.m_customData["ZenMap_pins"] = _pinsBase64 ?? MapLocationPins.SerializePins(Position, Radius);
			target.m_customData["ZenMap_timestamp"] = BitConverter.DoubleToInt64Bits((_timestamp != 0.0) ? _timestamp : ZNet.instance.GetTimeSeconds()).ToString();
			target.m_customData["ZenMap_version"] = 1.ToString();
		}

		public static MapLocation? ReadFrom(ItemData source, bool ignoreSeed = false)
		{
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			if (!ignoreSeed && !source.IsValidSeed())
			{
				Logging<Plugin>.Info((object)"Map item world seed does not match current world seed.", 0);
				return null;
			}
			Logging<Plugin>.Info((object)"Read map data from the item", 0);
			Dictionary<string, string> customData = source.m_customData;
			if (customData.TryGetValue("ZenMap_position", out var value) && customData.TryGetValue("ZenMap_radius", out var value2) && customData.TryGetValue("ZenMap_label", out var value3) && customData.TryGetValue("ZenMap_seed", out var value4))
			{
				string value5;
				MapLocation obj = new MapLocation(value3, JsonUtility.FromJson<Vector3>(value), float.Parse(value2), int.Parse(value4))
				{
					_pinsBase64 = (customData.TryGetValue("ZenMap_pins", out value5) ? value5 : null)
				};
				obj._pins = MapLocationPins.DeserializePins(obj._pinsBase64);
				obj._timestamp = (customData.TryGetValue("ZenMap_timestamp", out var value6) ? BitConverter.Int64BitsToDouble(long.Parse(value6)) : 0.0);
				return obj;
			}
			Logging<Plugin>.Warning((object)"Map item data missing or invalid location data. Was this map item instanced manually by admin?", 0);
			return null;
		}

		public void Show()
		{
			//IL_0022: 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)
			_active = this;
			Minimap.instance.Reset();
			if (IsMapItem())
			{
				MapLocationPins.ResetPinMarkers();
			}
			Minimap.instance.Explore(Position, Radius);
			Minimap.instance.m_largeZoom = Mathf.Max(Map.Zoom.Min, Map.Zoom.Max * (Percent + 0.2f));
			bool noMap = Game.m_noMap;
			Game.m_noMap = false;
			Minimap.instance.ShowPointOnMap(Position);
			Game.m_noMap = noMap;
			PlaySoundFX();
		}

		public static void Close()
		{
			if (InUse)
			{
				MapLocationPins.ResetPinMarkers();
				PlaySoundFX();
				_active = null;
			}
		}

		private static void PlaySoundFX()
		{
			((Humanoid)Player.m_localPlayer).TriggerEquipEffect((ItemData)null);
		}

		public void PromptLabel(Action onSuccess)
		{
			Action onSuccess2 = onSuccess;
			TextPrompt.Show("$map_item_prompt", Label, (Action<string>)delegate(string input)
			{
				Label = StringExt.ToProperCase(StringExtensionMethods.RemoveRichTextTags(Regex.Replace(input, "\\$", string.Empty, RegexOptions.Multiline)).Trim(), false);
				Logging<Plugin>.Info((object)("Set text (sanitized): '" + Label + "'"), 0);
				onSuccess2();
			}, 50);
		}

		private int GetCalendarYear(double defaultSeconds = -1.0)
		{
			int calendarDays = GetCalendarDays(defaultSeconds);
			int num = Configs.CalendarDaysPerYear.Value;
			if (num == 0)
			{
				num = 1;
			}
			return calendarDays / num + 1;
		}

		private int GetCalendarDays(double defaultSeconds = -1.0)
		{
			double num = ((_timestamp > 0.0) ? _timestamp : defaultSeconds);
			if (num < 0.0)
			{
				return 0;
			}
			return EnvMan.instance.GetDay(num) + Configs.CalendarInitDays.Value;
		}

		public string? GetCalendarString(double defaultSeconds = -1.0)
		{
			if (Configs.CalendarDaysPerYear.Value > 0)
			{
				int calendarYear = GetCalendarYear(defaultSeconds);
				if (calendarYear != 0)
				{
					return StringExt.Localize("$msg_calendar", new string[1] { calendarYear.ToString("N0", CultureInfo.CurrentCulture) });
				}
				return null;
			}
			int calendarDays = GetCalendarDays(defaultSeconds);
			if (calendarDays != 0)
			{
				return "$hud_mapday " + calendarDays.ToString("N0", CultureInfo.CurrentCulture);
			}
			return null;
		}
	}
	internal static class MapParchment
	{
		public const string PrefabName = "ZenMapParchment";

		internal static Action AddCraftingItem()
		{
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Expected O, but got Unknown
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Expected O, but got Unknown
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			Logging<Plugin>.Info((object)"Add crafting item: ZenMapParchment", 0);
			Sprite val = AssetIO.LoadSpriteFromResource((BaseUnityPlugin)(object)ZenMod<Plugin>.Instance, "ItemIcons.parchment.png");
			ItemConfig val2 = new ItemConfig();
			val2.Name = "$map_item_parchment";
			val2.Description = "$map_item_parchment_description";
			val2.CraftingStation = Configs.ParchmentCraftingStation.Value;
			val2.MinStationLevel = Configs.ParchmentCraftingStationLevel.Value;
			val2.Requirements = Configs.ParchmentResources.Value.ToRequirementConfigs(':');
			val2.Icons = (Sprite[])(object)new Sprite[1] { val };
			val2.Amount = 1;
			val2.Weight = 0.1f;
			val2.StackSize = 10;
			CustomItem item = new CustomItem("ZenMapParchment", "ArmorRagsChest", val2);
			CustomItemExt.ApplyTextureToPrefab(item, val.texture, 0.5f, Vector2.one, Vector2.zero, "", true, (Color?)null);
			ItemManager.Instance.AddItem(item);
			return ConfigSync;
			void ConfigSync()
			{
				Recipe recipe = item.Recipe.Recipe;
				recipe.m_craftingStation = PrefabManagerExt.GetCraftingStation(PrefabManager.Instance, Configs.ParchmentCraftingStation.Value);
				recipe.m_minStationLevel = Configs.ParchmentCraftingStationLevel.Value;
				recipe.m_resources = (Configs.MapItemEnabled.Value ? Configs.ParchmentResources.Value.ToRequirements(':') : Array.Empty<Requirement>());
			}
		}

		public static bool IsMapParchment(this ItemData? item)
		{
			return ((item != null) ? ItemDataExt.GetPrefabName(item) : null) == "ZenMapParchment";
		}
	}
	[HarmonyPatch]
	internal static class MapLocationPins
	{
		public class PinInfo
		{
			public Guid Guid;

			public PinType Type;

			public bool Checked;

			public Color Color;
		}

		private static readonly List<PinData> ValidPins = new List<PinData>();

		private const int SerializeVersion = 1;

		public static void Shutdown()
		{
			ResetPinMarkers();
		}

		public static void ResetPinMarkers()
		{
			foreach (PinData validPin in ValidPins)
			{
				Minimap instance = Minimap.instance;
				if (instance != null)
				{
					instance.DestroyPinMarker(validPin);
				}
				MapTrack.RemoveFromCache(validPin);
			}
			ValidPins.Clear();
			if (Object.op_Implicit((Object)(object)Minimap.instance))
			{
				CollectionExtensions.Do<PinData>((IEnumerable<PinData>)Minimap.instance.m_pins, (Action<PinData>)Minimap.instance.DestroyPinMarker);
				Minimap.instance.m_pinUpdateRequired = true;
			}
		}

		public static string SerializePins(Vector3 origin, float range)
		{
			//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_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Expected O, but got Unknown
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Expected I4, but got Unknown
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			List<PinData> list = (from pin in Minimap.instance.m_pins
				where VectorExtensions.DistanceTo(origin, pin.m_pos) < range
				where Configs.PinShowMapItem.IsAllowed(pin.GetPrefabHash())
				select pin).ToList();
			ZPackage val = new ZPackage();
			val.Write(1);
			val.Write(list.Count);
			foreach (PinData item in list)
			{
				Guid guid = item.GetGuid();
				if (guid == Guid.Empty)
				{
					throw new Exception("Guid can not be empty");
				}
				val.Write(guid.ToByteArray());
				val.Write((int)item.m_type);
				val.Write(item.m_checked);
				val.Write(Color.white.ToUInt());
			}
			string @base = val.GetBase64();
			Logging<Plugin>.Info((object)$"Serialized pins: {list.Count}, bytes: {val.Size()}, base64 size: {@base.Length}", 0);
			return @base;
		}

		public static List<PinInfo> DeserializePins(string? base64)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Expected O, but got Unknown
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			if (base64 == null)
			{
				return new List<PinInfo>();
			}
			ZPackage val = new ZPackage(base64);
			int num = val.ReadInt();
			if (num != 1)
			{
				Logging<Plugin>.Error((object)$"Map version mismatch. Expected {1}, got {num}", (ushort)0);
				return new List<PinInfo>();
			}
			List<PinInfo> list = new List<PinInfo>();
			int num2 = val.ReadInt();
			for (int i = 0; i < num2; i++)
			{
				PinInfo pinInfo = new PinInfo
				{
					Guid = new Guid(val.ReadByteArray()),
					Type = (PinType)val.ReadInt(),
					Checked = val.ReadBool(),
					Color = val.ReadUInt().ToColor()
				};
				Logging<Plugin>.Info((object)$"Deserialized pin: {pinInfo.Guid}, type: {pinInfo.Type}", 0);
				list.Add(pinInfo);
			}
			Logging<Plugin>.Info((object)$"Deserialized pins: {list.Count}", 0);
			return list;
		}

		private static List<PinData> MergeLocationPins()
		{
			if (!MapLocation.IsMapItem(out List<PinInfo> pins))
			{
				return Minimap.instance.m_pins;
			}
			if (ValidPins.Count > 0)
			{
				return ValidPins;
			}
			foreach (PinData pin in Minimap.instance.m_pins)
			{
				if (!IsHiddenOnMapItem(pin) && !pin.IsTracked())
				{
					ValidPins.Add(CopyPin(pin));
				}
			}
			foreach (PinInfo item2 in pins)
			{
				if (MapTrack.TryGetZDO(item2.Guid, out ZDO zdo))
				{
					PinData item = CreateTempPin(zdo, item2);
					ValidPins.Add(item);
				}
			}
			return ValidPins;
		}

		private static bool IsHiddenOnMapItem(PinData pin)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: 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_003d: Expected I4, but got Unknown
			bool flag = pin.m_shouldDelete;
			if (!flag)
			{
				PinType type = pin.m_type;
				bool flag2;
				switch (type - 5)
				{
				case 0:
				case 2:
				case 6:
				case 7:
				case 8:
					flag2 = true;
					break;
				default:
					flag2 = false;
					break;
				}
				flag = flag2;
			}
			return flag;
		}

		private static PinData CreateTempPin(ZDO zdo, PinInfo pinInfo)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: 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_0023: 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_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Expected O, but got Unknown
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Expected O, but got Unknown
			PinData val = new PinData
			{
				m_name = MapTrack.CreateTrackingLabel(zdo.GetLabel(), pinInfo.Guid),
				m_pos = zdo.GetPosition(),
				m_type = pinInfo.Type,
				m_icon = Minimap.instance.GetSprite(pinInfo.Type)
			};
			val.m_NamePinData = new PinNameData(val);
			Logging<Plugin>.Info((object)("Pin Created: " + val.m_name), 0);
			return val;
		}

		private static PinData CopyPin(PinData pin)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: 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_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: 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_006e: 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_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: 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_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Expected O, but got Unknown
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Expected O, but got Unknown
			//IL_00ab: Expected O, but got Unknown
			Logging<Plugin>.Info((object)$"Copy pin: {pin.m_name} {pin.m_pos}", 0);
			PinData val = new PinData
			{
				m_name = pin.m_name,
				m_pos = pin.m_pos,
				m_type = pin.m_type,
				m_icon = pin.m_icon,
				m_checked = pin.m_checked,
				m_ownerID = pin.m_ownerID,
				m_author = pin.m_author,
				m_doubleSize = pin.m_doubleSize,
				m_worldSize = pin.m_worldSize,
				m_animate = pin.m_animate
			};
			val.m_NamePinData = new PinNameData(val);
			return val;
		}

		[HarmonyTranspiler]
		[HarmonyPatch(typeof(Minimap), "UpdatePins")]
		private static IEnumerable<CodeInstruction> Minimap_UpdatePins_MergePins(IEnumerable<CodeInstruction> codes)
		{
			FieldInfo pinsField = AccessTools.Field(typeof(Minimap), "m_pins");
			Func<List<PinData>> intercept = MergeLocationPins;
			return Transpilers.Manipulator(codes, (Func<CodeInstruction, bool>)((CodeInstruction code) => CodeInstructionExtensions.Is(code, OpCodes.Ldfld, (MemberInfo)pinsField)), (Action<CodeInstruction>)delegate(CodeInstruction code)
			{
				code.opcode = OpCodes.Call;
				code.operand = intercept.Method;
			});
		}

		[HarmonyTranspiler]
		[HarmonyPatch(typeof(Minimap), "UpdatePins")]
		private static IEnumerable<CodeInstruction> Minimap_UpdatePins_ColorPins(IEnumerable<CodeInstruction> codes, ILGenerator gen)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Expected O, but got Unknown
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Expected O, but got Unknown
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Expected O, but got Unknown
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Expected O, but got Unknown
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Expected O, but got Unknown
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Expected O, but got Unknown
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Expected O, but got Unknown
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: Expected O, but got Unknown
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			CodeMatch[] array = (CodeMatch[])(object)new CodeMatch[4]
			{
				new CodeMatch((OpCode?)OpCodes.Ldloc_S, (object)null, (string)null),
				new CodeMatch((OpCode?)OpCodes.Ldfld, (object)AccessTools.Field(typeof(PinData), "m_iconElement"), (string)null),
				new CodeMatch((OpCode?)OpCodes.Ldloc_S, (object)null, (string)null),
				new CodeMatch((OpCode?)OpCodes.Callvirt, (object)AccessTools.PropertySetter(typeof(Graphic), "color"), (string)null)
			};
			Func<PinData, Color, Color> func = AdjustPinColor;
			CodeInstruction[] array2 = (CodeInstruction[])(object)new CodeInstruction[4]
			{
				new CodeInstruction(OpCodes.Ldloc_S, (object)(byte)6),
				new CodeInstruction(OpCodes.Ldloc_S, (object)(byte)9),
				new CodeInstruction(OpCodes.Call, (object)func.Method),
				new CodeInstruction(OpCodes.Stloc_S, (object)(byte)9)
			};
			return new CodeMatcher(codes, gen).MatchStartForward(array).ThrowIfInvalid("Unable to match IL").Insert(array2)
				.InstructionEnumeration();
		}

		private static Color AdjustPinColor(PinData pin, Color defaultColor)
		{
			//IL_000f: 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_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Invalid comparison between Unknown and I4
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Invalid comparison between Unknown and I4
			//IL_0023: 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_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			if (!Configs.PinColorEnabled.Value)
			{
				return defaultColor;
			}
			PinType type = pin.m_type;
			if ((int)type != 4)
			{
				if ((int)type == 9)
				{
					return Configs.PinColorBoss.Value;
				}
				if (pin.GetPrefabHash() == MapTrack.Pin.Sign)
				{
					return Configs.PinColorPrivate.Value;
				}
				if (MapTrack.Pin.Mounts.Contains(pin.GetPrefabHash()))
				{
					return Configs.PinColorPrivate.Value;
				}
				if (pin.IsTracked())
				{
					return Configs.PinColorShared.Value;
				}
				return Configs.PinColorSpecial.Value;
			}
			return Configs.PinColorDeath.Value;
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(Player), "OnSpawned")]
		private static void Player_OnSpawned()
		{
			ResetPinMarkers();
		}
	}
	[HarmonyPatch]
	internal static class MapPinSelect
	{
		private static VariantDialog _dialog = null;

		private static Action<PinType>? _onSelect;

		private static ItemData? _mapPinsIconData;

		private static readonly string[] PinDisplayOrder = new string[41]
		{
			"pickaxe", "axe", "sword", "bow", "anvil", "armor", "chest", "stackedbars", "potion", "cauldron",
			"tree", "berries", "berries2", "carrot", "turnip", "onion", "mushroom", "fish", "bee", "flower",
			"bread", "grain", "pig", "chicken", "wolf", "castle", "castle2", "tent", "bridge", "cave",
			"crystal", "magic_circle", "magic_eye", "magic_book", "swirl", "monster", "monster_trex", "dragon", "dragon2", "kraken",
			"question"
		};

		private static readonly PinType[] PinnableTypes = ((IEnumerable<PinType>)(object)new PinType[1] { (PinType)3 }).Union(PinDisplayOrder.Select(MapPinIcon.GetPinTypeFromResourceName)).ToArray();

		public static bool IsOpen
		{
			get
			{
				if (Object.op_Implicit((Object)(object)_dialog))
				{
					return ((Component)_dialog).gameObject.activeSelf;
				}
				return false;
			}
		}

		public static void Init()
		{
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			_dialog = Object.Instantiate<VariantDialog>(InventoryGui.instance.m_variantDialog, Hud.instance.m_rootObject.transform);
			((Component)_dialog).gameObject.SetActive(false);
			((Object)_dialog).name = "ZenMap_PinSelect";
			_dialog.m_selected = OnSelected;
			((Graphic)((Component)_dialog.m_elementPrefab.transform.Find("Button")).GetComponent<Image>()).material = Materials.IconCleanTransparency;
			_mapPinsIconData = CreateMapPinsIconData();
			RectTransform val = (RectTransform)_dialog.m_listRoot.parent;
			Vector2 anchoredPosition = val.anchoredPosition;
			anchoredPosition.y = -590f;
			val.anchoredPosition = anchoredPosition;
			val.sizeDelta = new Vector2(448f, 515f);
		}

		private static ItemData CreateMapPinsIconData()
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Expected O, but got Unknown
			ItemData obj = ZNetScene.instance.GetPrefab("ZenMapPin").GetComponent<ItemDrop>().m_itemData.Clone();
			obj.m_shared = new SharedData
			{
				m_icons = ((IEnumerable<PinType>)PinnableTypes).Select((Func<PinType, Sprite>)Minimap.instance.GetSprite).ToArray(),
				m_variants = PinnableTypes.Length
			};
			return obj;
		}

		private static GameObject CreateButton(Transform parent, string text, Action? onClick = null, Vector2 size = default(Vector2))
		{
			//IL_003a: 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_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Expected O, but got Unknown
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Expected O, but got Unknown
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			Action onClick2 = onClick;
			GameObject val = Object.Instantiate<GameObject>(((Component)Resources.FindObjectsOfTypeAll<Settings>()[0].m_backButton).gameObject, parent, false);
			((Object)val).name = "ZenMap_RemovePinBtn";
			GuiButton component = val.GetComponent<GuiButton>();
			Navigation navigation = default(Navigation);
			((Navigation)(ref navigation)).mode = (Mode)0;
			((Selectable)component).navigation = navigation;
			((UnityEventBase)((Button)component).onClick).RemoveAllListeners();
			((UnityEvent)((Button)component).onClick).AddListener(new UnityAction(ClickHandler));
			((Component)val.transform.Find("Label")).GetComponent<TMP_Text>().text = text;
			RectTransform val2 = (RectTransform)val.transform;
			val2.anchoredPosition = Vector2.one * 0.5f;
			val2.pivot = Vector2.one * 0.5f;
			if (size != default(Vector2))
			{
				val2.sizeDelta = size;
			}
			Localization.instance.Localize(val.transform);
			return val;
			void ClickHandler()
			{
				onClick2?.Invoke();
			}
		}

		public static void Choose(Action<PinType> onSelect)
		{
			if (!IsOpen)
			{
				_onSelect = onSelect;
				_dialog.Setup(_mapPinsIconData);
			}
		}

		public static void CheckForInput()
		{
			if (IsOpen)
			{
				if (ZInput.GetKeyDown((KeyCode)27, true))
				{
					Close();
				}
				if (ZInput.GetButtonDown("JoyButtonB"))
				{
					Close();
				}
			}
		}

		private static void Close()
		{
			_dialog.OnClose();
		}

		public static void Shutdown()
		{
			if (Object.op_Implicit((Object)(object)_dialog))
			{
				Object.Destroy((Object)(object)((Component)_dialog).gameObject);
			}
		}

		private static void OnSelected(int index)
		{
			Logging<Plugin>.Info((object)$"Selected index: {index}", 0);
			_onSelect?.Invoke(PinnableTypes[index]);
			Close();
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(VariantDialog), "OnClose")]
		private static void VariantDialog_OnClose(VariantDialog __instance)
		{
			if (!((Object)(object)__instance != (Object)(object)_dialog))
			{
				_onSelect = null;
				PlayerController.SetTakeInputDelay(0.5f);
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(InventoryGui), "IsVisible")]
		private static void InventoryGui_IsVisible(ref bool __result, ref bool __runOriginal)
		{
			__runOriginal = !IsOpen;
			__result = IsOpen;
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(InventoryGui), "Show")]
		private static void InventoryGui_Show()
		{
			if (IsOpen)
			{
				Close();
			}
		}
	}
	[HarmonyPatch]
	internal static class MapUI
	{
		private const float IconPadding = 15f;

		private const float IconScale = 0.65f;

		private static readonly (string Name, PinType PinType, PinOption options)[] PinGroups = new(string, PinType, PinOption)[8]
		{
			("Sign", (PinType)3, PinOption.Sign),
			("Town", (PinType)1, PinOption.MapTable),
			("Bonfire", (PinType)0, PinOption.Bonfire),
			("Vehicle", (PinType)260, PinOption.Cart | PinOption.WarMachine),
			("Ship", (PinType)258, PinOption.LargeShip | PinOption.SmallBoat),
			("Portal", (PinType)6, PinOption.Portal),
			("TombStone", (PinType)4, PinOption.Tombstone),
			("BossAlter", (PinType)9, PinOption.None)
		};

		private static RectTransform _iconPanel = null;

		private static RectTransform _iconPanel2 = null;

		private static RectTransform _keyHints = null;

		private static RectTransform _sharedPanel = null;

		private static RectTransform _publicPanel = null;

		private static Image _playerMarker = null;

		private static void DisableOriginalIcons()
		{
			Disable(Minimap.instance.m_selectedIcon0);
			Disable(Minimap.instance.m_selectedIcon1);
			Disable(Minimap.instance.m_selectedIcon2);
			Disable(Minimap.instance.m_selectedIcon3);
			Disable(Minimap.instance.m_selectedIcon4);
			Disable(Minimap.instance.m_selectedIconBoss);
			Disable(Minimap.instance.m_selectedIconDeath);
			static void Disable(Image img)
			{
				((Component)((Component)img).transform.parent).gameObject.SetActive(false);
			}
		}

		public static void Show(bool isVisible)
		{
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			((Component)_iconPanel).gameObject.SetActive(isVisible);
			((Component)_iconPanel2).gameObject.SetActive(isVisible);
			((Component)_keyHints).gameObject.SetActive(isVisible);
			if (_sharedPanel.anchoredPosition.y > _publicPanel.anchoredPosition.y)
			{
				RectTransform sharedPanel = _sharedPanel;
				RectTransform publicPanel = _publicPanel;
				Vector2 anchoredPosition = _publicPanel.anchoredPosition;
				Vector2 anchoredPosition2 = _sharedPanel.anchoredPosition;
				sharedPanel.anchoredPosition = anchoredPosition;
				publicPanel.anchoredPosition = anchoredPosition2;
				sharedPanel = _sharedPanel;
				RectTransform publicPanel2 = _publicPanel;
				anchoredPosition2 = _publicPanel.pivot;
				anchoredPosition = _sharedPanel.pivot;
				sharedPanel.pivot = anchoredPosition2;
				publicPanel2.pivot = anchoredPosition;
			}
			((Component)_sharedPanel).gameObject.SetActive(isVisible || !Map.IsNoMapKey);
			((Component)_publicPanel).gameObject.SetActive(isVisible);
			((Behaviour)_playerMarker).enabled = !Configs.HidePlayerArrow.Value || isVisible;
		}

		internal static void Init()
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Expected O, but got Unknown
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Expected O, but got Unknown
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Expected O, but got Unknown
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Expected O, but got Unknown
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Expected O, but got Unknown
			Transform transform = Minimap.instance.m_largeRoot.transform;
			_iconPanel = (RectTransform)transform.Find("IconPanel");
			_iconPanel2 = (RectTransform)transform.Find("IconPanel2");
			_keyHints = (RectTransform)transform.Find("KeyHints");
			_sharedPanel = (RectTransform)transform.Find("SharedPanel");
			_publicPanel = (RectTransform)transform.Find("PublicPanel");
			_playerMarker = ((Component)Minimap.instance.m_largeMarker).GetComponent<Image>();
		}

		internal static void Shutdown()
		{
		}

		private static void InitNavIcons()
		{
			//IL_000f: 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_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: 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_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_0128: Unknown result type (might be due to invalid IL or missing references)
			//IL_0138: Unknown result type (might be due to invalid IL or missing references)
			//IL_0166: Unknown result type (might be due to invalid IL or missing references)
			//IL_016b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0172: 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_0183: 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_0197: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0144: Unknown result type (might be due to invalid IL or missing references)
			//IL_014e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0153: Unknown result type (might be due to invalid IL or missing references)
			//IL_0157: Unknown result type (might be due to invalid IL or missing references)
			_iconPanel.anchoredPosition = new Vector2(-39f, -100f);
			_iconPanel.anchorMax = new Vector2(1f, 1f);
			_iconPanel.anchorMin = new Vector2(1f, 0f);
			_iconPanel.pivot = new Vector2(0.5f, 0.5f);
			_iconPanel.sizeDelta = new Vector2(100f, -110f);
			((Transform)_iconPanel).localScale = Vector3.one * 0.65f;
			((Transform)_iconPanel).Find("iconhints").localScale = Vector3.one / 0.65f;
			GameObject gameObject = ((Component)((Component)Minimap.instance.m_selectedIcon1).transform.parent).gameObject;
			Minimap.instance.m_selectedIcons.Clear();
			foreach (var item3 in IEnumerableExt.WithIndex<(string, PinType, PinOption)>((IEnumerable<(string, PinType, PinOption)>)PinGroups))
			{
				(string, PinType, PinOption) item = item3.Item1;
				int item2 = item3.Item2;
				GameObject val = Object.Instantiate<GameObject>(gameObject, (Transform)(object)_iconPanel);
				Image component = val.GetComponent<Image>();
				component.sprite = Minimap.instance.GetSprite(item.Item2);
				if (MapPinType.IsTrackedPin(item.Item2))
				{
					Color color = Color.white * 0.8f;
					((Graphic)component).color = color;
				}
				Transform transform = val.transform;
				Vector3 localPosition = transform.localPosition;
				Vector3 val2 = Vector3.down * (float)item2;
				Rect rect = ((Graphic)component).rectTransform.rect;
				transform.localPosition = localPosition + val2 * (((Rect)(ref rect)).height + 15f);
				((Object)val).name = item.Item1;
				val.SetActive(true);
				SetupEventHandlers(val, item2);
				Minimap.instance.m_selectedIcons.Add(item.Item2, ((Component)val.transform.Find("Selected")).GetComponent<Image>());
			}
		}

		private static void SetupEventHandlers(GameObject obj, int index)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Expected O, but got Unknown
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Expected O, but got Unknown
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Expected O, but got Unknown
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Expected O, but got Unknown
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Expected O, but got Unknown
			Button component = obj.GetComponent<Button>();
			((Behaviour)component).enabled = true;
			component.onClick = new ButtonClickedEvent();
			((UnityEvent)component.onClick).AddListener((UnityAction)delegate
			{
				OnSelectPinGroup(index);
			});
			MouseClick component2 = obj.GetComponent<MouseClick>();
			((Behaviour)component2).enabled = false;
			component2.m_leftClick = (UnityEvent)new ButtonClickedEvent();
			component2.m_rightClick = (UnityEvent)new ButtonClickedEvent();
			component2.m_middleClick = (UnityEvent)new ButtonClickedEvent();
		}

		private static void OnSelectPinGroup(int index)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			Logging<Plugin>.Info((object)$"Selected pin group index: {index}", 0);
			PinType item = PinGroups[index].PinType;
			Minimap.instance.ToggleIconFilter(item);
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(Minimap), "Start")]
		private static void Minimap_Start()
		{
			Init();
		}
	}
	[HarmonyPatch]
	internal static class NetPlayerPosition
	{
		[HarmonyPatch]
		private static class AlwaysShowPlayerPosition
		{
			[UsedImplicitly]
			private static IEnumerable<MethodInfo> TargetMethods()
			{
				return new <>z__ReadOnlyArray<MethodInfo>(new MethodInfo[3]
				{
					AccessTools.DeclaredMethod(typeof(ZNet), "UpdatePlayerList", (Type[])null, (Type[])null),
					AccessTools.DeclaredMethod(typeof(ZNet), "SendPlayerList", (Type[])null, (Type[])null),
					AccessTools.DeclaredMethod(typeof(ZNet), "RPC_PlayerList", (Type[])null, (Type[])null)
				});
			}

			[UsedImplicitly]
			private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> codes)
			{
				//IL_0027: Unknown result type (might be due to invalid IL or missing references)
				//IL_002d: Expected O, but got Unknown
				//IL_003b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0041: Expected O, but got Unknown
				//IL_0044: Unknown result type (might be due to invalid IL or missing references)
				CodeMatch[] array = (CodeMatch[])(object)new CodeMatch[2]
				{
					new CodeMatch((OpCode?)OpCodes.Ldfld, (object)AccessTools.DeclaredField(typeof(PlayerInfo), "m_publicPosition"), (string)null),
					new CodeMatch((OpCode?)OpCodes.Brfalse, (object)null, (string)null)
				};
				return new CodeMatcher(codes, (ILGenerator)null).MatchStartForward(array).ThrowIfInvalid("Unable to match IL").Repeat((Action<CodeMatcher>)Change, (Action<string>)null)
					.InstructionEnumeration();
				static void Change(CodeMatcher cm)
				{
					cm.Advance(-1);
					cm.SetAndAdvance(OpCodes.Nop, (object)null);
					cm.SetAndAdvance(OpCodes.Nop, (object)null);
					cm.SetAndAdvance(OpCodes.Nop, (object)null);
				}
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(ZNet), "SendServerSyncPlayerData")]
		private static void ZNet_SendServerSyncPlayerData(ZNet __instance)
		{
			if (Object.op_Implicit((Object)(object)Player.m_localPlayer) && !((Character)Player.m_localPlayer).InGodMode())
			{
				if (Configs.PinPvPStealth.Value)
				{
					__instance.SetPublicReferencePosition(!((Character)Player.m_localPlayer).IsPVPEnabled());
				}
				else
				{
					__instance.SetPublicReferencePosition(true);
				}
			}
		}
	}
	[HarmonyPatch]
	internal static class PinBoss
	{
		public enum RevealMode
		{
			Never,
			NearOnly,
			Anywhere
		}

		private const float NearDistance = 20f;

		[HarmonyPrefix]
		[HarmonyPatch(typeof(Minimap), "DiscoverLocation")]
		private static void Minimap_DiscoverLocation(PinType type, Vector3 pos, ref bool __runOriginal)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Invalid comparison between Unknown and I4
			//IL_0073: 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_009c: Unknown result type (might be due to invalid IL or missing references)
			if ((int)type != 9 || !Object.op_Implicit((Object)(object)Player.m_localPlayer))
			{
				return;
			}
			if (((Character)Player.m_localPlayer).InGodMode())
			{
				Logging<Plugin>.Info((object)"God mode is enabled, use vanilla behavior", 0);
				return;
			}
			Logging<Plugin>.Info((object)$"Boss pin reveal mode: {Configs.PinBossReveal.Value}", 0);
			switch (Configs.PinBossReveal.Value)
			{
			case RevealMode.Never:
				__runOriginal = false;
				break;
			case RevealMode.NearOnly:
				if (MathExt.DistanceTo((MonoBehaviour)(object)Player.m_localPlayer, pos) > 20f)
				{
					__runOriginal = false;
				}
				break;
			default:
				throw new ArgumentOutOfRangeException();
			case RevealMode.Anywhere:
				break;
			}
			Logging<Plugin>.Info((object)(__runOriginal ? $"Revealing pin {MathExt.XZY(pos)}" : "Suppressing pin"), 0);
		}
	}
	[HarmonyPatch]
	internal static class MapPin
	{
		public const string PrefabName = "ZenMapPin";

		public static readonly Sprite Icon = AssetIO.LoadSpriteFromResource((BaseUnityPlugin)(object)ZenMod<Plugin>.Instance, "ItemIcons.pin_nail2.png");

		internal static Action AddCraftingItem()
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Expected O, but got Unknown
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Expected O, but got Unknown
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			Logging<Plugin>.Info((object)"Add crafting item: ZenMapPin", 0);
			ItemConfig val = new ItemConfig();
			val.Name = "$map_item_pin";
			val.Description = "$map_item_pin_description";
			val.CraftingStation = Configs.MapPinCraftingStation.Value;
			val.MinStationLevel = Configs.MapPinCraftingStationLevel.Value;
			val.Requirements = Configs.MapPinItemResources.Value.ToRequirementConfigs(':');
			val.Icons = (Sprite[])(object)new Sprite[1] { Icon };
			val.Amount = 1;
			val.Weight = 0.1f;
			val.StackSize = Configs.MapPinStackSize.Value;
			CustomItem mapPinItem = new CustomItem("ZenMapPin", "Club", val);
			CustomItemExt.ApplyTextureToPrefab(mapPinItem, Icon.texture, 0.35f, Vector2.one * 2f, Vector2.zero, "", true, (Color?)null);
			ItemManager.Instance.AddItem(mapPinItem);
			return ConfigSync;
			void ConfigSync()
			{
				Recipe recipe = mapPinItem.Recipe.Recipe;
				recipe.m_craftingStation = PrefabManagerExt.GetCraftingStation(PrefabManager.Instance, Configs.MapPinCraftingStation.Value);
				recipe.m_minStationLevel = Configs.MapPinCraftingStationLevel.Value;
				recipe.m_resources = Configs.MapPinItemResources.Value.ToRequirements(':');
				recipe.m_item.m_itemData.m_shared.m_maxStackSize = Configs.MapPinStackSize.Value;
			}
		}

		public static bool IsMapPin(this ItemData? item)
		{
			return ((item != null) ? ItemDataExt.GetPrefabName(item) : null) == "ZenMapPin";
		}

		public static bool IsCursorOver(this PinData pin)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			if (!Object.op_Implicit((Object)(object)pin.m_uiElement))
			{
				return false;
			}
			Vector3 val = ZInput.mousePosition;
			if (ZInput.IsGamepadActive())
			{
				RectTransform gamepadCrosshair = Minimap.instance.m_gamepadCrosshair;
				if (!((Component)gamepadCrosshair).gameObject.activeSelf)
				{
					return false;
				}
				val = ((Transform)gamepadCrosshair).position;
			}
			Transform transform = ((Component)pin.m_uiElement).transform;
			return RectTransformUtility.RectangleContainsScreenPoint((RectTransform)(object)((transform is RectTransform) ? transform : null), Vector2.op_Implicit(val), (Camera)null);
		}

		public static void ShowLabel(this PinData pin, bool isVisible)
		{
			PinNameData namePinData = pin.m_NamePinData;
			GameObject val = ((namePinData != null) ? namePinData.PinNameGameObject : null);
			if (Object.op_Implicit((Object)(object)val))
			{
				val.SetActive(isVisible);
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(PinNameData), "SetTextAndGameObject")]
		private static void PinNameData_SetTextAndGameObject(PinNameData __instance)
		{
			__instance.PinNameGameObject.SetActive(false);
		}

		[HarmonyTranspiler]
		[HarmonyPatch(typeof(Minimap), "CreateMapNamePin")]
		private static IEnumerable<CodeInstruction> Minimap_CreateMapNamePin(IEnumerable<CodeInstruction> codes)
		{
			MethodInfo methodInfo = AccessTools.DeclaredMethod(typeof(MonoBehaviour), "StartCoroutine", new Type[1] { typeof(IEnumerator) }, (Type[])null);
			Func<MonoBehaviour, IEnumerator, Coroutine> func2 = SuppressCoroutine;
			return Transpilers.MethodReplacer(codes, (MethodBase)methodInfo, (MethodBase)func2.Method);
			static Coroutine? SuppressCoroutine(MonoBehaviour self, IEnumerator func)
			{
				return null;
			}
		}
	}
	[HarmonyPatch]
	internal static class PinDeath
	{
		public static bool AllowAdd;

		[HarmonyPrefix]
		[HarmonyPatch(typeof(Minimap), "AddPin")]
		private static void Minimap_AddPin(PinType type, ref bool __runOriginal)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Invalid comparison between Unknown and I4
			__runOriginal = (int)type != 4 || AllowAdd;
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(Minimap), "LoadMapData")]
		private static void Minimap_LoadMapData(Minimap __instance)
		{
			__instance.m_pins.RemoveAll((PinData pin) => (int)pin.m_type == 4);
		}
	}
	[HarmonyPatch]
	internal static class MapPinType
	{
		internal static class VisibleTypes
		{
			public static readonly bool[] Everything = Init(state: true);

			public static readonly bool[] CompassNoMap = Init(state: false);

			public static readonly bool[] CompassWithMap = Init(state: false);

			public static readonly bool[] MapTable = Init(state: false);

			public static readonly bool[] MapItem = Init(state: false);

			public static readonly bool[] Nothing = Init(state: false);

			private static bool[] Init(bool state)
			{
				return Enumerable.Repeat(state, 384).ToArray();
			}
		}

		private const int ReservedTypes = 128;

		private const PinType ReservedStart = 256;

		private const PinType ReservedEnd = 384;

		internal const PinType UserPin = 288;

		public const PinType Raft = 256;

		public const PinType Karve = 257;

		public const PinType VikingShip = 258;

		public const PinType VikingShipAshlands = 259;

		public const PinType Cart = 260;

		public const PinType Catapult = 261;

		public const PinType BatteringRam = 262;

		public const PinType Mount = 263;

		public const PinType None = 8;

		public const PinType Campfire = 0;

		public const PinType House = 1;

		public const PinType Hammer = 2;

		public const PinType Dot = 3;

		public const PinType Portal = 6;

		public const PinType Death = 4;

		public const PinType Boss = 9;

		public const PinType Bed = 5;

		public const PinType Player = 10;

		public static bool IsSignPin(PinType type)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Invalid comparison between Unknown and I4
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Invalid comparison between Unknown and I4
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Invalid comparison between Unknown and I4
			if ((int)type >= 288)
			{
				if ((int)type < 384)
				{
					goto IL_0016;
				}
			}
			else if ((int)type == 3)
			{
				goto IL_0016;
			}
			return false;
			IL_0016:
			return true;
		}

		public static bool IsTrackedPin(PinType type)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Invalid comparison between Unknown and I4
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Invalid comparison between Unknown and I4
			if ((int)type < 256 || (int)type >= 384)
			{
				return IsSignPin(type);
			}
			return true;
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(Minimap), "Start")]
		private static void Minimap_Start(Minimap __instance)
		{
			Minimap.instance.m_visibleIconTypes = VisibleTypes.Nothing;
		}
	}
	[HarmonyPatch]
	internal static class MapPinIcon
	{
		internal static readonly Dictionary<int, PinType> NamedPinTypes;

		internal static readonly Dictionary<PinType, string> PinTypeToResource;

		private static readonly Dictionary<string, Sprite> SpriteCache;

		static MapPinIcon()
		{
			NamedPinTypes = new Dictionary<int, PinType>
			{
				[MapTrack.Pin.Raft] = (PinType)256,
				[MapTrack.Pin.Karve] = (PinType)257,
				[MapTrack.Pin.Longship] = (PinType)258,
				[MapTrack.Pin.Drakkar] = (PinType)259,
				[MapTrack.Pin.Cart] = (PinType)260,
				[MapTrack.Pin.Catapult] = (PinType)261,
				[MapTrack.Pin.BatteringRam] = (PinType)262,
				[MapTrack.Pin.Tombstone] = (PinType)4,
				[MapTrack.Pin.Bonfire] = (PinType)0,
				[MapTrack.Pin.MapTable] = (PinType)1,
				[MapTrack.Pin.PortalWood] = (PinType)6,
				[MapTrack.Pin.PortalStone] = (PinType)6
			};
			PinTypeToResource = new Dictionary<PinType, string>
			{
				[(PinType)3] = "flag",
				[(PinType)256] = "vehicle_ship_raft",
				[(PinType)257] = "vehicle_ship_karve",
				[(PinType)258] = "vehicle_ship_longboat",
				[(PinType)259] = "vehicle_ship_drakkar",
				[(PinType)260] = "vehicle_cart",
				[(PinType)261] = "vehicle_catapult",
				[(PinType)262] = "vehicle_batteringram",
				[(PinType)263] = "horse",
				[(PinType)288] = "anvil",
				[(PinType)289] = "cauldron",
				[(PinType)290] = "pickaxe",
				[(PinType)291] = "armor",
				[(PinType)292] = "axe",
				[(PinType)293] = "sword",
				[(PinType)294] = "potion",
				[(PinType)295] = "bow",
				[(PinType)296] = "stackedbars",
				[(PinType)297] = "chest",
				[(PinType)298] = "tree",
				[(PinType)299] = "berries",
				[(PinType)300] = "berries2",
				[(PinType)301] = "carrot",
				[(PinType)302] = "turnip",
				[(PinType)303] = "onion",
				[(PinType)304] = "mushroom",
				[(PinType)305] = "fish",
				[(PinType)306] = "bee",
				[(PinType)307] = "flower",
				[(PinType)308] = "bread",
				[(PinType)309] = "grain",
				[(PinType)310] = "pig",
				[(PinType)311] = "chicken",
				[(PinType)312] = "wolf",
				[(PinType)313] = "castle",
				[(PinType)314] = "castle2",
				[(PinType)315] = "tent",
				[(PinType)316] = "bridge",
				[(PinType)317] = "cave",
				[(PinType)318] = "crystal",
				[(PinType)319] = "magic_circle",
				[(PinType)320] = "magic_eye",
				[(PinType)321] = "magic_book",
				[(PinType)322] = "swirl",
				[(PinType)323] = "monster",
				[(PinType)324] = "monster_trex",
				[(PinType)325] = "dragon",
				[(PinType)326] = "dragon2",
				[(PinType)327] = "kraken",
				[(PinType)328] = "question"
			};
			SpriteCache = new Dictionary<string, Sprite>();
			Logging<Plugin>.Info((object)"Init sprite cache", 0);
			SpriteCache.Clear();
			foreach (string item in PinTypeToResource.Values.Distinct())
			{
				SpriteCache.Add(item, LoadSprite(item));
			}
		}

		private static Sprite LoadSprite(string name)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if (name.StartsWith("#"))
				{
					PinType val = (PinType)int.Parse(name.Substring(1));
					return Minimap.instance.GetSprite(val);
				}
				if (name.StartsWith("$"))
				{
					string text = name.Substring(1);
					GameObject prefab = ZNetScene.instance.GetPrefab(text);
					if (Object.op_Implicit((Object)(object)prefab))
					{
						return prefab.GetComponent<Piece>().m_icon;
					}
					prefab = ObjectDB.instance.GetItemPrefab(text);
					if (Object.op_Implicit((Object)(object)prefab))
					{
						return ItemDataExt.GetIcon(prefab.GetComponent<ItemDrop>());
					}
					throw new NullReferenceException("Prefab not found: " + name);
				}
				return AssetIO.LoadSpriteFromResource((BaseUnityPlugin)(object)ZenMod<Plugin>.Instance, "MapPins." + name + ".png");
			}
			catch (Exception innerException)
			{
				throw new Exception("Failed to load sprite: " + name, innerException);
			}
		}

		private static PinType GetPrefabPinType(int prefabHash)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			if (!NamedPinTypes.TryGetValue(prefabHash, out var value))
			{
				return (PinType)3;
			}
			return value;
		}

		internal static PinType GetPinTypeFromResourceName(string name)
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			string name2 = name;
			return PinTypeToResource.First<KeyValuePair<PinType, string>>((KeyValuePair<PinType, string> kvp) => kvp.Value == name2).Key;
		}

		internal static PinType GetPinType(this ZDO zdo)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			return GetPrefabPinType(zdo.GetPrefab());
		}

		private static Sprite? GetCustomIcon(PinType pinType)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			if (!PinTypeToResource.TryGetValue(pinType, out string value))
			{
				return null;
			}
			return SpriteCache[value];
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(Minimap), "GetSprite")]
		private static void Minimap_GetSprite(PinType type, ref Sprite? __result, ref bool __runOriginal)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			Sprite customIcon = GetCustomIcon(type);
			if (Object.op_Implicit((Object)(object)customIcon))
			{
				__result = customIcon;
				__runOriginal = false;
			}
		}
	}
	[HarmonyPatch]
	internal static class MapTrack
	{
		public static class Pin
		{
			public static readonly int Sign = StringExtensionMethods.GetStableHashCode("sign");

			public static readonly int Tombstone = StringExtensionMethods.GetStableHashCode("Player_tombstone");

			public static readonly int MapTable = StringExtensionMethods.GetStableHashCode("piece_cartographytable");

			public static readonly int Bonfire = StringExtensionMethods.GetStableHashCode("bonfire");

			public static readonly int Raft = StringExtensionMethods.GetStableHashCode("Raft");

			public static readonly int Karve = StringExtensionMethods.GetStableHashCode("Karve");

			public static readonly int Longship = StringExtensionMethods.GetStableHashCode("VikingShip");

			public static readonly int Drakkar = StringExtensionMethods.GetStableHashCode("VikingShip_Ashlands");

			public static readonly int Cart = StringExtensionMethods.GetStableHashCode("Cart");

			public static readonly int Catapult = StringExtensionMethods.GetStableHashCode("Catapult");

			public static readonly int BatteringRam = StringExtensionMethods.GetStableHashCode("BatteringRam");

			public static readonly int PortalWood = StringExtensionMethods.GetStableHashCode("portal_wood");

			public static readonly int PortalStone = StringExtensionMethods.GetStableHashCode("portal_stone");

			public static readonly HashSet<int> Mounts = new HashSet<int>();
		}

		private static class LegacyDataScan
		{
			private static readonly Dictionary<string, int> Results = new Dictionary<string, int>();

			private static bool IsCleanMode => Configs.RemoveLegacyData.Value;

			public static void ResetState()
			{
				Results.Clear();
			}

			public static void Check(ZDO zdo)
			{
				if (IsTrackable(zdo))
				{
					return;
				}
				byte[] byteArray = zdo.GetByteArray(ZDOVarGUID, (byte[])null);
				if (byteArray != null && byteArray.Length != 0)
				{
					if (IsCleanMode)
					{
						zdo.Set(ZDOVarGUID, Array.Empty<byte>());
					}
					string prefabName = ZdoExt.GetPrefabName(zdo);
					Results[prefabName] = ((!Results.TryGetValue(prefabName, out var value)) ? 1 : (value + 1));
				}
			}

			public static void ShowResults()
			{
				if (Results.Count == 0)
				{
					if (IsCleanMode)
					{
						Logging<Plugin>.Message((object)"No legacy data found", 0);
					}
					else
					{
						Logging<Plugin>.Info((object)"No legacy data found", 0);
					}
				}
				else if (!IsCleanMode)
				{
					DumpResults("Old data found");
					Logging<Plugin>.Message((object)string.Format("Legacy {0} data found in {1} ZDOs", "ZenMap", Results.Sum<KeyValuePair<string, int>>((KeyValuePair<string, int> kvp) => kvp.Value)), 0);
					Logging<Plugin>.Message((object)"This is not harming anything, but it is ZDO bloat", 0);
					Logging<Plugin>.Message((object)"To remove legacy data enable the debug config option and then restart.", 0);
					Logging<Plugin>.Message((object)"Make a backup of your world first!", 0);
				}
				else
				{
					DumpResults("Old data removed");
					Logging<Plugin>.Message((object)string.Format("Legacy {0} data removed from {1} ZDOs", "ZenMap", Results.Sum<KeyValuePair<string, int>>((KeyValuePair<string, int> kvp) => kvp.Value)), 0);
					Logging<Plugin>.Message((object)"Process complete. Turn off the debug config option and then restart.", 0);
				}
			}

			private static void DumpResults(string prefix)
			{
				string prefix2 = prefix;
				foreach (string item in Results.Select<KeyValuePair<string, int>, string>((KeyValuePair<string, int> kvp) => $"{prefix2}: {kvp.Value,8} {kvp.Key}"))
				{
					if (IsCleanMode)
					{
						Logging<Plugin>.Warning((object)item, 0);
					}
					else
					{
						Logging<Plugin>.Message((object)item, 0);
					}
				}
			}
		}

		internal static readonly Dictionary<int, PinOption> PinToOption = new Dictionary<int, PinOption>
		{
			{
				Pin.Sign,
				PinOption.Sign
			},
			{
				Pin.Raft,
				PinOption.SmallBoat
			},
			{
				Pin.Karve,
				PinOption.SmallBoat
			},
			{
				Pin.Longship,
				PinOption.LargeShip
			},
			{
				Pin.Drakkar,
				PinOption.LargeShip
			},
			{
				Pin.Cart,
				PinOption.Cart
			},
			{
				Pin.Catapult,
				PinOption.WarMachine
			},
			{
				Pin.BatteringRam,
				PinOption.WarMachine
			},
			{
				Pin.Tombstone,
				PinOption.Tombstone
			},
			{
				Pin.MapTable,
				PinOption.MapTable
			},
			{
				Pin.Bonfire,
				PinOption.Bonfire
			},
			{
				Pin.PortalWood,
				PinOption.Portal
			},
			{
				Pin.PortalStone,
				PinOption.Portal
			}
		};

		private const string GuidPrefix = "GUID|";

		private static readonly int ZDOVarGUID = StringExtensionMethods.GetStableHashCode("GUID|");

		private static readonly Dictionary<Guid, ZDOID> GuidIndexZDOID = new Dictionary<Guid, ZDOID>();

		private static readonly Dictionary<Guid, PinData> GuidIndexPin = new Dictionary<Guid, PinData>();

		private static readonly Dictionary<PinData, Guid> PinToGuidCache = new Dictionary<PinData, Guid>();

		private static bool _isIndexReady;

		private const string DataDelimiter = "\0#";

		private static readonly int DataSize;

		private static readonly HashSet<PinData> VisiblePins;

		internal static void Init()
		{
			Configs.UpdatePinOptions();
			ZRoutedRpc.instance.Register<ZDOID>("RPC_StopTracking", (Action<long, ZDOID>)RPC_StopTracking);
			_isIndexReady = false;
			Logging<Plugin>.Info((object)"Waiting before rebuilding index...", 0);
			Timing.Delay((MonoBehaviour)(object)ZenMod<Plugin>.Instance, 3f, (Action)delegate
			{
				RebuildIndex();
				SetupAutoPins();
				_isIndexReady = true;
			});
			VisiblePins.Clear();
		}

		internal static void Shutdown()
		{
			_isIndexReady = false;
			ZRoutedRpc instance = ZRoutedRpc.instance;
			if (instance != null)
			{
				ZRoutedRpcExt.Unregister(instance, "RPC_StopTracking");
			}
		}

		public static PinOption GetPinOption(int prefabHash)
		{
			if (!PinToOption.TryGetValue(prefabHash, out var value))
			{
				return PinOption.None;
			}
			return value;
		}

		private static void SetupAutoPins()
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			Logging<Plugin>.Debug((object)"Refreshing AutoPins", 0);
			ZDOID[] array = GuidIndexZDOID.Values.ToArray();
			foreach (ZDOID val in array)
			{
				ZDO zDO = ZDOMan.instance.GetZDO(val);
				if (zDO == null)
				{
					Logging<Plugin>.Warning((object)$"ZDO is null for ZDOID: {val} - skipping.", 0);
				}
				else
				{
					AutoPinIfReq(zDO);
				}
			}
		}

		[HarmonyTranspiler]
		[HarmonyPatch(typeof(Minimap), "AddPin")]
		private static IEnumerable<CodeInstruction> Minimap_AddPin(IEnumerable<CodeInstruction> codes)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Expected O, but got Unknown
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Expected O, but got Unknown
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Expected O, but got Unknown
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			CodeMatch[] array = (CodeMatch[])(object)new CodeMatch[3]
			{
				new CodeMatch((OpCode?)OpCodes.Ldarg_0, (object)null, (string)null),
				new CodeMatch((OpCode?)OpCodes.Ldarg_2, (object)null, (string)null),
				new CodeMatch((OpCode?)OpCodes.Call, (object)AccessTools.DeclaredMethod(typeof(Minimap), "ToggleIconFilter", (Type[])null, (Type[])null), (string)null)
			};
			return new CodeMatcher(codes, (ILGenerator)null).MatchStartForward(array).ThrowIfInvalid("Unable to match IL").SetAndAdvance(OpCodes.Nop, (object)null)
				.SetAndAdvance(OpCodes.Nop, (object)null)
				.SetAndAdvance(OpCodes.Nop, (object)null)
				.InstructionEnumeration();
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(Minimap), "UpdatePins")]
		private static void Minimap_UpdatePins(Minimap __instance)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Invalid comparison between Unknown and I4
			bool flag = (int)__instance.m_mode != 2;
			Minimap instance = Minimap.instance;
			bool[] visibleIconTypes = (((Character)Player.m_localPlayer).InGodMode() ? MapPinType.VisibleTypes.Everything : (MapLocation.IsMapItem() ? MapPinType.VisibleTypes.MapItem : (MapLocation.IsMapTable() ? MapPinType.VisibleTypes.MapTable : ((!flag) ? MapPinType.VisibleTypes.Nothing : (InventoryCheck.HaveMap ? MapPinType.VisibleTypes.CompassWithMap : MapPinType.VisibleTypes.CompassNoMap)))));
			instance.m_visibleIconTypes = visibleIconTypes;
		}

		[HarmonyTranspiler]
		[HarmonyPatch(typeof(Minimap), "UpdatePins")]
		private static IEnumerable<CodeInstruction> Minimap_UpdatePins_Transpiler(IEnumerable<CodeInstruction> codes)
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Expected O, but got Unknown
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Expected O, but got Unknown
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Expected O, but got Unknown
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Expected O, but got Unknown
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Expected O, but got Unknown
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: Expected O, but got Unknown
			//IL_0106: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Expected O, but got Unknown
			//IL_012d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0133: Expected O, but got Unknown
			//IL_0136: Unknown result type (might be due to invalid IL or missing references)
			Func<Minimap, PinData, RawImage, bool> func = IsPointVisibleIntercept;
			CodeMatch[] array = (CodeMatch[])(object)new CodeMatch[4]
			{
				new CodeMatch((OpCode?)OpCodes.Ldloc_S, (object)null, (string)null),
				new CodeMatch((OpCode?)OpCodes.Ldfld, (object)AccessTools.DeclaredField(typeof(PinData), "m_pos"), (string)null),
				new CodeMatch((OpCode?)OpCodes.Ldloc_0, (object)null, (string)null),
				new CodeMatch((OpCode?)OpCodes.Call, (object)AccessTools.DeclaredMethod(typeof(Minimap), "IsPointVisible", (Type[])null, (Type[])null), (string)null)
			};
			Func<PinData, RectTransform> func2 = PinUIElementIntercept;
			CodeMatch[] array2 = (CodeMatch[])(object)new CodeMatch[4]
			{
				new CodeMatch((OpCode?)OpCodes.Ldloc_S, (object)null, (string)null),
				new CodeMatch((OpCode?)OpCodes.Ldfld, (object)AccessTools.DeclaredField(typeof(PinData), "m_uiElement"), (string)null),
				new CodeMatch((OpCode?)OpCodes.Ldloc_S, (object)null, (string)null),
				new CodeMatch((OpCode?)OpCodes.Callvirt, (object)AccessTools.DeclaredPropertySetter(typeof(RectTransform), "anchoredPosition"), (string)null)
			};
			return new CodeMatcher(codes, (ILGenerator)null).MatchStartForward(array).ThrowIfInvalid("Unable to match IL sequence1").Advance(1)
				.SetAndAdvance(OpCodes.Nop, (object)null)
				.Advance(1)
				.Set(OpCodes.Call, (object)func.Method)
				.MatchStartForward(array2)
				.ThrowIfInvalid("Unable to match IL sequence2")
				.Advance(1)
				.SetAndAdvance(OpCodes.Call, (object)func2.Method)
				.InstructionEnumeration();
			static bool IsPointVisibleIntercept(Minimap minimap, PinData pin, RawImage map)
			{
				//IL_0002: 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 (!minimap.IsPointVisible(pin.m_pos, map))
				{
					return false;
				}
				if (Configs.ShowBonfiresOnlyWhenLit.Value && (int)pin.m_type == 0 && pin.TryGetZDO(out ZDO zdo) && zdo.GetPrefab() == Pin.Bonfire && !FireplaceUtils.IsLit(zdo))
				{
					return false;
				}
				return true;
			}
			static RectTransform PinUIElementIntercept(PinData pin)
			{
				VisiblePins.Add(pin);
				return pin.m_uiElement;
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(Minimap), "DestroyPinMarker")]
		private static void Minimap_DestroyPinMarker(PinData pin)
		{
			VisiblePins.Remove(pin);
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(Minimap), "UpdateDynamicPins")]
		private static void Minimap_UpdateDynamicPins(float dt)
		{
			if (_isIndexReady)
			{
				UpdatePins(dt);
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(Minimap), "AddPin")]
		private static void Minimap_AddPin(PinData? __result)
		{
			if (__result != null)
			{
				UpdateIndex(__result);
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(Minimap), "RemovePin", new Type[] { typeof(PinData) })]
		private static void Minimap_RemovePin(PinData? pin)
		{
			if (pin != null)
			{
				GuidIndexPin.Remove(pin.GetGuid());
				RemoveFromCache(pin);
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(ZDOMan), "CreateSyncList")]
		private static void ZDOMan_CreateSyncList(ZDOMan __instance)
		{
			if (!ZNet.IsSinglePlayer && ZNet.instance.IsServer())
			{
				CollectionExtensions.Do<ZDOID>((IEnumerable<ZDOID>)GuidIndexZDOID.Values, (Action<ZDOID>)__instance.ForceSendZDO);
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(ZDOMan), "HandleDestroyedZDO")]
		private static void ZDOMan_HandleDestroyedZDO(ZDOID uid)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			if (!Game.instance.IsShuttingDown())
			{
				RemoveIndexAndPin(uid, out ZDO _);
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(ZDOMan), "FilterZDO")]
		private static void ZDOMan_FilterZDO(ZDO? zdo)
		{
			if (zdo != null)
			{
				UpdateIndex(zdo);
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(ZDOMan), "GetZDO")]
		private static void ZDOMan_GetZDO(ZDO? __result)
		{
			if (__result != null)
			{
				UpdateIndex(__result);
			}
		}

		[HarmonyTranspiler]
		[HarmonyPatch(typeof(ZDOMan), "RPC_ZDOData")]
		[HarmonyPriority(0)]
		private static IEnumerable<CodeInstruction> ZDOMan_RPC_ZDOData(IEnumerable<CodeInstruction> codes)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Expected O, but got Unknown
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Expected O, but got Unknown
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Expected O, but got Unknown
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			CodeMatch val = new CodeMatch((OpCode?)OpCodes.Callvirt, (object)AccessTools.DeclaredMethod(typeof(ZDO), "Deserialize", (Type[])null, (Type[])null), (string)null);
			Action<ZDO> action = ApplyIndex;
			CodeInstruction[] array = (CodeInstruction[])(object)new CodeInstruction[2]
			{
				new CodeInstruction(OpCodes.Ldloc_S, (object)(byte)12),
				new CodeInstruction(OpCodes.Call, (object)action.Method)
			};
			return new CodeMatcher(codes, (ILGenerator)null).MatchEndForward((CodeMatch[])(object)new CodeMatch[1] { val }).ThrowIfInvalid("Unable to match IL sequence").Advance(1)
				.Insert(array)
				.InstructionEnumeration();
			static void ApplyIndex(ZDO zdo)
			{
				UpdateIndex(zdo);
				AutoPinIfReq(zdo);
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(ZNetView), "Awake")]
		private static void ZNetView_Awake(ZNetView __instance)
		{
			if (__instance.IsValid())
			{
				AutoPinIfReq(__instance.GetZDO());
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(Piece), "SetCreator")]
		private static void Piece_SetCreator(Piece __instance, long uid)
		{
			if (uid != 0L && Object.op_Implicit((Object)(object)__instance.m_nview) && __instance.m_nview.IsValid())
			{
				AutoPinIfReq(__instance.m_nview.GetZDO());
			}
		}

		public static int GetPrefabHash(this PinData pin)
		{
			if (!pin.TryGetZDO(out ZDO zdo))
			{
				return 0;
			}
			return zdo.GetPrefab();
		}

		private static bool IsTrackable(ZDO zdo)
		{
			int prefab = zdo.GetPrefab();
			if (prefab == Pin.Bonfire && !ZdoExt.IsPlayerCreated(zdo))
			{
				return false;
			}
			if (!PinToOption.ContainsKey(prefab))
			{
				return Pin.Mounts.Contains(prefab);
			}
			return true;
		}

		private static bool IsAutoPinPrefab(ZDO zdo)
		{
			if (!IsTrackable(zdo))
			{
				return false;
			}
			int prefab = zdo.GetPrefab();
			if (prefab == Pin.Sign)
			{
				return false;
			}
			if (Pin.Mounts.Contains(prefab))
			{
				return false;
			}
			return true;
		}

		private static void AutoPinIfReq(ZDO zdo)
		{
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			if (IsAutoPinPrefab(zdo))
			{
				if (ZNet.instance.IsDedicated())
				{
					TrackZDO(zdo);
				}
				else if (zdo.FindPin() == null)
				{
					Logging<Plugin>.Info((object)$"Adding autopin for ZDO: {ZdoExt.GetPrefabName(zdo)} {zdo.m_uid}", 0);
					AddPin(zdo, save: false, (PinType)8);
				}
			}
		}

		private static void RebuildIndex()
		{
			LegacyDataScan.ResetState();
			Logging<Plugin>.Info((object)"Rebuilding Guid to ZDO index", 0);
			GuidIndexZDOID.Clear();
			foreach (ZDO value in ZDOMan.instance.m_objectsByID.Values)
			{
				LegacyDataScan.Check(value);
				UpdateIndex(value);
				if (ZNet.instance.IsServer() && IsAutoPinPrefab(value))
				{
					TrackZDO(value);
				}
			}
			LegacyDataScan.ShowResults();
			Logging<Plugin>.Info((object)"Rebuilding Guid to PinData index", 0);
			GuidIndexPin.Clear();
			PinToGuidCache.Clear();
			foreach (PinData pin in Minimap.instance.m_pins)
			{
				UpdateIndex(pin);
				VerifyMountPins(pin);
			}
		}

		private static void VerifyMountPins(PinData pin)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Invalid comparison between Unknown and I4
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			if ((int)pin.m_type != 263 && Pin.Mounts.Contains(pin.GetPrefabHash()))
			{
				Logging<Plugin>.Message((object)("Restoring mount pin type for " + pin.GetLabel()), 0);
				pin.m_type = (PinType)263;
				pin.m_icon = Minimap.instance.GetSprite(pin.m_type);
			}
		}

		private static Guid UpdateIndex(PinData pin)
		{
			Guid guid = pin.GetGuid();
			if (guid != Guid.Empty)
			{
				GuidIndexPin[guid] = pin;
			}
			return guid;
		}

		private static Guid UpdateIndex(ZDO zdo)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			Guid guid = zdo.GetGuid();
			if (guid != Guid.Empty)
			{
				GuidIndexZDOID[guid] = zdo.m_uid;
			}
			return guid;
		}

		private static ZDOID LookupZDOID(Guid guid)
		{
			//IL_000d: 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_0022: Unknown result type (might be due to invalid IL or missing references)
			if (guid == Guid.Empty)
			{
				return ZDOID.None;
			}
			if (!GuidIndexZDOID.TryGetValue(guid, out var value))
			{
				return ZDOID.None;
			}
			return value;
		}

		private static Guid GetGuid(this ZDO? zdo)
		{
			byte[] array = ((zdo != null) ? zdo.GetByteArray(ZDOVarGUID, (byte[])null) : null);
			if (array == null || array.Length != 16)
			{
				return Guid.Empty;
			}
			return new Guid(array);
		}

		public static string CreateTrackingLabel(string label, Guid guid)
		{
			if (label.Contains("\0#"))
			{
				throw new ArgumentException("label already contains guid, double guid encoding is not safe");
			}
			return label + "\0#" + guid.ToString("N");
		}

		private static string RemoveTrackingFromLabel(string label)
		{
			int num = label.IndexOf("\0#", StringComparison.Ordinal);
			if (num >= 0)
			{
				return label.Substring(0, num);
			}
			return label;
		}

		public static bool IsTracked(this PinData pin)
		{
			return pin.GetGuid() != Guid.Empty;
		}

		public static Guid GetGuid(this PinData pin)
		{
			if (PinToGuidCache.TryGetValue(pin, out var value))
			{
				return value;
			}
			if (Utility.IsNullOrWhiteSpace(pin.m_name) || pin.m_name.Length < DataSize + "\0#".Length)
			{
				return Guid.Empty;
			}
			int num = pin.m_name.IndexOf("\0#"[0]);
			if (num < 0 || num >= pin.m_name.Length - 1 || pin.m_name[num + 1] != "\0#"[1])
			{
				return Guid.Empty;
			}
			value = Guid.ParseExact(pin.m_name.Substring(num + "\0#".Length, DataSize), "N");
			Logging<Plugin>.Info((object)$"Caching Pin: {value}", 0);
			PinToGuidCache.Add(pin, value);
			return value;
		}

		public static string GetLabel(this PinData pin)
		{
			return RemoveTrackingFromLabel(pin.m_name);
		}

		public static PinData? FindPin(this ZDO zdo)
		{
			return FindPin(zdo.GetGuid());
		}

		private static PinData? FindPin(Guid guid)
		{
			if (!GuidIndexPin.TryGetValue(guid, out PinData value))
			{
				return null;
			}
			return value;
		}

		public static void RemovePin(PinData pin)
		{
			//IL_000c: 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)
			Logging<Plugin>.Info((object)$"Remove Pin: {pin.m_name} {MathExt.XZY(pin.m_pos)}", 0);
			Minimap.instance.RemovePin(pin);
		}

		internal static void RemoveFromCache(PinData pin)
		{
			PinToGuidCache.Remove(pin);
		}

		private static void RPC_StopTracking(long sender, ZDOID zid)
		{
			//IL_0000: 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)
			if (RemoveIndexAndPin(zid, out ZDO removedZDO) && removedZDO.IsOwner())
			{
				Logging<Plugin>.Info((object)$"Zero out Guid for ZDO: {zid}", 0);
				removedZDO.Set(ZDOVarGUID, Array.Empty<byte>());
			}
		}

		public static void StopTracking(ZDO zdo)
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			if (!zdo.HasOwner())
			{
				zdo.SetOwner(ZDOMan.GetSessionID());
			}
			ZRoutedRpc.instance.InvokeRoutedRPC(ZRoutedRpc.Everybody, "RPC_StopTracking", new object[1] { zdo.m_uid });
		}

		private static bool RemoveIndexAndPin(ZDOID zid, out ZDO removedZDO)
		{
			//IL_0006: 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)
			removedZDO = ZDOMan.instance.GetZDO(zid);
			Guid guid = removedZDO.GetGuid();
			if (guid != Guid.Empty)
			{
				Logging<Plugin>.Info((object)$"ZDOID: {zid} remove Guid: {guid}", 0);
				GuidIndexZDOID.Remove(guid);
			}
			if (Object.op_Implicit((Object)(object)Minimap.instance))
			{
				PinData val = FindPin(guid);
				if (val != null)
				{
					RemovePin(val);
				}
			}
			return removedZDO != null;
		}

		private static Guid TrackZDO(ZDO zdo)
		{
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			Guid guid = zdo.GetGuid();
			if (guid != Guid.Empty)
			{
				return guid;
			}
			ZNetView val = ZNetScene.instance.FindInstance(zdo);
			if (Object.op_Implicit((Object)(object)val))
			{
				val.ClaimOwnership();
			}
			guid = Guid.NewGuid();
			Logging<Plugin>.Info((object)$"Create new Guid: {guid} for zdo {zdo.m_uid}", 0);
			zdo.Set(ZDOVarGUID, guid.ToByteArray());
			UpdateIndex(zdo);
			return guid;
		}

		public static bool TryGetZDO(Guid guid, out ZDO zdo)
		{
			//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_000d: Unknown result type (might be due to invalid IL or missing references)
			ZDOID val = LookupZDOID(guid);
			zdo = ZDOMan.instance.GetZDO(val);
			return zdo != null;
		}

		private static bool TryGetZDO(this PinData pin, out ZDO zdo)
		{
			return TryGetZDO(pin.GetGuid(), out zdo);
		}

		private static bool IsSharedPin(PinData pin)
		{
			if (pin.m_ownerID != Player.m_localPlayer.GetPlayerID())
			{
				return pin.m_ownerID != 0;
			}
			return false;
		}

		private static void UpdatePins(float dt)
		{
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Invalid comparison between Unknown and I4
			//IL_0125: Unknown result type (might be due to invalid IL or missing references)
			//IL_012a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0130: Unknown result type (might be due to invalid IL or missing references)
			//IL_0135: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0143: Unknown result type (might be due to invalid IL or missing references)
			//IL_014a: Unknown result type (might be due to invalid IL or missing references)
			//IL_014f: Unknown result type (might be due to invalid IL or missing references)
			//IL_015d: Unknown result type (might be due to invalid IL or missing references)
			//IL_015f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0161: Unknown result type (might be due to invalid IL or missing references)
			//IL_016f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0188: 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_018f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0192: Invalid comparison between Unknown and I4
			//IL_0194: Unknown result type (might be due to invalid IL or missing references)
			//IL_0197: Invalid comparison between Unknown and I4
			if (Game.instance.IsShuttingDown())
			{
				return;
			}
			Player localPlayer = Player.m_localPlayer;
			ZNetView attached = null;
			Ship controlled = PlayerExt.GetControlled<Ship>(localPlayer);
			if (Object.op_Implicit((Object)(object)controlled))
			{
				attached = controlled.m_nview;
			}
			if (!Object.op_Implicit((Object)(object)attached))
			{
				Sadle controlled2 = PlayerExt.GetControlled<Sadle>(localPlayer);
				if (Object.op_Implicit((Object)(object)controlled2))
				{
					attached = controlled2.m_nview;
				}
			}
			if (!Object.op_Implicit((Object)(object)attached) && ((Character)localPlayer).IsAttachedToShip() && Object.op_Implicit((Object)(object)localPlayer.m_attachPoint))
			{
				attached = ((Component)localPlayer.m_attachPoint).GetComponentInParent<ZNetView>();
			}
			List<PinData> list = new List<PinData>();
			foreach (PinData visiblePin in VisiblePins)
			{
				if ((int)Minimap.instance.m_mode == 2)
				{
					visiblePin.ShowLabel(visiblePin.IsCursorOver() || Map.IsLabelTogglePressed);
				}
				if (IsSharedPin(visiblePin))
				{
					Logging<Plugin>.Debug((object)"Shared pin found, ignoring", 0);
					continue;
				}
				if (!visiblePin.TryGetZDO(out ZDO zdo2))
				{
					if (visiblePin.GetGuid() != Guid.Empty)
					{
						list.Add(visiblePin);
					}
					continue;
				}
				Vector3 position = zdo2.GetPosition();
				visiblePin.m_pos = Vector3.MoveTowards(visiblePin.m_pos, position, 200f * dt);
				Vector3 pos = visiblePin.m_pos;
				pos.y = 0f;
				Vector3 val = pos;
				pos = position;
				pos.y = 0f;
				if (!MathExt.Approximately(val, pos))
				{
					Minimap.instance.m_pinUpdateRequired = true;
				}
				MapMode mode = Minimap.instance.m_mode;
				if ((int)mode > 1)
				{
					if ((int)mode != 2)
					{
						throw new ArgumentOutOfRangeException("m_mode");
					}
					bool flag = PlayerExt.IsShipCaptain(localPlayer) && (!Configs.HideShipBanana.Value || ((Character)Player.m_localPlayer).InGodMode());
					ShowShipBanana(flag);
					ShowAttachedPin(visiblePin, zdo2, !flag);
					visiblePin.SetLabel(zdo2.GetLabel());
				}
				else
				{
					ShowAttachedPin(visiblePin, zdo2, isVisible: false);
				}
			}
			list.ForEach(RemovePin);
			void ShowAttachedPin(PinData pin, ZDO zdo, bool isVisible)
			{
				bool flag2 = Object.op_Implicit((Object)(object)attached) && zdo == attached.GetZDO();
				ShowPin(pin, isVisible || !flag2);
			}
			static void ShowPin(PinData pin, bool isVisible)
			{
				if (Object.op_Implicit((Object)(object)pin.m_uiElement))
				{
					((Component)pin.m_uiElement).gameObject.SetActive(isVisible);
				}
			}
			static void ShowShipBanana(bool isVisible)
			{
				((Component)Minimap.instance.m_largeShipMarker).gameObject.SetActive(isVisible);
			}
		}

		public static bool AddPin(ZDO zdo, bool save, PinType type = 8)
		{
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Invalid comparison between Unknown and I4
			//IL_0038: 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_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			if (ZNet.instance.IsDedicated())
			{
				throw new Exception("AddPin() should not be called on dedicated servers");
			}
			PinData val = zdo.FindPin();
			if (val != null)
			{
				Logging<Plugin>.Debug((object)$"Pin already exists: {val.GetGuid()} {val.m_name} {val.m_pos}", 0);
				return false;
			}
			string label = zdo.GetLabel();
			Vector3 position = zdo.GetPosition();
			Guid guid = TrackZDO(zdo);
			string text = CreateTrackingLabel(label, guid);
			Logging<Plugin>.Info((object)("Tracking Label: " + text), 0);
			if ((int)type == 8)
			{
				type = zdo.GetPinType();
			}
			PinDeath.AllowAdd = true;
			PinData val2 = Minimap.instance.AddPin(position, type, text, save, false, 0L, default(PlatformUserID));
			PinDeath.AllowAdd = false;
			if (val2 == null)
			{
				return false;
			}
			Logging<Plugin>.Info((object)$"Add pin type: {val2.m_type} {guid} {ZdoExt.GetPrefabName(zdo)} ({MathExt.XZY(position)}) ", 0);
			return true;
		}

		private static void SetLabel(this PinData pin, string label)
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Expected O, but got Unknown
			if (!Utility.IsNullOrWhiteSpace(label))
			{
				pin.m_name = CreateTrackingLabel(label, pin.GetGuid());
				if (pin.m_NamePinData == null)
				{
					pin.m_NamePinData = new PinNameData(pin);
				}
				if (Object.op_Implicit((Object)(object)pin.m_NamePinData.PinNameText))
				{
					pin.m_NamePinData.PinNameText.text = pin.GetLabel();
				}
			}
		}

		internal static string GetLabel(this ZDO zdo)
		{
			GameObject prefab = ZNetScene.instance.GetPrefab(zdo.GetPrefab());
			Sign val = default(Sign);
			string text = default(string);
			if (prefab.TryGetComponent<Sign>(ref val) && zdo.GetString(ZDOVars.s_text, ref text))
			{
				if (!(text != val.m_defaultText))
				{
					return string.Empty;
				}
				return text;
			}
			Tameable val2 = default(Tameable);
			if (prefab.TryGetComponent<Tameable>(ref val2))
			{
				string result = default(string);
				if (zdo.GetString(ZDOVars.s_tamedName, ref result))
				{
					return result;
				}
				Character val3 = default(Character);
				if (((Component)val2).TryGetComponent<Character>(ref val3))
				{
					return StringExt.Localize(val3.m_name);
				}
				return string.Empty;
			}
			MapTable val4 = default(MapTable);
			if (prefab.TryGetComponent<MapTable>(ref val4))
			{
				string text2 = default(string);
				if (zdo.GetString(ZDOVars.s_text, ref text2))
				{
					if (Utility.IsNullOrWhiteSpace(text2))
					{
						return StringExt.Localize("$map_region_default");
					}
					return text2;
				}
				return StringExt.Localize("$map_region_default");
			}
			TombStone val5 = default(TombStone);
			if (prefab.TryGetComponent<TombStone>(ref val5))
			{
				string @string = zdo.GetString(ZDOVars.s_ownerName, "");
				string text3 = StringExt.Localize(zdo.GetString(ZDOVars.s_text, ""));
				if (Utility.IsNullOrWhiteSpace(text3))
				{
					return @string;
				}
				return @string + "\n(" + text3 + ")";
			}
			TeleportWorld val6 = default(TeleportWorld);
			if (prefab.TryGetComponent<TeleportWorld>(ref val6))
			{
				string text4 = Portal.RequestPortalSymbols(zdo);
				if (text4 != null)
				{
					return text4;
				}
			}
			string text5 = string.Empty;
			Piece val7 = default(Piece);
			Hoverable val8 = default(Hoverable);
			if (prefab.TryGetComponent<Piece>(ref val7))
			{
				string string2 = zdo.GetString(ZDOVars.s_tamedName, "");
				text5 = (Utility.IsNullOrWhiteSpace(string2) ? val7.m_name : string2);
			}
			else if (prefab.TryGetComponent<Hoverable>(ref val8))
			{
				text5 = val8.GetHoverName();
			}
			return StringExt.Localize(text5);
		}

		static MapTrack()
		{
			Guid empty = Guid.Empty;
			DataSize = empty.ToString("N").Length;
			VisiblePins = new HashSet<PinData>();
		}
	}
	[HarmonyPatch]
	internal static class PinToMount
	{
		private static bool IsTrackedMount(this Tameable tameable)
		{
			return Configs.TrackedMounts.Value.Contains(tameable.m_nview.GetPrefabName(), true);
		}

		private static void StartTracking(this Tameable tameable)
		{
			if (!tameable.m_nview.IsValid())
			{
				Logging<Plugin>.Error((object)"m_nview is not valid", (ushort)0);
			}
			else
			{
				MapTrack.AddPin(tameable.m_nview.GetZDO(), save: true, (PinType)263);
			}
		}

		private static void StopTracking(this Tameable tameable)
		{
			if (tameable.m_nview.IsValid())
			{
				MapTrack.StopTracking(tameable.m_nview.GetZDO());
			}
			else
			{
				Logging<Plugin>.Error((object)"m_nview is not valid", (ushort)0);
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(Tameable), "UseItem")]
		private static void Tamable_UseItem(Tameable __instance, ItemData item, bool __result)
		{
			if (__instance.IsTrackedMount())
			{
				ItemDrop saddleItem = __instance.m_saddleItem;
				if (((saddleItem != null) ? ItemDataExt.GetPrefabName(saddleItem) : null) == ItemDataExt.GetPrefabName(item) && __result)
				{
					__instance.StartTracking();
				}
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(Tameable), "DropSaddle")]
		private static void Tamable_DropSaddle(Tameable __instance, bool __result)
		{
			if (__instance.IsTrackedMount() && __result)
			{
				__instance.StopTracking();
			}
		}
	}
	[HarmonyPatch]
	internal static class ShoutsAndPings
	{
		[HarmonyPrefix]
		[HarmonyPatch(typeof(Chat), "AddInworldText")]
		private static void AddInWorldText(Type type, Vector3 position, ref bool __runOriginal)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Invalid comparison between Unknown and I4
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Invalid comparison between Unknown and I4
			if ((int)Minimap.instance.m_mode != 2 && (int)type == 3)
			{
				__runOriginal = !Configs.HideMapPingInWorld.Value;
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(Chat), "UpdateWorldTextField")]
		private static void UpdateWorldTextField(WorldTextInstance wt)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Invalid comparison between Unknown and I4
			if ((int)wt.m_type == 3 && Configs.HideMapPingInWorld.Value)
			{
				((Component)wt.m_textMeshField).gameObject.SetActive(false);
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(Minimap), "UpdateShoutPins")]
		private static void UpdateShoutPins(Minimap __instance, ref bool __runOriginal)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Invalid comparison between Unknown and I4
			if (Configs.HideShoutPings.Value && !Map.IsGodMode && (int)__instance.m_mode == 2)
			{
				__runOriginal = false;
				CollectionExtensions.Do<PinData>((IEnumerable<PinData>)__instance.m_shoutPins, (Action<PinData>)__instance.RemovePin);
				__instance.m_shoutPins.Clear();
			}
		}
	}
	[BepInPlugin("ZenDragon.ZenMap", "ZenMap", "1.7.4")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[NetworkCompatibility(/*Could not decode attribute arguments.*/)]
	internal class Plugin : ZenMod<Plugin>
	{
		public const string PluginName = "ZenMap";

		public const string PluginVersion = "1.7.4";

		public const string PluginGUID = "ZenDragon.ZenMap";

		protected override void Setup()
		{
			((ZenMod)this).RunOnServer = true;
			base.RegisterCraftingItems += MapPin.AddCraftingItem;
			base.RegisterCraftingItems += MapParchment.AddCraftingItem;
			base.RegisterCraftingItems += MapItem.AddCraftingItem;
		}

		protected override void TitleScene(bool isFirstBoot)
		{
		}

		protected override void HotRestore()
		{
			if (Object.op_Implicit((Object)(object)Minimap.instance))
			{
				MapUI.Init();
				MapFog.InitFogCache();
				InventoryCheck.Init();
				Configs.UpdatePinOptions();
			}
		}

		protected override void WorldStart()
		{
			Configs.SetNoMap();
			MapTrack.Init();
			MapPinSelect.Init();
			((MonoBehaviour)this).InvokeRepeating("CheckNoMapMode", 1f, 1f);
		}

		private void Update()
		{
			MapPinSelect.CheckForInput();
		}

		protected override void Shutdown()
		{
			MapTrack.Shutdown();
			MapPinSelect.Shutdown();
			MapLocationPins.Shutdown();
			MapClouds.Shutdown();
			MapUI.Shutdown();
		}

		private void CheckNoMapMode()
		{
			if (Configs.GodModeMapEnabled.Value && Object.op_Implicit((Object)(object)Player.m_localPlayer))
			{
				Game.m_noMap = ZoneSystem.instance.GetGlobalKey("nomap");
				if (((Character)Player.m_localPlayer).InGodMode())
				{
					Game.m_noMap = false;
				}
			}
		}

		protected override HelpInfo? GetHelpInfo()
		{
			//IL_020b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0211: Expected O, but got Unknown
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.AppendLine(HelpInfo.Format("Description", "Use cartography tables to explore the area. They slowly reveal their surrounding area over time.\r\nIf you destroy the table then they have to recreate the explored area.\r\nView the map at the table. Craft map pins and attach them to signs to mark areas.\r\nPin visibility is shared at the table automatically.", (string)null, true, true));
			if (Configs.MapPinRefund.Value)
			{
				stringBuilder.AppendLine(HelpInfo.Format<bool>(Configs.MapPinRefund, false, true, true));
			}
			if (Configs.CalendarShow.Value && Configs.CalendarDaysPerYear.Value > 0)
			{
				stringBuilder.AppendLine(HelpInfo.Format<int>(Configs.CalendarDaysPerYear, true, true, true));
			}
			if (Configs.PinColorEnabled.Value)
			{
				stringBuilder.AppendLine(HelpInfo.Format<Color>(Configs.PinColorPrivate, true, true, true));
				stringBuilder.AppendLine(HelpInfo.Format<Color>(Configs.PinColorShared, true, true, true));
				stringBuilder.AppendLine(HelpInfo.Format<Color>(Configs.PinColorBoss, true, true, true));
				stringBuilder.AppendLine(HelpInfo.Format<Color>(Configs.PinColorDeath, true, true, true));
				stringBuilder.AppendLine(HelpInfo.Format<Color>(Configs.PinColorSpecial, true, true, true));
			}
			if (Configs.ShowBonfiresOnlyWhenLit.Value && Configs.IsPinOptionUsedInAnyRule(PinOption.Bonfire))
			{
				stringBuilder.AppendLine(HelpInfo.Format<bool>(Configs.ShowBonfiresOnlyWhenLit, false, true, true));
			}
			if (Configs.PinPvPBlind.Value)
			{
				stringBuilder.AppendLine(HelpInfo.Format<bool>(Configs.PinPvPBlind, false, true, true));
			}
			if (Configs.PinPvPStealth.Value)
			{
				stringBuilder.AppendLine(HelpInfo.Format<bool>(Configs.PinPvPStealth, false, true, true));
			}
			if (Configs.HideMapPingInWorld.Value)
			{
				stringBuilder.AppendLine(HelpInfo.Format<bool>(Configs.HideMapPingInWorld, false, true, true));
			}
			if (Configs.HideShoutPings.Value)
			{
				stringBuilder.AppendLine(HelpInfo.Format<bool>(Configs.HideShoutPings, false, true, true));
			}
			if (Configs.MapItemEnabled.Value)
			{
				stringBuilder.AppendLine(HelpInfo.Format<bool>(Configs.MapItemEnabled, false, true, true));
				if (Configs.MapItemRecraft.Value != 0)
				{
					stringBuilder.AppendLine(HelpInfo.Format<MapRecraftOption>(Configs.MapItemRecraft, true, true, false));
				}
			}
			stringBuilder.AppendLine(HelpInfo.Format<KeyCode>(Configs.InputPinShowLabelsKey, true, true, true));
			stringBuilder.AppendLine(HelpInfo.Format<KeyCode>(Configs.InputHideInfoKey, true, true, true));
			stringBuilder.AppendLine(HelpInfo.Format<KeyCode>(Configs.InputHideMapCloudsKey, true, true, true));
			return new HelpInfo("Maps", stringBuilder.ToString());
		}
	}
	[Flags]
	public enum PinOption
	{
		None = 0,
		Sign = 1,
		MapTable = 2,
		Tombstone = 4,
		Bonfire = 8,
		Cart = 0x10,
		LargeShip = 0x20,
		SmallBoat = 0x40,
		WarMachine = 0x80,
		Portal = 0x100,
		Player = 0x200,
		Mount = 0x400,
		Boss = 0x800,
		All = 0xFFF
	}
	internal enum MapRecraftOption
	{
		Disabled,
		OriginTable,
		AnyTable
	}
	internal static class Configs
	{
		public static readonly ConfigEntry<bool> RemoveLegacyData;

		public static readonly ConfigEntry<float> ZoomScale;

		public static readonly ConfigEntry<bool> DisableFogCache;

		public static readonly ConfigEntry<KeyCode> InputMapTableAdminAccelerateAgeKey;

		public static readonly ConfigEntry<KeyCode> InputHideMapCloudsKey;

		public static readonly ConfigEntry<KeyCode> InputHideInfoKey;

		public static readonly ConfigEntry<KeyCode> InputPinShowLabelsKey;

		public static readonly ConfigEntry<bool> GodModeMapEnabled;

		public static readonly ConfigEntry<bool> GodModeFullMap;

		public static readonly ConfigEntry<int> MapTableDaysUntilFull;

		public static readonly ConfigEntry<int> MapTableFullRadius;

		public static readonly ConfigEntry<bool> HideShipBanana;

		public static readonly ConfigEntry<bool> HidePlayerArrow;

		public static readonly ConfigEntry<bool> AutoSetNoMap;

		public static readonly ConfigEntry<bool> HideMapPingInWorld;

		public static readonly ConfigEntry<bool> HideShoutPings;

		public static readonly ConfigEntry<bool> CalendarShow;

		public static readonly ConfigEntry<int> CalendarDaysPerYear;

		public static readonly ConfigEntry<int> CalendarInitDays;

		public static readonly ConfigEntry<bool> HideMapTableClouds;

		public static readonly ConfigEntry<bool> HideMapItemClouds;

		public static readonly ConfigEntry<StringList> TrackedMounts;

		public static readonly ConfigEntry<PinOption> PinShowMapTable;

		public static readonly ConfigEntry<PinOption> PinShowMapItem;

		public static readonly ConfigEntry<PinOption> PinShowCompassNoMap;

		public static readonly ConfigEntry<PinOption> PinShowCompassWithMap;

		public static readonly ConfigEntry<PinBoss.RevealMode> PinBossReveal;

		public static readonly ConfigEntry<bool> PinPvPStealth;

		public static readonly ConfigEntry<bool> PinPvPBlind;

		public static readonly ConfigEntry<bool> ShowBonfiresOnlyWhenLit;

		public static readonly ConfigEntry<bool> PinColorEnabled;

		public static readonly ConfigEntry<Color> PinColorPrivate;

		public static readonly ConfigEntry<Color> PinColorShared;

		public static readonly ConfigEntry<Color> PinColorBoss;

		public static readonly ConfigEntry<Color> PinColorDeath;

		public static readonly ConfigEntry<Color> PinColorSpecial;

		public static readonly ConfigEntry<string> MapPinCraftingStation;

		public static readonly ConfigEntry<int> MapPinCraftingStationLevel;

		public static readonly ConfigEntry<StringList> MapPinItemResources;

		public static readonly ConfigEntry<int> MapPinStackSize;

		public static readonly ConfigEntry<bool> MapPinRefund;

		public static readonly ConfigEntry<bool> MapItemEnabled;

		public static readonly ConfigEntry<MapRecraftOption> MapItemRecraft;

		public static readonly ConfigEntry<int> MapItemRecraftMaxRange;

		public static readonly ConfigEntry<string> ParchmentCraftingStation;

		public static readonly ConfigEntry<int> ParchmentCraftingStationLevel;

		public static readonly ConfigEntry<StringList> ParchmentResources;

		private static readonly Dictionary<int, PinOption> DefaultPinToOption;

		static Configs()
		{
			//IL_031a: Unknown result type (might be due to invalid IL or missing references)
			//IL_031f: Unknown result type (might be due to invalid IL or missing references)
			//IL_032a: Expected O, but got Unknown
			//IL_032a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0335: Expected O, but got Unknown
			//IL_033f: Expected O, but got Unknown
			//IL_04d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_050c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0511: Unknown result type (might be due to invalid IL or missing references)
			//IL_0535: Unknown result type (might be due to invalid IL or missing references)
			//IL_0559: Unknown result type (might be due to invalid IL or missing references)
			//IL_0578: Unknown result type (might be due to invalid IL or missing references)
			//IL_066a: Unknown result type (might be due to invalid IL or missing references)
			//IL_066f: Unknown result type (might be due to invalid IL or missing references)
			//IL_067a: Expected O, but got Unknown
			//IL_067a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0685: Expected O, but got Unknown
			//IL_0685: Unknown result type (might be due to invalid IL or missing references)
			//IL_0690: Expected O, but got Unknown
			//IL_0690: Unknown result type (might be due to invalid IL or missing references)
			//IL_069b: Expected O, but got Unknown
			//IL_06a5: Expected O, but got Unknown
			//IL_06fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0700: Unknown result type (might be due to invalid IL or missing references)
			//IL_070b: Expected O, but got Unknown
			//IL_0715: Expected O, but got Unknown
			DefaultPinToOption = new Dictionary<int, PinOption>(MapTrack.PinToOption);
			RemoveLegacyData = Config.Define<bool>(true, "_Debug", "Remove Legacy Data", false, "Clean legacy data from ZDOs from prior versions of this mod.\r\nThis will be checked once on server startup, or in single player when the world loads.\r\nNo need to run this unless you see a message on startup that legacy data is present.\r\nYou should not leave this option enabled after use. Turn it off when not being used.\r\n[restart required for changes to take effect]");
			DisableFogCache = Config.Define<bool>(true, "_Debug", "Disable Fog Cache", false, "Disable the fog texture cache.\r\nIf this is disabled there will be a noticable freeze when you open the map.");
			DisableFogCache.SettingChanged += delegate
			{
				if (DisableFogCache.Value)
				{
					MapFog.RemoveFogCache();
				}
				else
				{
					MapFog.InitFogCache();
				}
			};
			ZoomScale = Config.Define<float>(true, "Compatibility", "Zoom Scale", 1f, Config.AcceptRange<float>(0.1f, 10f), "Zoom scaling\r\nWARNING: Do not change this value if you did not alter world size.\r\nChange this if you alter the minimap size and/or pixel size via the ExpandWorld mod.\r\nThe fully explored map window rectangle should fit entirely within the \r\nbounds of a fully mature Cartography Table's explored area circle.\r\nNo fog should be visible around the edges of a fully explored map.\r\nUsually this value is multiples of 2x, example: 1.0, 2.0, 0.5, etc...\r\n[close/open map to see changes]");
			InputMapTableAdminAccelerateAgeKey = Config.Define<KeyCode>(true, "Input", "Admin Accelerate Age Key", (KeyCode)308, "Admin can hold this key while interacting with the table to accelerate its age. (God mode must be active)");
			InputHideInfoKey = Config.Define<KeyCode>(false, "Input", "Hide Info Key", (KeyCode)308, "Hold down this key to hide all info on the map.\r\nGamepad is LS/L3.");
			InputHideMapCloudsKey = Config.Define<KeyCode>(false, "Input", "Hide Clouds Key", (KeyCode)307, "Hold down this key to hide clouds on the map.\r\nGamepad is RS/R3.");
			InputPinShowLabelsKey = Config.Define<KeyCode>(false, "Input", "Display Labels Key", (KeyCode)304, "Hold down this key to display the pin labels on the map.\r\nGamepad is button Y.");
			AutoSetNoMap = Config.Define<bool>(true, "General", "Autoset World Modifier NoMap", true, "Automatically set the world modifier nomap on startup.\r\nIf nomap is enabled then the only way to view the map is via the Cartography Table (or admin god mode)");
			HidePlayerArrow = Config.Define<bool>(true, "General", "Hide Player Arrow", true, "Hide the player's arrow icon when looking at the Map Table.\r\nInstead, use the landscape and compass to get your bearings.\r\n[close/open map to see changes]");
			GodModeMapEnabled = Config.Define<bool>(true, "General", "God Mode - Allow Map", true, "The map button is available for admin when they are in god mode");
			GodModeFullMap = Config.Define<bool>(true, "General", "God Mode - Full Map", true, "When in god mode the entire map will be revealed when pressing the map button.\r\nWhen using a Map Table or portable map the full map will not be revealed.\r\nThe global key \"nomap\" must be set for this config to function.");
			MapTableDaysUntilFull = Config.Define<int>(true, "General", "Days Until Full Map", 7, Config.AcceptRange<int>(0, 100), "How long must pass for a Map Table to be fully explored. (game days)");
			MapTableFullRadius = Config.Define<int>(true, "General", "Map Table Fully Explored Radius", 1250, Config.AcceptRange<int>(400, 10000), "How large of an area does the fully explored map reveal");
			HideShipBanana = Config.Define<bool>(true, "General", "Hide Ship Marker", true, "Hide the ship marker (yellow banana) when the player is controlling a ship.");
			HideMapPingInWorld = Config.Define<bool>(true, "General", "Map Ping - Hide In World", true, "You can ping the map table with middle-click.\r\nAny players viewing the map table can see the ping.\r\nThe ping can only be seen on the map table.  Not on the map item, or compass, or in world as floating text.\r\nTalk to each other and plan ahead. [This prevents guiding players via in world ping spam]");
			HideShoutPings = Config.Define<bool>(true, "General", "Map Ping - Hide Shout Pings", true, "Shouts do not show on the map.\r\nHowever, shouts can still be seen in world or on the compass if you are in range.\r\n[God mode can always see all shout pings]");
			CalendarShow = Config.Define<bool>(true, "General", "Calendar Show", true, "When true displays the era year on the map and on the portable Map Item description.\r\nThis is helpful because portable maps are frozen in time and it's useful to know when it was created.");
			CalendarInitDays = Config.Define<int>(true, "General", "Calendar Init Days", 0, "Initial number of days added to the era display, adjustable for customization of the era.\r\nCan be a negative or positive number.  Years = days x days per year");
			CalendarDaysPerYear = Config.Define<int>(true, "General", "Calendar Days Per Year", 0, Config.AcceptRange<int>(0, 1000), "Number of days in a year. \r\n[Set to a value greater than 0 to display times on the map as \"years\"\r\nIf set to 0 then the times on the map are displayed as days.\r\nNOTE: Seasons mod, by default has 40 days per year, 10 days per season.\r\nIf you want to show the passage of years with that mod set this to 40]");
			HideMapTableClouds = Config.Define<bool>(true, "General", "Hide Clouds - Table", false, "Hide the clouds on the Map Table.  (Vanilla: false)\r\nThey move in direction of the wind which can be useful for figuring out your direction.\r\nHowever, for a more difficult experience you can disable them.\r\nThe player can hide them by pressing " + ((ConfigEntryBase)InputHideMapCloudsKey).Definition.Key + ".");
			HideMapTableClouds.SettingChanged += delegate
			{
				MapClouds.ResetState();
			};
			HideMapItemClouds = Config.Define<bool>(true, "General", "Hide Clouds - Item", true, "Hide the clouds on the Map Item.  (Vanilla: false)\r\nThey move in direction of the wind which can be useful for figuring out your direction.\r\nHowever, for a more difficult experience you can disable them.\r\nThe player can hide them by pressing " + ((ConfigEntryBase)InputHideMapCloudsKey).Definition.Key + ".");
			HideMapItemClouds.SettingChanged += delegate
			{
				MapClouds.ResetState();
			};
			StringList val = new StringList();
			((List<string>)val).Add("Lox");
			((List<string>)val).Add("Asksvin");
			TrackedMounts = Config.Define<StringList>(true, "General", "Tracked Mounts", val, "List of prefab names of mounts which can have a saddle attached.");
			TrackedMounts.SettingChanged += delegate
			{
				UpdatePinOptions();
			};
			PinPvPStealth = Config.Define<bool>(true, "Pin Rules", "PvP - Stealth", true, "Other players can not see your pin when you are in PvP mode.");
			PinPvPBlind = Config.Define<bool>(true, "Pin Rules", "PvP - Blind", true, "You can not see other player pins when you are in PvP mode.");
			PinBossReveal = Config.Define<PinBoss.RevealMode>(true, "Pin Rules", "Boss Reveal", PinBoss.RevealMode.NearOnly, "Set the condition to display the boss pins. (Vanilla: Anywhere)\r\nNever: Never show the boss pins on the map.\r\nAnywhere: Add the boss pin to the map when you touch any Vegvisir anywhere in the world.\r\nNearOnly: Only add the boss pin to the map when you touch a Vegvisir close to the boss altar.");
			ShowBonfiresOnlyWhenLit = Config.Define<bool>(true, "Pin Rules", "Show Bonfires Only When Lit", true, "Bonfire pins only show if they are lit. Bonfire pins are shared and can be seen by anyone.\r\n[when disabled bonfire pins can not be seen if not lit]");
			PinShowMapTable = Config.Define<PinOption>(true, "Pin Rules", "Show - Table", PinOption.All, "Displayed on the Cartography Table for all players who look at the table, except Sign pins.\r\nSign: PRIVATE pins visible only to the player who placed the Sign pin, nobody else can see these.\r\nMapTable: marked as towns so players know where to go for map info.\r\nBonfire: large bright sources of light that can be seen by everyone at great distances.\r\nTombstone: pin markers are global, everyone can see the tombstone pins for all players.\r\nCart: tracked so they don't get lost easily\r\nWarMachine: BatteringRam and Catapult, tracked.\r\nSmallBoat: coastal craft, Raft and Karve, tracked.\r\nLargeShip: deep sea adventures, Longship and Drakkar, tracked.\r\nPlayer: Other players are visible unless PvP is enabled. \r\nAdmin god mode can always see all players.\r\nAdmin god mode can always see all pins.");
			PinShowMapTable.SettingChanged += delegate
			{
				UpdatePinOptions();
			};
			PinShowMapItem = Config.Define<PinOption>(true, "Pin Rules", "Show - Map Item", PinOption.Sign | PinOption.MapTable | PinOption.Tombstone | PinOption.Bonfire | PinOption.Portal | PinOption.Boss, "Map Item is a SNAPSHOT of the current explored area and pins on the map, INCLUDING private Sign pins and Mounts.\r\nNew pins added after the Map Item is crafted will not be visible. Craft a new map at the table.\r\nSign pins are copied from the table to the crafted map and are visible to anyone who looks at that Map Item.\r\nThe pins on the snapshot live update. If the object is destroyed or moved the pin will be updated as well.\r\nConsider immersion before enabling pins for objects that move, they will live update on the crafted map.\r\nIf you have a cart and pins are configured to show carts then you can easily figure out where you are.\r\nThe default configuration preserves immersion by restricting pins to non-movable objects.\r\nAdmin god mode can always see all players.\r\nAdmin god mode can always see all pins.\r\n[enabling pin options requires recrafting existing maps to add the newly enabled pins]");
			PinShowMapItem.SettingChanged += delegate
			{
				UpdatePinOptions();
			};
			PinShowCompassNoMap = Config.Define<PinOption>(true, "Pin Rules", "Show - Compass", PinOption.MapTable | PinOption.Bonfire | PinOption.Player | PinOption.Mount | PinOption.Boss, "Pins shown on the compass when the player does not have a Map Item in their inventory.\r\nBy default this shows less pins than when you have a Map Item with you.\r\nEncourages carrying a map and compass together to gain more information about your surroundings.\r\nBy default the compass does not show the tombstone. Only aproximate location via the map.\r\nAdmin god mode can always see all players.\r\nAdmin god mode can always see all pins.\r\n[requires ZenCompass to be installed]");
			PinShowCompassNoMap.SettingChanged += delegate
			{
				UpdatePinOptions();
			};
			PinShowCompassWithMap = Config.Define<PinOption>(true, "Pin Rules", "Show - Compass w/ Map", PinOption.Sign | PinOption.MapTable | PinOption.Bonfire | PinOption.Cart | PinOption.LargeShip | PinOption.SmallBoat | PinOption.WarMachine | PinOption.Portal | PinOption.Player | PinOption.Mount | PinOption.Boss, "Pins shown on the compass when the player has a Map Item in their inventory.\r\nBy default this should reveal more pins on their compass than without a map in the inventory.\r\nEncourages the player to carry a Map Item. Sacrifice an inventory slot for increased compass info.\r\nBy default the compass does not show the tombstone. Only aproximate location via the map.\r\nAdmin god mode can always see all players.\r\nAdmin god mode can always see all pins.\r\n[requires ZenCompass to be installed]");
			PinShowCompassWithMap.SettingChanged += delegate
			{
				UpdatePinOptions();
			};
			PinColorEnabled = Config.Define<bool>(false, "Pin Color", "Color - Enabled", true, "Show the pins color coded by visibility and intent. (Vanilla: false)");
			PinColorPrivate = Config.Define<Color>(false, "Pin Color", "Color Private", UIColor.LightYellow.Color, "Private pins, only visible to you.\r\nCopied to Map Items when crafted.");
			PinColorShared = Config.Define<Color>(false, "Pin Color", "Color Shared", Color32.op_Implicit(new Color32((byte)188, (byte)188, (byte)221, byte.MaxValue)), "Public auto-tracked pins, visible to everyone on the table. \r\nCopied to Map Items when crafted.");
			PinColorBoss = Config.Define<Color>(false, "Pin Color", "Color Boss", UIColor.ValheimOrange.Color, "Boss alters, always private. Visible only to you on any map.");
			PinColorDeath = Config.Define<Color>(false, "Pin Color", "Color Death", UIColor.ValheimYellow.Color, "Tombstones, shared on Cartography Tables. \r\nCopied to Map Items when crafted.");
			PinColorSpecial = Config.Define<Color>(false, "Pin Color", "Color Special", Color.white, "Special areas of interest: start temple, traders, etc. \r\nAlways visible on all maps for all players once discovered.");
			MapItemEnabled = Config.Define<bool>(true, "Crafting", "Map Item - Enabled", true, "Apply parchment to a Cartography Table and copy a snapshot of the table to a map item.\r\nThe map item can be opened from anywhere in the world but it will reflect the information copied to it when it was created.\r\nYou can store it in chests or trade it with other players.\r\nIt can be named when created or renamed after creation.\r\n[When false, Map Items can not be created from the Map Table. However, any existing map items can still be used.\r\nThis means amin can create them and put them into the world if desired but prevent players from creating them.]\r\n[reboot required for changes to take effect]");
			MapItemRecraft = Config.Define<MapRecraftOption>(true, "Crafting", "Map Item - Recraft", MapRecraftOption.OriginTable, "The player can recraft a Map Item by using it on the Cartography Table.\r\n- Disabled: Can not recraft existing Map Items, must create new ones.\r\n- OriginTable: Update existing Map Items from the original table only.\r\n- AnyTable: Update existing Map Items from any table.\r\n[" + ((ConfigEntryBase)MapItemEnabled).Definition.Key + " must be true for this to work]");
			MapItemRecraftMaxRange = Config.Define<int>(true, "Crafting", "Map Item - Recraft Range", 25, Config.AcceptRange<int>(1, 100), $"Max distance that recrafting the same Map Item will work from the origin it was created at.\r\nYou can not recraft the Map Item at a different table beyond this range.\r\n{((ConfigEntryBase)MapItemRecraft).Definition.Key} must be {MapRecraftOption.OriginTable} for this to work.");
			ParchmentCraftingStation = Config.Define<string>(true, "Crafting", "Parchment Crafting Station", "ArtisanTable", CraftingStations.GetAcceptableValueList(), "Crafting station required for creating a parchment.");
			ParchmentCraftingStationLevel = Config.Define<int>(true, "Crafting", "Parchment Crafting Station Level", 1, Config.AcceptRange<int>(1, 5), "Minimum level required for the crafting station to craft parchment");
			StringList val2 = new StringList();
			((List<string>)val2).Add("Resin:4");
			((List<string>)val2).Add("Guck:3");
			((List<string>)val2).Add("MeadPoisonResist:2");
			((List<string>)val2).Add("LoxPelt:1");
			ParchmentResources = Config.Define<StringList>(true, "Crafting", "Parchment Resources", val2, "Resource requirements for crafting a parchment.");
			MapPinCraftingStation = Config.Define<string>(true, "Crafting", "Map Pin Crafting Station", "None", CraftingStations.GetAcceptableValueList(), "Crafting station required for creating the map pin item.");
			MapPinCraftingStationLevel = Config.Define<int>(true, "Crafting", "Map Pin Crafting Station Level", 1, Config.AcceptRange<int>(1, 5), "Minimum level required for the crafting station to craft map pins");
			StringList val3 = new StringList();
			((List<string>)val3).Add("BronzeNails:1");
			MapPinItemResources = Config.Define<StringList>(true, "Crafting", "Map Pin Resources", val3, "Resource requirements for crafting Map Pins.\r\nBronze nails is the default because it gives a period of early game progression\r\nwithout pins for added challenge and reward.");
			MapPinStackSize = Config.Define<int>(true, "Crafting", "Map Pin Stack Size", 100, Config.AcceptRange<int>(1, 100), "Max stack size. How many pins can be stored in a single inventory slot.\r\n[restart required for changes to take effect]");
			MapPinRefund = Config.Define<bool>(true, "Crafting", "Map Pin Refund", true, "Map pins are refunded when manually removed from the sign.\r\nAssign another pin to the same sign to remove the old pin, or apply the Hammer.");
		}

		internal static void UpdatePinOptions()
		{
			MapTrack.PinToOption.Clear();
			DictionaryExt.Copy<int, PinOption>(MapTrack.PinToOption, DefaultPinToOption);
			MapTrack.Pin.Mounts.Clear();
			foreach (int item in ((IEnumerable<string>)TrackedMounts.Value).Select((string name) => StringExtensionMethods.GetStableHashCode(name)))
			{
				MapTrack.Pin.Mounts.Add(item);
				MapTrack.PinToOption[item] = PinOption.Mount;
			}
			SetVisiblePinOptions(MapPinType.VisibleTypes.MapTable, PinShowMapTable.Value);
			SetVisiblePinOptions(MapPinType.VisibleTypes.MapItem, PinShowMapItem.Value);
			SetVisiblePinOptions(MapPinType.VisibleTypes.CompassNoMap, PinShowCompassNoMap.Value);
			SetVisiblePinOptions(MapPinType.VisibleTypes.CompassWithMap, PinShowCompassWithMap.Value);
			if (Object.op_Implicit((Object)(object)Minimap.instance))
			{
				Minimap.instance.m_pinUpdateRequired = true;
			}
		}

		public static bool HasOption(this PinOption value, PinOption flag)
		{
			if (flag != 0)
			{
				return (value & flag) == flag;
			}
			return false;
		}

		public static bool IsPinOptionUsedInAnyRule(PinOption option)
		{
			if (!PinShowCompassNoMap.Value.HasOption(option) && !PinShowCompassWithMap.Value.HasOption(option) && !PinShowMapItem.Value.HasOption(option))
			{
				return PinShowMapTable.Value.HasOption(option);
			}
			return true;
		}

		private static void SetVisiblePinOptions(bool[] visiblePinTypes, PinOption configValue)
		{
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: 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_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			MapPinType.VisibleTypes.Everything.CopyTo(visiblePinTypes, 0);
			visiblePinTypes[9] = configValue.HasOption(PinOption.Boss);
			foreach (var item3 in IEnumerableExt.AsTuple<int, PinOption>(MapTrack.PinToOption))
			{
				int item = item3.Item1;
				PinOption item2 = item3.Item2;
				bool flag = configValue.HasOption(item2);
				if (item == MapTrack.Pin.Sign)
				{
					foreach (PinType item4 in MapPinIcon.PinTypeToResource.Keys.Where(MapPinType.IsSignPin))
					{
						visiblePinTypes[item4] = flag;
					}
				}
				else if (MapTrack.Pin.Mounts.Contains(item))
				{
					visiblePinTypes[263] = flag;
				}
				else
				{
					PinType val = MapPinIcon.NamedPinTypes[item];
					visiblePinTypes[val] = flag;
				}
			}
		}

		public static bool IsAllowed(this ConfigEntry<PinOption> config, int prefabHash)
		{
			PinOption pinOption = MapTrack.GetPinOption(prefabHash);
			if (pinOption != 0)
			{
				return (config.Value & pinOption) == pinOption;
			}
			return false;
		}

		internal static void SetNoMap()
		{
			if (ZNet.instance.IsServer() && AutoSetNoMap.Value)
			{
				ZoneSystem.instance.SetGlobalKey((GlobalKeys)26);
				Logging<Plugin>.Message((object)"World modifier enabled: NoMap", 0);
			}
		}
	}
	[HarmonyPatch]
	internal static class Map
	{
		public static class Zoom
		{
			private const float MaxLimit = 0.385f;

			private const float MinLimit = 0.05f;

			private static float WorldScale => Minimap.instance.m_maxZoom * Minimap.instance.m_maxZoom * 10000f;

			private static float Scaling => (float)Configs.MapTableFullRadius.Value / WorldScale * Configs.ZoomScale.Value;

			public static float Max => 0.385f * Scaling;

			public static float Min => 0.05f * Scaling;
		}

		[HarmonyPatch]
		private static class MinimapPinRemove
		{
			[UsedImplicitly]
			private static IEnumerable<MethodInfo> TargetMethods()
			{
				return new <>z__ReadOnlyArray<MethodInfo>(new MethodInfo[2]
				{
					AccessTools.DeclaredMethod(typeof(Minimap), "OnMapRightClick", (Type[])null, (Type[])null),
					AccessTools.DeclaredMethod(typeof(Minimap), "UpdateMap", (Type[])null, (Type[])null)
				});
			}

			[UsedImplicitly]
			private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> codes)
			{
				MethodInfo methodInfo = AccessTools.DeclaredMethod(typeof(Minimap), "RemovePin", new Type[2]
				{
					typeof(Vector3),
					typeof(float)
				}, (Type[])null);
				Func<Minimap, Vector3, float, bool> func = RemovePin_Intercept;
				return Transpilers.MethodReplacer(codes, (MethodBase)methodInfo, (MethodBase)func.Method);
			}

			private static bool RemovePin_Intercept(Minimap self, Vector3 pos, float radius)
			{
				//IL_001f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0059: Unknown result type (might be due to invalid IL or missing references)
				//IL_0065: Unknown result type (might be due to invalid IL or missing references)
				//IL_0070: Expected O, but got Unknown
				//IL_0070: Expected O, but got Unknown
				//IL_006b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0075: Expected O, but got Unknown
				Minimap self2 = self;
				Logging<Plugin>.Info((object)"Right click, remove pin", 0);
				PinData pin = self2.GetClosestPin(pos, radius, true);
				if (pin == null)
				{
					return false;
				}
				string text = pin.GetLabel() + "\n\n$msg_confirm";
				UnifiedPopup.Push((PopupBase)new YesNoPopup("$hud_removepin", text, new PopupButtonCallback(Yes), new PopupButtonCallback(No), true));
				return false;
				static void No()
				{
					UnifiedPopup.Pop();
				}
				void Yes()
				{
					self2.inputDelay = 0.5f;
					self2.RemovePin(pin);
					UnifiedPopup.Pop();
				}
			}
		}

		public static bool IsNoMapKey => ZoneSystem.instance.GetGlobalKey((GlobalKeys)26);

		public static bool IsGodMode
		{
			get
			{
				if (Object.op_Implicit((Object)(object)Player.m_localPlayer))
				{
					return ((Character)Player.m_localPlayer).InGodMode();
				}
				return false;
			}
		}

		private static float AccessibilityGuiScale => 1f / PlayerPrefs.GetFloat("GuiScale", 1f);

		public static bool IsLabelTogglePressed
		{
			get
			{
				//IL_0005: Unknown result type (might be due to invalid IL or missing references)
				if (!ZInput.GetKey(Configs.InputPinShowLabelsKey.Value, true))
				{
					return ZInput.GetButton("JoyButtonY");
				}
				return true;
			}
		}

		public static bool IsInfoTogglePressed
		{
			get
			{
				//IL_0005: Unknown result type (might be due to invalid IL or missing references)
				if (!ZInput.GetKey(Configs.InputHideInfoKey.Value, true))
				{
					return ZInput.GetButton("JoyLStick");
				}
				return true;
			}
		}

		private static double TimeElapsedSeconds(this MapTable table)
		{
			if (table.m_nview.IsValid())
			{
				return ZdoExt.GetAgeSeconds(table.m_nview.GetZDO());
			}
			Logging<Plugin>.Warning((object)"MapTable ZNetView invalid", 0);
			return 0.0;
		}

		private static void SetLabel(this MapTable table, string name)
		{
			table.m_nview.ClaimOwnership();
			table.m_nview.GetZDO().Set(ZDOVars.s_text, name);
		}

		private static string GetLabel(this MapTable table)
		{
			if (!table.m_nview.IsValid())
			{
				return string.Empty;
			}
			return table.m_nview.GetZDO().GetString(ZDOVars.s_text, "");
		}

		private static MapLocation GetLocation(this MapTable table)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			return new MapLocation(table.GetLabel(), ((Component)table).transform.position, table.ExploredRadius());
		}

		private static float ExploredRadius(this MapTable table)
		{
			float num = Mathf.Clamp((float)(table.TimeElapsedSeconds() / (double)EnvMan.instance.m_dayLengthSec) / (float)Configs.MapTableDaysUntilFull.Value, 0.05f, 1f);
			return (float)Configs.MapTableFullRadius.Value * num;
		}

		private static int GetDaysRemaining(this MapTable table)
		{
			MapLocation location = table.GetLocation();
			return Configs.MapTableDaysUntilFull.Value - Mathf.FloorToInt((float)Configs.MapTableDaysUntilFull.Value * location.Percent);
		}

		private static void AccelerateAge(this MapTable table, float seconds)
		{
			table.m_nview.ClaimOwnership();
			ZdoExt.AccelerateAge(table.m_nview.GetZDO(), (double)seconds);
		}

		private static void ApplyWriteFX(this MapTable table)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			Transform transform = ((Component)table).transform;
			table.m_writeEffects.Create(transform.position, transform.rotation, (Transform)null, 1f, -1);
		}

		[HarmonyTranspiler]
		[HarmonyPatch(typeof(Minimap), "UpdatePlayerPins")]
		private static IEnumerable<CodeInstruction> Minimap_UpdatePlayerPins(IEnumerable<CodeInstruction> codes)
		{
			MethodInfo methodInfo = AccessTools.DeclaredMethod(typeof(ZNet), "GetOtherPublicPlayers", (Type[])null, (Type[])null);
			Action<ZNet, List<PlayerInfo>> action = GetOtherPublicPlayers;
			return Transpilers.MethodReplacer(codes, (MethodBase)methodInfo, (MethodBase)action.Method);
			static PinOption ConfigForMapMode()
			{
				if (MapLocation.IsMapItem())
				{
					return Configs.PinShowMapItem.Value;
				}
				if (MapLocation.IsMapTable())
				{
					return Configs.PinShowMapTable.Value;
				}
				PinOption value = Configs.PinShowCompassWithMap.Value;
				PinOption value2 = Configs.PinShowCompassNoMap.Value;
				if (!InventoryCheck.HaveMap)
				{
					return value2;
				}
				return value;
			}
			static void GetOtherPublicPlayers(ZNet instance, List<PlayerInfo> infos)
			{
				ZNet instance2 = instance;
				infos.AddRange(instance2.m_players.Where(IsVisible));
				bool IsVisible(PlayerInfo info)
				{
					//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_0006: 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_0015: 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_003a: 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)
					if (info.m_characterID == ZDOID.None)
					{
						return false;
					}
					if (info.m_characterID == instance2.m_characterID)
					{
						return false;
					}
					if (!Object.op_Implicit((Object)(object)Player.m_localPlayer))
					{
						return info.m_publicPosition;
					}
					if (((Character)Player.m_localPlayer).InGodMode())
					{
						return true;
					}
					if (((Character)Player.m_localPlayer).IsPVPEnabled() && Configs.PinPvPBlind.Value)
					{
						return false;
					}
					if (info.m_publicPosition)
					{
						return ConfigForMapMode().HasFlag(PinOption.Player);
					}
					return false;
				}
			}
		}

		[HarmonyTranspiler]
		[HarmonyPatch(typeof(Minimap), "UpdatePins")]
		private static IEnumerable<CodeInstruction> Minimap_UpdatePins(IEnumerable<CodeInstruction> codes)
		{
			MethodInfo methodInfo = AccessTools.Method(typeof(RectTransform), "SetSizeWithCurrentAnchors", (Type[])null, (Type[])null);
			Action<RectTransform, Axis, float> action = SetSizeWithCurrentAnchors;
			return Transpilers.MethodReplacer(codes, (MethodBase)methodInfo, (MethodBase)action.Method);
			static void SetSizeWithCurrentAnchors(RectTransform rt, Axis axis, float size)
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				rt.SetSizeWithCurrentAnchors(axis, size * AccessibilityGuiScale);
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(Minimap), "UpdateMap")]
		private static void Minimap_UpdateMap(Minimap __instance, ref bool __runOriginal, float dt)
		{
			//IL_00cf: 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)
			((Component)__instance.m_pinRootLarge).gameObject.SetActive(!IsInfoTogglePressed);
			((Component)__instance.m_biomeNameLarge).gameObject.SetActive(!IsInfoTogglePressed);
			if (!MapLocation.InUse)
			{
				return;
			}
			__runOriginal = false;
			float num = __instance.m_largeZoom * 2f;
			float num2 = Mathf.Clamp(ZInput.GetMouseScrollWheel(), -0.05f, 0.05f) * num;
			if (ZInput.IsGamepadActive())
			{
				if (ZInput.GetButton("JoyLTrigger"))
				{
					num2 = (0f - num) * dt;
				}
				if (ZInput.GetButton("JoyRTrigger"))
				{
					num2 = num * dt;
				}
			}
			__instance.m_largeZoom = Mathf.Clamp(__instance.m_largeZoom - num2, Zoom.Min, Zoom.Max);
			((Component)__instance.m_gamepadCrosshair).gameObject.SetActive(false);
			__instance.m_hints[0].SetActive(false);
			__instance.UpdatePlayerMarker(Player.m_localPlayer, Quaternion.identity);
			__instance.CenterMap(MapLocation.Active.Position);
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(PlayerController), "TakeInput")]
		private static void BlockMovementIfMapOpen(ref bool __runOriginal, ref bool __result)
		{
			if (Minimap.IsOpen() || MapPinSelect.IsOpen)
			{
				__result = false;
				__runOriginal = false;
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(Minimap), "Start")]
		private static void Minimap_Start(Minimap __instance)
		{
			//IL_0026: 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_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			__instance.m_biomeNameLarge.alignment = (TextAlignmentOptions)260;
			__instance.m_showNamesZoom = 0f;
			RectTransform val = (RectTransform)__instance.m_biomeNameLarge.transform;
			Vector2 anchorMin = val.anchorMin;
			anchorMin.x = 0f;
			val.anchorMin = anchorMin;
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(Minimap), "ShowPinNameInput")]
		private static void Minimap_ShowPinNameInput(ref bool __runOriginal)
		{
			__runOriginal = !MapLocation.InUse;
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(Minimap), "IsPointVisible")]
		private static void Minimap_IsPointVisible(Minimap __instance, Vector3 p, ref bool __result)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			__result = __result && __instance.IsExplored(p);
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(Minimap), "UpdateExplore")]
		private static void Minimap_UpdateExplore(Minimap __instance, ref bool __runOriginal)
		{
			__runOriginal = !IsNoMapKey || !MapLocation.InUse;
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(Minimap), "SetMapMode")]
		private static void Minimap_SetMapMode(Minimap __instance, MapMode mode)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Invalid comparison between Unknown and I4
			if ((int)mode != 2)
			{
				MapLocation.Close();
				return;
			}
			SetAspectRatio();
			Timing.NextFrame((MonoBehaviour)(object)__instance, (Action)delegate
			{
				if (InventoryGui.IsVisible())
				{
					InventoryGui.instance.Hide();
				}
			});
			if (!MapLocation.InUse && IsGodMode)
			{
				((Character)Player.m_localPlayer).Message((MessageType)2, "God mode: Unrestricted map", 0, (Sprite)null);
				if (Configs.GodModeFullMap.Value && IsNoMapKey)
				{
					Minimap.instance.ExploreAll();
				}
			}
			MapUI.Show((IsNoMapKey && !MapLocation.InUse && IsGodMode) || (!IsNoMapKey && IsGodMode));
		}

		private static void SetAspectRatio()
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			float num = 1920f * AccessibilityGuiScale - 300f;
			float num2 = (float)Screen.width / UI.ScaleFactor - num;
			RectTransform val = (RectTransform)Minimap.instance.m_largeRoot.transform;
			Vector2 sizeDelta = val.sizeDelta;
			sizeDelta.x = 0f - num2;
			val.sizeDelta = sizeDelta;
		}

		private static bool CheckForInput()
		{
			if (!PlayerExt.IsReady(Player.m_localPlayer) || IsGodMode)
			{
				return false;
			}
			if (!IsNoMapKey)
			{
				return false;
			}
			if (UI.IsOpen)
			{
				return false;
			}
			if (MapLocation.InUse)
			{
				return false;
			}
			if ((!ZInput.GetButtonDown("Map") && !ZInput.GetButtonDown("JoyMap")) || ZInput.GetButton(ControlInputs.JoyAlt))
			{
				return false;
			}
			MapItem.ShowLastUsed();
			return true;
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(Minimap), "Update")]
		private static void Minimap_Update(ref bool __runOriginal)
		{
			__runOriginal = !CheckForInput();
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(MapTable), "Start")]
		private static void MapTable_Start(MapTable __instance)
		{
			if (__instance.m_nview.IsOwner())
			{
				ZdoExt.InitEpoch(__instance.m_nview.GetZDO());
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(MapTable), "GetReadHoverText")]
		private static void MapTable_GetReadHoverText(MapTable __instance, ref string __result, ref bool __runOriginal)
		{
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			if (IsNoMapKey)
			{
				__runOriginal = false;
				__result = __instance.m_name + "\n" + UI.PromptInteract + " $piece_readmap";
				if (WardAccessExt.CanAccessWard(((Component)__instance).transform.position, false))
				{
					__result = __result + "\n" + UI.PromptInteractAlt + " $hud_rename";
				}
				string label = __instance.GetLabel();
				if (label != string.Empty)
				{
					__result += $"\n<color={UIColor.MinorInfo}>{label}</color>";
				}
				int daysRemaining = __instance.GetDaysRemaining();
				if (daysRemaining > 0)
				{
					string arg = ((daysRemaining == 1) ? "$map_charting_single" : StringExt.Localize("$map_charting_plural", new string[1] { daysRemaining.ToString() }));
					__result += $"\n\n<color={UIColor.MinorInfo}>{arg}</color>";
				}
				__result = StringExt.Localize(__result);
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(MapTable), "GetWriteHoverText")]
		private static void MapTable_GetWriteHoverText(MapTable __instance, ref string __result, ref bool __runOriginal)
		{
			if (!IsNoMapKey)
			{
				return;
			}
			__runOriginal = false;
			if (Configs.MapItemEnabled.Value)
			{
				__result = __instance.m_name + "\n" + UI.PromptInteract + " $piece_writemap";
				if (InventoryExt.ContainsItemByPrefab(((Humanoid)Player.m_localPlayer).GetInventory(), "ZenMap") && Configs.MapItemRecraft.Value != 0)
				{
					__result = __result + "\n" + UI.PromptUseItem + " $piece_useitem";
				}
			}
			else
			{
				__result = string.Empty;
			}
			__result = StringExt.Localize(__result);
		}

		private static void PromptLabel(this MapTable table)
		{
			MapTable table2 = table;
			TextPrompt.Show("$map_region_prompt", table2.GetLabel(), (Action<string>)delegate(string input)
			{
				table2.SetLabel(input);
				((Character)Player.m_localPlayer).Message((MessageType)1, "$hud_rename: " + input, 0, Minimap.instance.GetSprite((PinType)1));
				table2.ApplyWriteFX();
			}, 50);
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(Switch), "Interact")]
		private static void Switch_Interact(Switch __instance, Humanoid character, bool hold, bool alt, ref bool __result, ref bool __runOriginal)
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			object? target = ((Delegate)(object)__instance.m_onUse).Target;
			MapTable val = (MapTable)((target is MapTable) ? target : null);
			if (val != null && !((Object)(object)__instance != (Object)(object)val.m_readSwitch) && !(!alt || hold) && WardAccessExt.CanAccessWard(((Component)__instance).transform.position, false))
			{
				val.PromptLabel();
				__runOriginal = false;
				__result = true;
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(MapTable), "OnRead", new Type[]
		{
			typeof(Switch),
			typeof(Humanoid),
			typeof(ItemData)
		})]
		private static void MapTable_OnRead(MapTable __instance, ref bool __runOriginal, ItemData? item)
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			Logging<Plugin>.Debug((object)"Read the MapTable", 0);
			if (!IsNoMapKey)
			{
				return;
			}
			__runOriginal = false;
			if (item == null)
			{
				if (IsGodMode && ZInput.GetKey(Configs.InputMapTableAdminAccelerateAgeKey.Value, true))
				{
					__instance.AccelerateAge(EnvMan.instance.m_dayLengthSec);
					__instance.ApplyWriteFX();
					((Character)Player.m_localPlayer).Message((MessageType)2, "Map table aged 1 day", 0, (Sprite)null);
				}
				else
				{
					__instance.GetLocation().Show();
				}
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(MapTable), "OnWrite")]
		private static void MapTable_Write(MapTable __instance, Humanoid user, ItemData? item, ref bool __runOriginal, ref bool __result)
		{
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			MapTable __instance2 = __instance;
			Humanoid user2 = user;
			ItemData item2 = item;
			Logging<Plugin>.Debug((object)"Write the MapTable", 0);
			if (!IsNoMapKey)
			{
				return;
			}
			__runOriginal = false;
			__result = false;
			if (!Configs.MapItemEnabled.Value)
			{
				return;
			}
			ItemData obj = item2;
			if (((obj != null) ? ItemDataExt.GetPrefabName(obj) : null) == "ZenMap")
			{
				switch (Configs.MapItemRecraft.Value)
				{
				case MapRecraftOption.Disabled:
					return;
				case MapRecraftOption.OriginTable:
				{
					if (!item2.IsNear(((Component)__instance2).transform.position, Configs.MapItemRecraftMaxRange.Value, out string mapItemLabel))
					{
						string text = "$piece_toofar: " + mapItemLabel;
						Sprite val = ((Component)__instance2).GetComponentInParent<Piece>()?.m_icon;
						((Character)Player.m_localPlayer).Message((MessageType)1, text, 0, val);
						return;
					}
					break;
				}
				}
			}
			else
			{
				if (item2 == null)
				{
					item2 = user2.GetInventory().GetItem("ZenMapParchment", -1, true);
				}
				if (!item2.IsMapParchment())
				{
					((Character)user2).Message((MessageType)2, "$msg_donthaveany $map_item_parchment", 0, (Sprite)null);
					return;
				}
			}
			if (item2 == null)
			{
				Logging<Plugin>.Warning((object)"Item is null, this should never happen", 0);
				return;
			}
			__result = true;
			MapLocation mapLocation = __instance2.GetLocation();
			mapLocation.PromptLabel(delegate
			{
				__instance2.CreateMapItem(user2, item2, mapLocation);
			});
		}

		private static void CreateMapItem(this MapTable mapTable, Humanoid user, ItemData item, MapLocation mapLocation)
		{
			GameObject itemPrefab = ObjectDB.instance.GetItemPrefab("ZenMap");
			ItemData val = default(ItemData);
			if (InventoryExt.TryAddItem(user.GetInventory(), itemPrefab, 1, ref val))
			{
				val.m_crafterName = Player.m_localPlayer.GetPlayerName();
				val.m_crafterID = Player.m_localPlayer.GetPlayerID();
				val.m_variant = MapItem.GetNextVariant();
				mapLocation.WriteTo(val);
				if (user.GetInventory().RemoveItem(item, 1))
				{
					((Character)user).ShowRemovedMessage(item, 1);
				}
				else
				{
					Logging<Plugin>.Error((object)("Unable to remove " + ItemDataExt.GetName(item) + " from inventory."), (ushort)0);
				}
				((Character)user).Message((MessageType)2, "$msg_mapsynced", 0, (Sprite)null);
				((Character)user).ShowPickupMessage(val, 1);
				mapTable.ApplyWriteFX();
			}
			else
			{
				((Character)user).Message((MessageType)2, "$msg_noroom", 0, (Sprite)null);
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(Minimap), "UpdateBiome")]
		private static void Minimap_UpdateBiome(Minimap __instance)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Invalid comparison between Unknown and I4
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			if ((int)Minimap.instance.m_mode != 2)
			{
				return;
			}
			TMP_Text biomeNameLarge = __instance.m_biomeNameLarge;
			if (IsGodMode)
			{
				biomeNameLarge.text += "\n<color=yellow>GOD MODE</color>";
			}
			if (!IsNoMapKey || !MapLocation.InUse)
			{
				return;
			}
			biomeNameLarge.outlineColor = Color32.op_Implicit(Color.black);
			biomeNameLarge.outlineWidth = 0.075f;
			biomeNameLarge.alpha = 1f;
			((Graphic)biomeNameLarge).color = Color.white;
			if (ZInput.IsGamepadActive())
			{
				biomeNameLarge.text = string.Empty;
			}
			string label = MapLocation.Active.Label;
			if (Utility.IsNullOrWhiteSpace(label))
			{
				return;
			}
			if (Configs.CalendarShow.Value)
			{
				string text = MapLocation.Active.GetCalendarString(ZNet.instance.GetTimeSeconds());
				if (!MapLocation.IsMapItem())
				{
					text = "$item_current " + text;
				}
				biomeNameLarge.text = "<size=30>" + label + "</size>\r\n" + StringExt.Localize(text) + "\r\n" + biomeNameLarge.text;
			}
			else
			{
				biomeNameLarge.text = "<size=30>" + label + "</size>\r\n" + biomeNameLarge.text;
			}
		}
	}
	[HarmonyPatch]
	internal static class PinToSign
	{
		private static bool AddPin(this Sign sign, PinType pinType)
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			if (!sign.m_nview.IsValid())
			{
				Logging<Plugin>.Error((object)"Sign.m_nview is not valid", (ushort)0);
				return false;
			}
			if (!MapTrack.AddPin(sign.m_nview.GetZDO(), save: true, pinType))
			{
				return false;
			}
			((Character)Player.m_localPlayer).Message((MessageType)2, "$msg_pin_added", 0, (Sprite)null);
			return true;
		}

		private static bool HasPin(this Sign sign, out PinData pin)
		{
			return (pin = sign.m_nview.GetZDO().FindPin()) != null;
		}

		private static bool HasPin(this Sign sign)
		{
			PinData pin;
			return sign.HasPin(out pin);
		}

		private static void RemovePin(this Sign sign)
		{
			PinData val = sign.m_nview.GetZDO().FindPin();
			if (val == null)
			{
				Logging<Plugin>.Error((object)"Attempting to remove pin from sign that does not have a pin", (ushort)0);
				return;
			}
			MapTrack.RemovePin(val);
			((Character)Player.m_localPlayer).Message((MessageType)2, "$msg_removed", 0, (Sprite)null);
		}

		private static bool RefundPin(this Sign sign)
		{
			ItemData itemData = ObjectDB.instance.GetItemPrefab("ZenMapPin").GetComponent<ItemDrop>().m_itemData;
			Player localPlayer = Player.m_localPlayer;
			if (((Humanoid)localPlayer).GetInventory().CanAddItem(itemData, 1))
			{
				sign.RemovePin();
				((Humanoid)localPlayer).GetInventory().AddItem(itemData.m_dropPrefab, 1);
				((Character)localPlayer).Message((MessageType)1, "$piece_tombstone_recovered", 1, itemData.GetIcon());
				return true;
			}
			((Character)localPlayer).Message((MessageType)2, "$msg_noroom", 0, (Sprite)null);
			return false;
		}

		private static string GetPromptUseMapPin(Sign sign)
		{
			Inventory inventory = ((Humanoid)Player.m_localPlayer).GetInventory();
			string text = string.Empty;
			if (!sign.HasPin())
			{
				if (InventoryExt.ContainsItemByPrefab(inventory, "ZenMapPin"))
				{
					text = "$hud_addpin";
				}
			}
			else if (InventoryExt.ContainsItemByPrefab(inventory, "Hammer") || InventoryExt.ContainsItemByPrefab(inventory, "ZenMapPin"))
			{
				text = "$hud_removepin";
			}
			if (text == string.Empty)
			{
				return string.Empty;
			}
			return StringExt.Localize(UI.PromptUseItem + " " + text);
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(Sign), "GetHoverText")]
		private static void Sign_GetHoverText(Sign __instance, ref string __result)
		{
			if (!__result.Contains(StringExt.Localize(UI.PromptUseItem)))
			{
				__result = __result + "\n" + GetPromptUseMapPin(__instance);
			}
			if (__instance.HasPin(out PinData pin))
			{
				HoverItem.UpdateIcons((Sprite[])(object)new Sprite[2]
				{
					MapPin.Icon,
					pin.m_icon
				});
				string text = StringExt.Localize("$piece_sign");
				string replacement = text + " «";
				__result = Regex.Replace(__result, "^" + text, replacement, RegexOptions.Multiline);
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(Sign), "UseItem")]
		private static void Sign_UseItem(Sign __instance, ItemData item, ref bool __result, ref bool __runOriginal)
		{
			Sign __instance2 = __instance;
			ItemData item2 = item;
			bool flag = ItemDataExt.GetPrefabName(item2) == "Hammer";
			if ((!item2.IsMapPin() && !flag) || (flag && !__instance2.HasPin()))
			{
				return;
			}
			__runOriginal = false;
			__result = true;
			Player localPlayer = Player.m_localPlayer;
			Inventory playerInventory = ((Humanoid)localPlayer).GetInventory();
			if (((Character)localPlayer).InInterior())
			{
				((Character)localPlayer).Message((MessageType)1, "$msg_no_pin_indoors", 0, (Sprite)null);
				__result = false;
			}
			else if (!__instance2.HasPin())
			{
				if (InventoryGui.IsVisible())
				{
					InventoryGui.instance.Hide();
				}
				MapPinSelect.Choose(delegate(PinType pinType)
				{
					//IL_0006: Unknown result type (might be due to invalid IL or missing references)
					if (__instance2.AddPin(pinType))
					{
						playerInventory.RemoveOneItem(item2);
					}
				});
			}
			else if (Configs.MapPinRefund.Value)
			{
				__instance2.RefundPin();
			}
			else
			{
				__instance2.RemovePin();
			}
		}
	}
}
[CompilerGenerated]
internal sealed class <>z__ReadOnlyArray<T> : IEnumerable, ICollection, IList, IEnumerable<T>, IReadOnlyCollection<T>, IReadOnlyList<T>, ICollection<T>, IList<T>
{
	int ICollection.Count => _items.Length;

	bool ICollection.IsSynchronized => false;

	object ICollection.SyncRoot => this;

	object IList.this[int index]
	{
		get
		{
			return _items[index];
		}
		set
		{
			throw new NotSupportedException();
		}
	}

	bool IList.IsFixedSize => true;

	bool IList.IsReadOnly => true;

	int IReadOnlyCollection<T>.Count => _items.Length;

	T IReadOnlyList<T>.this[int index] => _items[index];

	int ICollection<T>.Count => _items.Length;

	bool ICollection<T>.IsReadOnly => true;

	T IList<T>.this[int index]
	{
		get
		{
			return _items[index];
		}
		set
		{
			throw new NotSupportedException();
		}
	}

	public <>z__ReadOnlyArray(T[] items)
	{
		_items = items;
	}

	IEnumerator IEnumerable.GetEnumerator()
	{
		return ((IEnumerable)_items).GetEnumerator();
	}

	void ICollection.CopyTo(Array array, int index)
	{
		((ICollection)_items).CopyTo(array, index);
	}

	int IList.Add(object value)
	{
		throw new NotSupportedException();
	}

	void IList.Clear()
	{
		throw new NotSupportedException();
	}

	bool IList.Contains(object value)
	{
		return ((IList)_items).Contains(value);
	}

	int IList.IndexOf(object value)
	{
		return ((IList)_items).IndexOf(value);
	}

	void IList.Insert(int index, object value)
	{
		throw new NotSupportedException();
	}

	void IList.Remove(object value)
	{
		throw new NotSupportedException();
	}

	void IList.RemoveAt(int index)
	{
		throw new NotSupportedException();
	}

	IEnumerator<T> IEnumerable<T>.GetEnumerator()
	{
		return ((IEnumerable<T>)_items).GetEnumerator();
	}

	void ICollection<T>.Add(T item)
	{
		throw new NotSupportedException();
	}

	void ICollection<T>.Clear()
	{
		throw new NotSupportedException();
	}

	bool ICollection<T>.Contains(T item)
	{
		return ((ICollection<T>)_items).Contains(item);
	}

	void ICollection<T>.CopyTo(T[] array, int arrayIndex)
	{
		((ICollection<T>)_items).CopyTo(array, arrayIndex);
	}

	bool ICollection<T>.Remove(T item)
	{
		throw new NotSupportedException();
	}

	int IList<T>.IndexOf(T item)
	{
		return ((IList<T>)_items).IndexOf(item);
	}

	void IList<T>.Insert(int index, T item)
	{
		throw new NotSupportedException();
	}

	void IList<T>.RemoveAt(int index)
	{
		throw new NotSupportedException();
	}
}