using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.IO.Compression;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Serialization;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using BetterMap.Scripts.Creatures;
using BetterMap.Scripts.Map;
using BetterMap.Scripts.Pins;
using BetterMap.Scripts.Vehicles;
using HarmonyLib;
using JetBrains.Annotations;
using Microsoft.CodeAnalysis;
using ServerSync;
using Splatform;
using TMPro;
using UnityEngine;
using UnityEngine.Events;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("BetterMap")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("BetterMap")]
[assembly: AssemblyCopyright("Copyright ©  2025")]
[assembly: AssemblyTrademark("")]
[assembly: Guid("0FFBB82E-5492-486C-A8A5-346DED8E95E7")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: ComVisible(false)]
[assembly: AssemblyVersion("1.0.0.0")]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[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]
	[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;
		}
	}
}
namespace BetterMap
{
	[BepInPlugin("xtav1m.BetterMap", "BetterMap", "1.0.0")]
	public class Plugin : BaseUnityPlugin
	{
		public static ConfigEntry<bool> showCreatures;

		public static ConfigEntry<float> creatureRefreshInterval;

		public static ConfigEntry<bool> showEntityNames;

		public static ConfigEntry<bool> tintTamedCreatures;

		public static ConfigEntry<bool> tintHostileCreatures;

		public static ConfigEntry<bool> showBoats;

		public static ConfigEntry<bool> showCarts;

		public static ConfigEntry<bool> rotateBoatIcons;

		public static ConfigEntry<bool> showVehicleNames;

		public static ConfigEntry<float> vehicleRefreshInterval;

		public static ConfigEntry<bool> autoPin;

		public static ConfigEntry<bool> autoPinPortals;

		public static ConfigEntry<bool> nameTraderPins;

		public static ConfigEntry<bool> revealTraders;

		public static ConfigEntry<float> autoPinMergeDistance;

		public static ConfigEntry<float> autoPinInterval;

		public const PinType AutoPinType = (PinType)3;

		public static ConfigEntry<int> deathMarkersKept;

		public static ConfigEntry<float> explorationRadius;

		public static ConfigEntry<float> iconScale;

		public static ConfigEntry<bool> debugMode;

		public static ConfigEntry<bool> forgetPinned;

		public static readonly ManualLogSource Logger = Logger.CreateLogSource("BetterMap");

		private static readonly ConfigSync configSync = new ConfigSync("xtav1m.BetterMap")
		{
			DisplayName = "BetterMap",
			CurrentVersion = "1.0.0",
			MinimumRequiredVersion = "1.0.0"
		};

		private void Awake()
		{
			InitializeConfig();
			InitializeHarmonyPatches();
			Logger.LogInfo((object)"BetterMap 1.0.0 loaded");
		}

		private void Update()
		{
			CreatureTracker.Tick();
			DeathMarkers.Tick();
			VehicleTracker.Tick();
			VehicleIndex.Tick();
			AutoPins.Tick();
		}

		private ConfigEntry<T> ConfigSync<T>(string group, string name, T value, ConfigDescription description, bool synchronizedSetting = true)
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Expected O, but got Unknown
			ConfigDescription val = new ConfigDescription(description.Description + (synchronizedSetting ? " [Synced with Server]" : " [Not Synced with Server]"), description.AcceptableValues, description.Tags);
			ConfigEntry<T> val2 = ((BaseUnityPlugin)this).Config.Bind<T>(group, name, value, val);
			configSync.AddConfigEntry<T>(val2).SynchronizedConfig = synchronizedSetting;
			return val2;
		}

		private void InitializeConfig()
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Expected O, but got Unknown
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Expected O, but got Unknown
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Expected O, but got Unknown
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Expected O, but got Unknown
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Expected O, but got Unknown
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: Expected O, but got Unknown
			//IL_0127: Unknown result type (might be due to invalid IL or missing references)
			//IL_0132: Expected O, but got Unknown
			//IL_014e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0159: Expected O, but got Unknown
			//IL_0175: Unknown result type (might be due to invalid IL or missing references)
			//IL_0180: Expected O, but got Unknown
			//IL_019c: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a7: Expected O, but got Unknown
			//IL_01d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e0: Expected O, but got Unknown
			//IL_01fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0207: Expected O, but got Unknown
			//IL_0235: Unknown result type (might be due to invalid IL or missing references)
			//IL_0240: Expected O, but got Unknown
			//IL_025c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0267: Expected O, but got Unknown
			//IL_0283: Unknown result type (might be due to invalid IL or missing references)
			//IL_028e: Expected O, but got Unknown
			//IL_02aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b5: Expected O, but got Unknown
			//IL_02e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ee: Expected O, but got Unknown
			//IL_0311: Unknown result type (might be due to invalid IL or missing references)
			//IL_031c: Expected O, but got Unknown
			//IL_034a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0355: Expected O, but got Unknown
			//IL_0383: Unknown result type (might be due to invalid IL or missing references)
			//IL_038e: Expected O, but got Unknown
			//IL_03b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_03bb: Expected O, but got Unknown
			//IL_03d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e2: Expected O, but got Unknown
			((BaseUnityPlugin)this).Config.SaveOnConfigSet = false;
			ConfigEntry<bool> lockingConfig = ConfigSync("1 - ServerSync", "Lock Configuration", value: true, new ConfigDescription("If enabled, the configuration is locked and can be changed by server admins only.", (AcceptableValueBase)null, Array.Empty<object>()));
			configSync.AddLockingConfigEntry<bool>(lockingConfig);
			showCreatures = ConfigSync("Creatures", "Show Creatures", value: true, new ConfigDescription("Show creatures on the minimap and the map, using their trophy as the icon.", (AcceptableValueBase)null, Array.Empty<object>()));
			creatureRefreshInterval = ConfigSync("Creatures", "Creature Refresh Interval", 0.5f, new ConfigDescription("How often, in seconds, the set of tracked creatures is rebuilt. Their pins follow them every frame regardless.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.1f, 5f), Array.Empty<object>()));
			showEntityNames = ConfigSync("Creatures", "Show Creature Names", value: false, new ConfigDescription("Show a name under every creature pin. Creatures with no trophy icon, and tamed creatures that have been given a name, always show theirs regardless of this setting.", (AcceptableValueBase)null, Array.Empty<object>()));
			tintTamedCreatures = ConfigSync("Creatures", "Tint Tamed Creatures", value: true, new ConfigDescription("Tint the pins of tamed creatures green so they stand out from the wildlife.", (AcceptableValueBase)null, Array.Empty<object>()));
			tintHostileCreatures = ConfigSync("Creatures", "Tint Hostile Creatures", value: true, new ConfigDescription("Tint red the pins of creatures that will attack you on sight. Only applies to creatures with no trophy to use as an icon, which are drawn with a plain pin: a creature drawn as its own trophy is already recognisable.", (AcceptableValueBase)null, Array.Empty<object>()));
			showBoats = ConfigSync("Vehicles", "Show Boats", value: true, new ConfigDescription("Show boats on the map. Boats are found anywhere in the world, not only near you, which is what makes one you left adrift findable. Playing alone or hosting, that means every boat there is. As a guest on a server you get the ones in every area you have loaded since connecting, and a boat far away sits where it was when you were last near it.", (AcceptableValueBase)null, Array.Empty<object>()));
			showCarts = ConfigSync("Vehicles", "Show Carts", value: true, new ConfigDescription("Show carts on the map, wherever you left them.", (AcceptableValueBase)null, Array.Empty<object>()));
			rotateBoatIcons = ConfigSync("Vehicles", "Rotate Boat Icons", value: true, new ConfigDescription("Turn boat icons to point the way the boat is facing. While you are sailing, this also replaces the game's own boat marker so both look the same.", (AcceptableValueBase)null, Array.Empty<object>()));
			showVehicleNames = ConfigSync("Vehicles", "Show Vehicle Names", value: true, new ConfigDescription("Show what each vehicle is under its icon, so a raft can be told from a longship.", (AcceptableValueBase)null, Array.Empty<object>()));
			vehicleRefreshInterval = ConfigSync("Vehicles", "Vehicle Refresh Interval", 5f, new ConfigDescription("How often, in seconds, vehicles anywhere in the world are looked up. Vehicles near the player follow them continuously.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(1f, 60f), Array.Empty<object>()));
			autoPin = ConfigSync("Auto Pins", "Enable", value: true, new ConfigDescription("Pin resources as you come across them. What gets pinned is chosen biome by biome below, and a pin you delete is never put back.", (AcceptableValueBase)null, Array.Empty<object>()));
			autoPinInterval = ConfigSync("Auto Pins", "Sweep Interval", 2f, new ConfigDescription("How often, in seconds, the loaded world is looked over for anything worth pinning.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.5f, 30f), Array.Empty<object>()));
			autoPinPortals = ConfigSync("Auto Pins", "Pin Portals", value: true, new ConfigDescription("Pin portals where they stand, named by their tag, using the game's own portal icon. Renaming a portal renames its pin.", (AcceptableValueBase)null, Array.Empty<object>()));
			revealTraders = ConfigSync("Auto Pins", "Reveal Traders", value: false, new ConfigDescription("Put every trader in the world on your map at once, Haldor and Hildir and the bog witch, without having to stumble across them. Off by default because finding them is part of the game. On a server this is decided by the server, and takes effect the next time you connect.", (AcceptableValueBase)null, Array.Empty<object>()));
			nameTraderPins = ConfigSync("Auto Pins", "Name Trader Pins", value: true, new ConfigDescription("Put the trader's name on the pin the game already places for them, so Haldor, Hildir and the bog witch can be told apart on the map.", (AcceptableValueBase)null, Array.Empty<object>()));
			autoPinMergeDistance = ConfigSync("Auto Pins", "Merge Distance", 5f, new ConfigDescription("Do not place an automatic pin within this many meters of one that is already there, so walking past the same deposit does not stack pins on it.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(1f, 50f), Array.Empty<object>()));
			deathMarkersKept = ConfigSync("Map", "Death Markers Kept", 3, new ConfigDescription("How many of your death markers to keep on the map. The game drops a marker where you died but never saves it, so without this they are gone the next time you load the world.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(1, 20), Array.Empty<object>()));
			explorationRadius = ConfigSync("Map", "Exploration Radius", 100f, new ConfigDescription("How much of the map is uncovered as you walk, in meters. 100 is the vanilla value.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(20f, 500f), Array.Empty<object>()));
			iconScale = ConfigSync("Map", "Icon Scale", 1.25f, new ConfigDescription("Size of every pin on the map, as a multiple of its normal size. 1 leaves the game's own size, 32 pixels on the minimap and 48 on the map.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.5f, 3f), Array.Empty<object>()));
			BindPinRules();
			debugMode = ConfigSync("Debug", "Debug Mode", value: false, new ConfigDescription("Log what is being pinned and tracked.", (AcceptableValueBase)null, Array.Empty<object>()), synchronizedSetting: false);
			forgetPinned = ConfigSync("Debug", "Forget Pinned Places", value: false, new ConfigDescription("Once, on the next world you load, throw away this character's record of where it has already pinned, so everything is pinned again. Turn it back off afterwards. This also undoes every automatic pin you deleted on purpose.", (AcceptableValueBase)null, Array.Empty<object>()), synchronizedSetting: false);
			((BaseUnityPlugin)this).Config.SaveOnConfigSet = true;
			((BaseUnityPlugin)this).Config.Save();
		}

		private void BindPinRules()
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Expected O, but got Unknown
			foreach (PinRules.Rule item in PinRules.All)
			{
				item.Enabled = ConfigSync($"Auto Pins - {item.Biome}", item.Name, item.DefaultOn, new ConfigDescription(item.Description, (AcceptableValueBase)null, Array.Empty<object>()));
			}
		}

		private static void InitializeHarmonyPatches()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			new Harmony("xtav1m.BetterMap").PatchAll();
		}
	}
	internal static class PluginInfo
	{
		public const string PLUGIN_NAME = "BetterMap";

		public const string PLUGIN_GUID = "xtav1m.BetterMap";

		public const string PLUGIN_VERSION = "1.0.0";
	}
}
namespace BetterMap.Scripts
{
	public static class Icons
	{
		private static readonly Dictionary<string, Sprite> _sprites = new Dictionary<string, Sprite>();

		private static readonly MethodInfo LoadImageMethod = FindLoadImage();

		public static Sprite Boat => Get("boat.png");

		public static Sprite Cart => Get("cart.png");

		private static MethodInfo FindLoadImage()
		{
			Type type = AccessTools.TypeByName("UnityEngine.ImageConversion");
			if (type == null)
			{
				return null;
			}
			return AccessTools.Method(type, "LoadImage", new Type[3]
			{
				typeof(Texture2D),
				typeof(byte[]),
				typeof(bool)
			}, (Type[])null) ?? AccessTools.Method(type, "LoadImage", new Type[2]
			{
				typeof(Texture2D),
				typeof(byte[])
			}, (Type[])null);
		}

		public static Sprite For(PinCategory category)
		{
			return (Sprite)(category switch
			{
				PinCategory.Ore => Get("ore.png"), 
				PinCategory.Forage => Get("forage.png"), 
				PinCategory.Dungeon => Get("dungeon.png"), 
				PinCategory.Loot => Get("loot.png"), 
				PinCategory.Spawner => Get("spawner.png"), 
				PinCategory.Vegvisir => Get("vegvisir.png"), 
				PinCategory.Beehive => Get("beehive.png"), 
				PinCategory.Tar => Get("tar.png"), 
				PinCategory.Sap => Get("sap.png"), 
				_ => null, 
			});
		}

		private static Sprite Get(string file)
		{
			if (_sprites.TryGetValue(file, out Sprite value))
			{
				return value;
			}
			Sprite val = Load(file);
			_sprites[file] = val;
			return val;
		}

		private static Sprite Load(string file)
		{
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Expected O, but got Unknown
			//IL_008c: 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)
			try
			{
				byte[] array = Read(file);
				if (array == null)
				{
					Plugin.Logger.LogWarning((object)("Icons: " + file + " is not in the assembly"));
					return null;
				}
				Texture2D val = new Texture2D(2, 2, (TextureFormat)4, false)
				{
					filterMode = (FilterMode)1,
					wrapMode = (TextureWrapMode)1
				};
				if (!Decode(val, array))
				{
					Plugin.Logger.LogWarning((object)("Icons: " + file + " could not be decoded"));
					return null;
				}
				return Sprite.Create(val, new Rect(0f, 0f, (float)((Texture)val).width, (float)((Texture)val).height), new Vector2(0.5f, 0.5f));
			}
			catch (Exception arg)
			{
				Plugin.Logger.LogError((object)$"Icons: {file} failed to load: {arg}");
				return null;
			}
		}

		private static bool Decode(Texture2D texture, byte[] bytes)
		{
			if (LoadImageMethod == null)
			{
				Plugin.Logger.LogWarning((object)"Icons: the game's image decoder was not found");
				return false;
			}
			object[] parameters = ((LoadImageMethod.GetParameters().Length != 3) ? new object[2] { texture, bytes } : new object[3] { texture, bytes, false });
			return (bool)LoadImageMethod.Invoke(null, parameters);
		}

		private static byte[] Read(string file)
		{
			Assembly executingAssembly = Assembly.GetExecutingAssembly();
			string value = "." + file;
			string[] manifestResourceNames = executingAssembly.GetManifestResourceNames();
			foreach (string text in manifestResourceNames)
			{
				if (!text.EndsWith(value, StringComparison.OrdinalIgnoreCase))
				{
					continue;
				}
				using Stream stream = executingAssembly.GetManifestResourceStream(text);
				if (stream == null)
				{
					return null;
				}
				byte[] array = new byte[stream.Length];
				int num;
				for (int j = 0; j < array.Length; j += num)
				{
					num = stream.Read(array, j, array.Length - j);
					if (num <= 0)
					{
						break;
					}
				}
				return array;
			}
			return null;
		}
	}
	public static class MapPins
	{
		private static readonly FieldRef<Minimap, bool> PinUpdateRequired = AccessTools.FieldRefAccess<Minimap, bool>("m_pinUpdateRequired");

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

		public static void RequestRedraw()
		{
			if ((Object)(object)Minimap.instance != (Object)null)
			{
				PinUpdateRequired.Invoke(Minimap.instance) = true;
			}
		}

		public static List<PinData> Of(Minimap map)
		{
			return Pins.Invoke(map);
		}

		public static void ApplyScale()
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Invalid comparison between Unknown and I4
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			Minimap instance = Minimap.instance;
			if ((Object)(object)instance == (Object)null)
			{
				return;
			}
			float value = Plugin.iconScale.Value;
			if (Mathf.Approximately(value, 1f))
			{
				return;
			}
			float num = (((int)instance.m_mode == 2) ? instance.m_pinSizeLarge : instance.m_pinSizeSmall);
			foreach (PinData item in Pins.Invoke(instance))
			{
				if (!((Object)(object)item?.m_uiElement == (Object)null) && !(item.m_worldSize > 0f))
				{
					float num2;
					Rect rect;
					if (!item.m_animate)
					{
						num2 = (item.m_doubleSize ? (num * 2f) : num) * value;
					}
					else
					{
						rect = item.m_uiElement.rect;
						num2 = ((Rect)(ref rect)).width * value;
					}
					float num3 = num2;
					rect = item.m_uiElement.rect;
					if (!Mathf.Approximately(((Rect)(ref rect)).width, num3))
					{
						item.m_uiElement.SetSizeWithCurrentAnchors((Axis)0, num3);
						item.m_uiElement.SetSizeWithCurrentAnchors((Axis)1, num3);
					}
				}
			}
		}
	}
}
namespace BetterMap.Scripts.Map
{
	public static class DeathMarkers
	{
		private struct Marker
		{
			public long World;

			public Vector3 Pos;

			public string Label;
		}

		private const string CustomDataKey = "BetterMap.deaths";

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

		private static bool _rebuilt;

		public static void Tick()
		{
			if ((Object)(object)Player.m_localPlayer == (Object)null)
			{
				_rebuilt = false;
			}
			else if (!_rebuilt && !((Object)(object)Minimap.instance == (Object)null))
			{
				_rebuilt = true;
				Rebuild();
			}
		}

		public static void Invalidate()
		{
			_rebuilt = false;
		}

		public static void Record(Vector3 pos)
		{
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)Player.m_localPlayer == (Object)null) && !((Object)(object)ZNet.instance == (Object)null))
			{
				List<Marker> list = Load();
				list.Add(new Marker
				{
					World = ZNet.instance.GetWorldUID(),
					Pos = pos,
					Label = DayLabel()
				});
				Store(list);
				Rebuild();
			}
		}

		private static string DayLabel()
		{
			if ((Object)(object)EnvMan.instance == (Object)null || (Object)(object)ZNet.instance == (Object)null)
			{
				return "";
			}
			return $"$hud_mapday {EnvMan.instance.GetDay(ZNet.instance.GetTimeSeconds())}";
		}

		private static void Rebuild()
		{
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Invalid comparison between Unknown and I4
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			Minimap instance = Minimap.instance;
			if ((Object)(object)instance == (Object)null || (Object)(object)Player.m_localPlayer == (Object)null || (Object)(object)ZNet.instance == (Object)null)
			{
				return;
			}
			List<PinData> list = MapPins.Invoke(instance);
			for (int num = list.Count - 1; num >= 0; num--)
			{
				if ((int)list[num].m_type == 4)
				{
					instance.RemovePin(list[num]);
				}
			}
			long worldUID = ZNet.instance.GetWorldUID();
			foreach (Marker item in Trim(Load()))
			{
				if (item.World == worldUID)
				{
					instance.AddPin(item.Pos, (PinType)4, item.Label, false, false, 0L, default(PlatformUserID));
				}
			}
		}

		private static List<Marker> Trim(List<Marker> markers)
		{
			int value = Plugin.deathMarkersKept.Value;
			Dictionary<long, int> dictionary = new Dictionary<long, int>();
			List<Marker> list = new List<Marker>();
			for (int num = markers.Count - 1; num >= 0; num--)
			{
				Marker item = markers[num];
				dictionary.TryGetValue(item.World, out var value2);
				if (value2 < value)
				{
					dictionary[item.World] = value2 + 1;
					list.Add(item);
				}
			}
			list.Reverse();
			return list;
		}

		private static List<Marker> Load()
		{
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			List<Marker> list = new List<Marker>();
			if ((Object)(object)Player.m_localPlayer == (Object)null)
			{
				return list;
			}
			if (!Player.m_localPlayer.m_customData.TryGetValue("BetterMap.deaths", out var value))
			{
				return list;
			}
			if (string.IsNullOrEmpty(value))
			{
				return list;
			}
			string[] array = value.Split(new char[1] { '|' });
			for (int i = 0; i < array.Length; i++)
			{
				string[] array2 = array[i].Split(new char[1] { ';' }, 5);
				if (array2.Length >= 5 && long.TryParse(array2[0], NumberStyles.Integer, CultureInfo.InvariantCulture, out var result) && TryFloat(array2[1], out var value2) && TryFloat(array2[2], out var value3) && TryFloat(array2[3], out var value4))
				{
					list.Add(new Marker
					{
						World = result,
						Pos = new Vector3(value2, value3, value4),
						Label = array2[4]
					});
				}
			}
			return list;
		}

		private static void Store(List<Marker> markers)
		{
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)Player.m_localPlayer == (Object)null)
			{
				return;
			}
			List<string> list = new List<string>();
			foreach (Marker item in Trim(markers))
			{
				string[] array = new string[5];
				long world = item.World;
				array[0] = world.ToString(CultureInfo.InvariantCulture);
				array[1] = Float(item.Pos.x);
				array[2] = Float(item.Pos.y);
				array[3] = Float(item.Pos.z);
				array[4] = item.Label;
				list.Add(string.Join(";", array));
			}
			Player.m_localPlayer.m_customData["BetterMap.deaths"] = string.Join("|", list.ToArray());
		}

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

		private static bool TryFloat(string text, out float value)
		{
			return float.TryParse(text, NumberStyles.Float, CultureInfo.InvariantCulture, out value);
		}
	}
	[HarmonyPatch]
	public static class MapPatches
	{
		[HarmonyPrefix]
		[HarmonyPatch(typeof(Minimap), "UpdateExplore")]
		private static void Minimap_UpdateExplore_Prefix(Minimap __instance)
		{
			__instance.m_exploreRadius = Plugin.explorationRadius.Value;
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(Minimap), "Start")]
		private static void Minimap_Start_Postfix()
		{
			PinLegend.Install();
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(Minimap), "UpdatePins")]
		private static void Minimap_UpdatePins_Postfix()
		{
			MapPins.ApplyScale();
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(Player), "OnDeath")]
		private static void Player_OnDeath_Postfix(Player __instance)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)__instance != (Object)(object)Player.m_localPlayer))
			{
				DeathMarkers.Record(((Component)__instance).transform.position);
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(Minimap), "SetMapData")]
		private static void Minimap_SetMapData_Postfix()
		{
			DeathMarkers.Invalidate();
			AutoPins.Restore();
		}
	}
}
namespace BetterMap.Scripts.Vehicles
{
	public static class VehicleKinds
	{
		public class Kind
		{
			public string Prefab;

			public int Hash;

			public bool IsBoat;

			public string Label;
		}

		private static List<Kind> _all;

		private static Dictionary<int, Kind> _byHash;

		private static readonly List<Kind> Empty = new List<Kind>();

		public static bool Ready => Discover() != null;

		public static List<Kind> All => Discover() ?? Empty;

		public static Kind Get(int hash)
		{
			if (Discover() == null)
			{
				return null;
			}
			if (!_byHash.TryGetValue(hash, out Kind value))
			{
				return null;
			}
			return value;
		}

		private static List<Kind> Discover()
		{
			if (_all != null)
			{
				return _all;
			}
			ZNetScene instance = ZNetScene.instance;
			if ((Object)(object)instance == (Object)null || instance.m_prefabs == null)
			{
				return null;
			}
			List<Kind> list = new List<Kind>();
			Dictionary<int, Kind> dictionary = new Dictionary<int, Kind>();
			foreach (GameObject prefab in instance.m_prefabs)
			{
				if (!((Object)(object)prefab == (Object)null))
				{
					bool flag = (Object)(object)prefab.GetComponent<Ship>() != (Object)null;
					if (flag || !((Object)(object)prefab.GetComponent<Vagon>() == (Object)null))
					{
						Piece component = prefab.GetComponent<Piece>();
						string label = (((Object)(object)component != (Object)null && !string.IsNullOrEmpty(component.m_name) && Localization.instance != null) ? Localization.instance.Localize(component.m_name) : null);
						Kind kind = new Kind
						{
							Prefab = ((Object)prefab).name,
							Hash = StringExtensionMethods.GetStableHashCode(((Object)prefab).name),
							IsBoat = flag,
							Label = label
						};
						list.Add(kind);
						dictionary[kind.Hash] = kind;
					}
				}
			}
			if (list.Count == 0)
			{
				return null;
			}
			_all = list;
			_byHash = dictionary;
			if (Plugin.debugMode.Value)
			{
				foreach (Kind item in list)
				{
					Plugin.Logger.LogInfo((object)("VehicleKinds: " + item.Prefab + " (" + (item.IsBoat ? "boat" : "cart") + ", " + (item.Label ?? "unnamed") + ")"));
				}
			}
			return _all;
		}
	}
	public static class VehicleMemory
	{
		private const string CustomDataKey = "BetterMap.vehicles";

		private static readonly HashSet<ZDOID> _used = new HashSet<ZDOID>();

		private static long _world;

		private static bool _loaded;

		public static void Remember(ZDOID id)
		{
			//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_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			if (id == ZDOID.None)
			{
				return;
			}
			Load();
			if (_loaded && _used.Add(id))
			{
				Store();
				if (Plugin.debugMode.Value)
				{
					Plugin.Logger.LogInfo((object)$"VehicleMemory: remembered {id}");
				}
			}
		}

		public static HashSet<ZDOID> Used()
		{
			Load();
			return _used;
		}

		public static void Forget()
		{
			_used.Clear();
			_loaded = false;
			_world = 0L;
		}

		private static void Load()
		{
			//IL_011b: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)Player.m_localPlayer == (Object)null || (Object)(object)ZNet.instance == (Object)null)
			{
				return;
			}
			long worldUID = ZNet.instance.GetWorldUID();
			if (_loaded && _world == worldUID)
			{
				return;
			}
			_used.Clear();
			_world = worldUID;
			_loaded = true;
			if (!Player.m_localPlayer.m_customData.TryGetValue("BetterMap.vehicles", out var value) || string.IsNullOrEmpty(value))
			{
				return;
			}
			string[] array = value.Split(new char[1] { '|' });
			for (int i = 0; i < array.Length; i++)
			{
				string[] array2 = array[i].Split(new char[1] { ';' });
				if (array2.Length == 3 && long.TryParse(array2[0], NumberStyles.Integer, CultureInfo.InvariantCulture, out var result) && result == worldUID && long.TryParse(array2[1], NumberStyles.Integer, CultureInfo.InvariantCulture, out var result2) && uint.TryParse(array2[2], NumberStyles.Integer, CultureInfo.InvariantCulture, out var result3))
				{
					_used.Add(new ZDOID(result2, result3));
				}
			}
		}

		private static void Store()
		{
			//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)
			if ((Object)(object)Player.m_localPlayer == (Object)null)
			{
				return;
			}
			List<string> list = new List<string>();
			if (Player.m_localPlayer.m_customData.TryGetValue("BetterMap.vehicles", out var value) && !string.IsNullOrEmpty(value))
			{
				string[] array = value.Split(new char[1] { '|' });
				foreach (string text in array)
				{
					string[] array2 = text.Split(new char[1] { ';' });
					if (array2.Length == 3 && long.TryParse(array2[0], NumberStyles.Integer, CultureInfo.InvariantCulture, out var result) && result != _world)
					{
						list.Add(text);
					}
				}
			}
			foreach (ZDOID item in _used)
			{
				ZDOID current = item;
				list.Add(string.Join(";", _world.ToString(CultureInfo.InvariantCulture), ((ZDOID)(ref current)).UserID.ToString(CultureInfo.InvariantCulture), ((ZDOID)(ref current)).ID.ToString(CultureInfo.InvariantCulture)));
			}
			Player.m_localPlayer.m_customData["BetterMap.vehicles"] = string.Join("|", list.ToArray());
		}
	}
	public static class VehicleIndex
	{
		public struct Record
		{
			public ZDOID Id;

			public int Prefab;

			public Vector3 Pos;

			public float Heading;

			public long Creator;
		}

		private class Request
		{
			public long Peer;

			public long Player;

			public HashSet<ZDOID> Used;
		}

		private static readonly List<Record> _records = new List<Record>();

		private static readonly List<Request> _pending = new List<Request>();

		private static readonly List<ZDO> _found = new List<ZDO>();

		private static readonly List<Record> _matched = new List<Record>();

		private static int _kindIndex;

		private static int _sectorIndex;

		private static bool _scanning;

		private static float _scannedAt = float.NegativeInfinity;

		public static void Ask(long peer, long player, HashSet<ZDOID> used)
		{
			if (!_scanning && Time.time - _scannedAt < Plugin.vehicleRefreshInterval.Value)
			{
				Answer(new Request
				{
					Peer = peer,
					Player = player,
					Used = used
				});
			}
			else
			{
				_pending.Add(new Request
				{
					Peer = peer,
					Player = player,
					Used = used
				});
			}
		}

		public static void Tick()
		{
			if ((Object)(object)ZNet.instance == (Object)null || !ZNet.instance.IsServer() || ZDOMan.instance == null || !VehicleKinds.Ready)
			{
				return;
			}
			if (!_scanning)
			{
				if (_pending.Count == 0)
				{
					return;
				}
				_scanning = true;
				_kindIndex = 0;
				_sectorIndex = 0;
				_found.Clear();
			}
			Scan();
		}

		private static void Scan()
		{
			List<VehicleKinds.Kind> all = VehicleKinds.All;
			if (_kindIndex < all.Count)
			{
				if (ZDOMan.instance.GetAllZDOsWithPrefabIterative(all[_kindIndex].Prefab, _found, ref _sectorIndex))
				{
					_kindIndex++;
					_sectorIndex = 0;
				}
				return;
			}
			Collect();
			_scanning = false;
			_scannedAt = Time.time;
			foreach (Request item in _pending)
			{
				Answer(item);
			}
			_pending.Clear();
		}

		private static void Collect()
		{
			//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_005d: 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_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			_records.Clear();
			foreach (ZDO item2 in _found)
			{
				if (item2 != null && item2.IsValid())
				{
					List<Record> records = _records;
					Record item = new Record
					{
						Id = item2.m_uid,
						Prefab = item2.GetPrefab(),
						Pos = item2.GetPosition()
					};
					Quaternion rotation = item2.GetRotation();
					item.Heading = ((Quaternion)(ref rotation)).eulerAngles.y;
					item.Creator = item2.GetLong(ZDOVars.s_creator, 0L);
					records.Add(item);
				}
			}
			_found.Clear();
		}

		private static void Answer(Request request)
		{
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Expected O, but got Unknown
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			_matched.Clear();
			foreach (Record record in _records)
			{
				if ((record.Creator != 0L && record.Creator == request.Player) || (request.Used != null && request.Used.Contains(record.Id)))
				{
					_matched.Add(record);
				}
			}
			ZPackage val = new ZPackage();
			val.Write(_matched.Count);
			foreach (Record item in _matched)
			{
				val.Write(item.Id);
				val.Write(item.Prefab);
				val.Write(item.Pos);
				val.Write(item.Heading);
			}
			VehicleRpc.Reply(request.Peer, val);
		}
	}
	public static class VehicleRpc
	{
		private const string RequestName = "BetterMap_VehiclesRequest";

		private const string ResponseName = "BetterMap_VehiclesResponse";

		public static readonly List<VehicleIndex.Record> Remote = new List<VehicleIndex.Record>();

		private static bool _registered;

		private static float _nextRequest;

		public static void Register()
		{
			if (!_registered && ZRoutedRpc.instance != null)
			{
				_registered = true;
				ZRoutedRpc.instance.Register<ZPackage>("BetterMap_VehiclesRequest", (Action<long, ZPackage>)OnRequest);
				ZRoutedRpc.instance.Register<ZPackage>("BetterMap_VehiclesResponse", (Action<long, ZPackage>)OnResponse);
			}
		}

		public static void Reset()
		{
			_registered = false;
			_nextRequest = 0f;
			Remote.Clear();
		}

		public static void Tick()
		{
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Expected O, but got Unknown
			//IL_0076: 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: Unknown result type (might be due to invalid IL or missing references)
			if (ZRoutedRpc.instance == null || (Object)(object)Player.m_localPlayer == (Object)null || Time.time < _nextRequest)
			{
				return;
			}
			_nextRequest = Time.time + Plugin.vehicleRefreshInterval.Value;
			ZPackage val = new ZPackage();
			val.Write(Player.m_localPlayer.GetPlayerID());
			HashSet<ZDOID> hashSet = VehicleMemory.Used();
			val.Write(hashSet.Count);
			foreach (ZDOID item in hashSet)
			{
				val.Write(item);
			}
			ZRoutedRpc.instance.InvokeRoutedRPC("BetterMap_VehiclesRequest", new object[1] { val });
		}

		private static void OnRequest(long sender, ZPackage package)
		{
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)ZNet.instance == (Object)null) && ZNet.instance.IsServer() && package != null)
			{
				long player = package.ReadLong();
				int num = package.ReadInt();
				HashSet<ZDOID> hashSet = new HashSet<ZDOID>();
				for (int i = 0; i < num; i++)
				{
					hashSet.Add(package.ReadZDOID());
				}
				VehicleIndex.Ask(sender, player, hashSet);
			}
		}

		public static void Reply(long peer, ZPackage package)
		{
			if (ZRoutedRpc.instance != null)
			{
				ZRoutedRpc.instance.InvokeRoutedRPC(peer, "BetterMap_VehiclesResponse", new object[1] { package });
			}
		}

		private static void OnResponse(long sender, ZPackage package)
		{
			//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_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			if (package != null)
			{
				Remote.Clear();
				int num = package.ReadInt();
				for (int i = 0; i < num; i++)
				{
					Remote.Add(new VehicleIndex.Record
					{
						Id = package.ReadZDOID(),
						Prefab = package.ReadInt(),
						Pos = package.ReadVector3(),
						Heading = package.ReadSingle()
					});
				}
				if (Plugin.debugMode.Value)
				{
					Plugin.Logger.LogInfo((object)$"VehicleRpc: {num} of my vehicles");
				}
			}
		}
	}
	public static class VehicleTracker
	{
		private class Tracked
		{
			public PinData Pin;

			public Transform Instance;

			public float Heading;
		}

		private struct Vehicle
		{
			public Transform Instance;

			public Vector3 Pos;

			public float Heading;

			public VehicleKinds.Kind Kind;
		}

		private static readonly FieldRef<List<Vagon>> Carts = AccessTools.StaticFieldRefAccess<List<Vagon>>(AccessTools.Field(typeof(Vagon), "m_instances"));

		private static readonly Dictionary<ZDOID, Tracked> _tracked = new Dictionary<ZDOID, Tracked>();

		private static readonly Dictionary<ZDOID, Vehicle> _wanted = new Dictionary<ZDOID, Vehicle>();

		private static readonly List<ZDOID> _gone = new List<ZDOID>();

		private static bool _named;

		public static void Tick()
		{
			bool value = Plugin.showBoats.Value;
			bool value2 = Plugin.showCarts.Value;
			if (!value && !value2)
			{
				if (_tracked.Count > 0)
				{
					Clear();
				}
			}
			else if (!((Object)(object)Minimap.instance == (Object)null) && !((Object)(object)Player.m_localPlayer == (Object)null) && VehicleKinds.Ready)
			{
				if (_named != Plugin.showVehicleNames.Value)
				{
					_named = Plugin.showVehicleNames.Value;
					Clear();
				}
				VehicleRpc.Tick();
				Gather(value, value2);
				Reconcile();
				UpdatePositions();
			}
		}

		private static void Gather(bool wantBoats, bool wantCarts)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0149: Unknown result type (might be due to invalid IL or missing references)
			//IL_0162: Unknown result type (might be due to invalid IL or missing references)
			//IL_0167: Unknown result type (might be due to invalid IL or missing references)
			_wanted.Clear();
			Vector3 position = ((Component)Player.m_localPlayer).transform.position;
			float value = Plugin.explorationRadius.Value;
			float rangeSqr = value * value;
			foreach (IMonoUpdater instance in Ship.Instances)
			{
				Ship val = (Ship)(object)((instance is Ship) ? instance : null);
				if (!((Object)(object)val == (Object)null))
				{
					Consider(((Component)val).gameObject, wantBoats, wantCarts, position, rangeSqr);
				}
			}
			List<Vagon> list = Carts.Invoke();
			if (list != null)
			{
				foreach (Vagon item in list)
				{
					if (!((Object)(object)item == (Object)null))
					{
						Consider(((Component)item).gameObject, wantBoats, wantCarts, position, rangeSqr);
					}
				}
			}
			foreach (VehicleIndex.Record item2 in VehicleRpc.Remote)
			{
				if (!_wanted.ContainsKey(item2.Id))
				{
					VehicleKinds.Kind kind = VehicleKinds.Get(item2.Prefab);
					if (kind != null && !(kind.IsBoat ? (!wantBoats) : (!wantCarts)))
					{
						_wanted[item2.Id] = new Vehicle
						{
							Instance = null,
							Pos = item2.Pos,
							Heading = item2.Heading,
							Kind = kind
						};
					}
				}
			}
		}

		private static void Consider(GameObject go, bool wantBoats, bool wantCarts, Vector3 origin, float rangeSqr)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_002d: 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_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			ZNetView component = go.GetComponent<ZNetView>();
			if ((Object)(object)component == (Object)null || !component.IsValid())
			{
				return;
			}
			Vector3 position = go.transform.position;
			Vector3 val = position - origin;
			if (!(((Vector3)(ref val)).sqrMagnitude > rangeSqr))
			{
				ZDO zDO = component.GetZDO();
				VehicleKinds.Kind kind = VehicleKinds.Get(zDO.GetPrefab());
				if (kind != null && !(kind.IsBoat ? (!wantBoats) : (!wantCarts)))
				{
					Dictionary<ZDOID, Vehicle> wanted = _wanted;
					ZDOID uid = zDO.m_uid;
					Vehicle value = new Vehicle
					{
						Instance = go.transform,
						Pos = position
					};
					Quaternion rotation = go.transform.rotation;
					value.Heading = ((Quaternion)(ref rotation)).eulerAngles.y;
					value.Kind = kind;
					wanted[uid] = value;
				}
			}
		}

		private static void Reconcile()
		{
			//IL_002f: 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_007d: 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_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: 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_012d: Unknown result type (might be due to invalid IL or missing references)
			//IL_016e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0173: Unknown result type (might be due to invalid IL or missing references)
			//IL_019b: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f7: Expected O, but got Unknown
			Minimap instance = Minimap.instance;
			_gone.Clear();
			foreach (KeyValuePair<ZDOID, Tracked> item in _tracked)
			{
				if (!_wanted.ContainsKey(item.Key))
				{
					_gone.Add(item.Key);
				}
			}
			foreach (ZDOID item2 in _gone)
			{
				instance.RemovePin(_tracked[item2].Pin);
				_tracked.Remove(item2);
			}
			foreach (KeyValuePair<ZDOID, Vehicle> item3 in _wanted)
			{
				Vehicle value = item3.Value;
				if (_tracked.TryGetValue(item3.Key, out Tracked value2))
				{
					value2.Instance = value.Instance;
					if ((Object)(object)value.Instance == (Object)null)
					{
						value2.Pin.m_pos = value.Pos;
						value2.Heading = value.Heading;
					}
					continue;
				}
				bool flag = _named && !string.IsNullOrEmpty(value.Kind.Label);
				PinData val = instance.AddPin(value.Pos, PinLegend.VehicleType, flag ? value.Kind.Label : "", false, false, 0L, default(PlatformUserID));
				Sprite val2 = (value.Kind.IsBoat ? Icons.Boat : Icons.Cart);
				if ((Object)(object)val2 != (Object)null)
				{
					val.m_icon = val2;
				}
				if (flag)
				{
					val.m_NamePinData = new PinNameData(val);
				}
				_tracked[item3.Key] = new Tracked
				{
					Pin = val,
					Instance = value.Instance,
					Heading = value.Heading
				};
			}
		}

		private static void UpdatePositions()
		{
			//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_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			bool flag = false;
			foreach (KeyValuePair<ZDOID, Tracked> item in _tracked)
			{
				Tracked value = item.Value;
				if (!((Object)(object)value.Instance == (Object)null))
				{
					Vector3 position = value.Instance.position;
					if (value.Pin.m_pos != position)
					{
						value.Pin.m_pos = position;
						flag = true;
					}
					Quaternion rotation = value.Instance.rotation;
					value.Heading = ((Quaternion)(ref rotation)).eulerAngles.y;
				}
			}
			if (flag)
			{
				MapPins.RequestRedraw();
			}
		}

		public static void RestylePins()
		{
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			if (_tracked.Count == 0 || !Plugin.rotateBoatIcons.Value)
			{
				return;
			}
			foreach (KeyValuePair<ZDOID, Tracked> item in _tracked)
			{
				Tracked value = item.Value;
				if (value.Pin != null && !((Object)(object)value.Pin.m_uiElement == (Object)null))
				{
					((Transform)value.Pin.m_uiElement).localRotation = Quaternion.Euler(0f, 0f, 0f - value.Heading);
				}
			}
		}

		public static void Clear()
		{
			if ((Object)(object)Minimap.instance != (Object)null)
			{
				foreach (KeyValuePair<ZDOID, Tracked> item in _tracked)
				{
					if (item.Value.Pin != null)
					{
						Minimap.instance.RemovePin(item.Value.Pin);
					}
				}
			}
			_tracked.Clear();
			_wanted.Clear();
		}
	}
	[HarmonyPatch]
	public static class VehiclePatches
	{
		[HarmonyPostfix]
		[HarmonyPatch(typeof(Minimap), "UpdatePins")]
		private static void Minimap_UpdatePins_Postfix()
		{
			VehicleTracker.RestylePins();
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(Minimap), "UpdatePlayerMarker")]
		private static void Minimap_UpdatePlayerMarker_Postfix(Minimap __instance)
		{
			if (Plugin.showBoats.Value)
			{
				if ((Object)(object)__instance.m_smallShipMarker != (Object)null)
				{
					((Component)__instance.m_smallShipMarker).gameObject.SetActive(false);
				}
				if ((Object)(object)__instance.m_largeShipMarker != (Object)null)
				{
					((Component)__instance.m_largeShipMarker).gameObject.SetActive(false);
				}
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(Player), "StartDoodadControl")]
		private static void Player_StartDoodadControl_Postfix(Player __instance, IDoodadController shipControl)
		{
			if (!((Object)(object)__instance != (Object)(object)Player.m_localPlayer) && shipControl != null)
			{
				Remember(shipControl.GetControlledComponent());
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(Vagon), "AttachTo")]
		private static void Vagon_AttachTo_Postfix(Vagon __instance, GameObject go)
		{
			if (!((Object)(object)Player.m_localPlayer == (Object)null) && !((Object)(object)go != (Object)(object)((Component)Player.m_localPlayer).gameObject))
			{
				Remember((Component)(object)__instance);
			}
		}

		private static void Remember(Component component)
		{
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)component == (Object)null))
			{
				ZNetView component2 = component.GetComponent<ZNetView>();
				if (!((Object)(object)component2 == (Object)null) && component2.IsValid() && VehicleKinds.Get(component2.GetZDO().GetPrefab()) != null)
				{
					VehicleMemory.Remember(component2.GetZDO().m_uid);
				}
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(Game), "Start")]
		private static void Game_Start_Postfix()
		{
			VehicleRpc.Register();
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(Game), "Logout")]
		private static void Game_Logout_Postfix()
		{
			VehicleRpc.Reset();
			VehicleMemory.Forget();
		}
	}
}
namespace BetterMap.Scripts.Creatures
{
	public static class CreatureIcons
	{
		private static readonly Dictionary<string, Sprite> _icons = new Dictionary<string, Sprite>();

		public static Sprite Get(Character creature)
		{
			if ((Object)(object)creature == (Object)null)
			{
				return null;
			}
			string text = PrefabName(((Component)creature).gameObject);
			if (_icons.TryGetValue(text, out Sprite value))
			{
				return value;
			}
			Sprite val = Resolve(((Component)creature).gameObject);
			_icons[text] = val;
			if (Plugin.debugMode.Value)
			{
				Plugin.Logger.LogInfo((object)("CreatureIcons: " + text + " -> " + (((Object)(object)val != (Object)null) ? ((Object)val).name : "no trophy")));
			}
			return val;
		}

		private static Sprite Resolve(GameObject prefab)
		{
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Expected O, but got Unknown
			CharacterDrop component = prefab.GetComponent<CharacterDrop>();
			if (component?.m_drops == null)
			{
				return null;
			}
			foreach (Drop drop in component.m_drops)
			{
				if (!((Object)(object)drop?.m_prefab == (Object)null) && ((Object)drop.m_prefab).name.StartsWith("Trophy", StringComparison.OrdinalIgnoreCase))
				{
					Sprite[] array = drop.m_prefab.GetComponent<ItemDrop>()?.m_itemData?.m_shared?.m_icons;
					if (array != null && array.Length != 0)
					{
						return array[0];
					}
				}
			}
			return null;
		}

		public static string PrefabName(GameObject go)
		{
			string name = ((Object)go).name;
			int num = name.IndexOf("(Clone)", StringComparison.Ordinal);
			if (num >= 0)
			{
				return name.Substring(0, num);
			}
			return name;
		}

		public static void Clear()
		{
			_icons.Clear();
		}
	}
	public static class CreatureTracker
	{
		private class Tracked
		{
			public Character Creature;

			public PinData Pin;

			public bool Tamed;

			public bool Named;

			public string Label;

			public bool Hostile;

			public bool HasIcon;
		}

		private struct Style
		{
			public Sprite Icon;

			public bool Tamed;

			public bool Named;

			public string Label;

			public bool Hostile;
		}

		private static readonly Dictionary<Character, Tracked> _tracked = new Dictionary<Character, Tracked>();

		private static readonly List<Character> _leaving = new List<Character>();

		private static readonly List<Character> _characters = new List<Character>();

		private static float _nextRefresh;

		private static readonly HashSet<string> Excluded = new HashSet<string> { "piece_TrainingDummy", "FrozenKing_p2", "FrozenKing_p3" };

		private static readonly Color TamedTint = new Color(0.45f, 0.95f, 0.45f, 1f);

		private static readonly Color HostileTint = new Color(0.95f, 0.4f, 0.4f, 1f);

		public static void Tick()
		{
			if (!Plugin.showCreatures.Value)
			{
				if (_tracked.Count > 0)
				{
					Clear();
				}
			}
			else if (!((Object)(object)Minimap.instance == (Object)null) && !((Object)(object)Player.m_localPlayer == (Object)null))
			{
				if (Time.time >= _nextRefresh)
				{
					_nextRefresh = Time.time + Plugin.creatureRefreshInterval.Value;
					Refresh();
				}
				UpdatePositions();
			}
		}

		private static void Refresh()
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: 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_024d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0252: Unknown result type (might be due to invalid IL or missing references)
			//IL_0253: Unknown result type (might be due to invalid IL or missing references)
			//IL_0258: Unknown result type (might be due to invalid IL or missing references)
			Vector3 position = ((Component)Player.m_localPlayer).transform.position;
			float value = Plugin.explorationRadius.Value;
			float num = value * value;
			_leaving.Clear();
			Vector3 val;
			foreach (KeyValuePair<Character, Tracked> item in _tracked)
			{
				Character key = item.Key;
				if (!((Object)(object)key == (Object)null) && !key.IsDead())
				{
					val = ((Component)key).transform.position - position;
					if (!(((Vector3)(ref val)).sqrMagnitude > num))
					{
						continue;
					}
				}
				_leaving.Add(key);
			}
			foreach (Character item2 in _leaving)
			{
				Remove(item2);
			}
			_leaving.Clear();
			foreach (KeyValuePair<Character, Tracked> item3 in _tracked)
			{
				if (!((Object)(object)item3.Key == (Object)null))
				{
					Style style = Describe(item3.Key);
					Tracked value2 = item3.Value;
					value2.Hostile = style.Hostile;
					if (style.Tamed != value2.Tamed || style.Named != value2.Named || (style.Named && style.Label != value2.Label))
					{
						_leaving.Add(item3.Key);
					}
				}
			}
			foreach (Character item4 in _leaving)
			{
				Remove(item4);
				Add(item4);
			}
			_characters.Clear();
			_characters.AddRange(Character.GetAllCharacters());
			foreach (Character character in _characters)
			{
				if (!_tracked.ContainsKey(character) && ShouldTrack(character))
				{
					val = ((Component)character).transform.position - position;
					if (!(((Vector3)(ref val)).sqrMagnitude > num))
					{
						Add(character);
					}
				}
			}
		}

		private static void UpdatePositions()
		{
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			bool flag = false;
			foreach (KeyValuePair<Character, Tracked> item in _tracked)
			{
				if (!((Object)(object)item.Key == (Object)null))
				{
					Vector3 position = ((Component)item.Key).transform.position;
					if (!(item.Value.Pin.m_pos == position))
					{
						item.Value.Pin.m_pos = position;
						flag = true;
					}
				}
			}
			if (flag)
			{
				MapPins.RequestRedraw();
			}
		}

		private static bool ShouldTrack(Character creature)
		{
			if ((Object)(object)creature == (Object)null || creature.IsDead())
			{
				return false;
			}
			if (creature.IsPlayer())
			{
				return false;
			}
			if ((Object)(object)((Component)creature).GetComponent<CharacterTimedDestruction>() != (Object)null)
			{
				return false;
			}
			string text = CreatureIcons.PrefabName(((Component)creature).gameObject);
			if (text.StartsWith("Aspect_", StringComparison.Ordinal))
			{
				return false;
			}
			if (Excluded.Contains(text))
			{
				return false;
			}
			return true;
		}

		private static Style Describe(Character creature)
		{
			Sprite val = CreatureIcons.Get(creature);
			bool flag = creature.IsTamed();
			string text = GivenName(creature);
			bool flag2 = (Object)(object)val == (Object)null || (flag && !string.IsNullOrEmpty(text)) || Plugin.showEntityNames.Value;
			return new Style
			{
				Icon = val,
				Tamed = flag,
				Named = flag2,
				Hostile = IsHostile(creature, flag),
				Label = ((!flag2) ? null : ((!string.IsNullOrEmpty(text)) ? text : Localization.instance.Localize(creature.m_name)))
			};
		}

		private static void Add(Character creature)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Expected O, but got Unknown
			Style style = Describe(creature);
			PinData val = Minimap.instance.AddPin(((Component)creature).transform.position, PinLegend.CreatureType, style.Named ? style.Label : "", false, false, 0L, default(PlatformUserID));
			if ((Object)(object)style.Icon != (Object)null)
			{
				val.m_icon = style.Icon;
			}
			if (style.Named)
			{
				val.m_NamePinData = new PinNameData(val);
			}
			_tracked[creature] = new Tracked
			{
				Creature = creature,
				Pin = val,
				Tamed = style.Tamed,
				Named = style.Named,
				Label = style.Label,
				Hostile = style.Hostile,
				HasIcon = ((Object)(object)style.Icon != (Object)null)
			};
		}

		private static bool IsHostile(Character creature, bool tamed)
		{
			if (tamed)
			{
				return false;
			}
			BaseAI baseAI = creature.GetBaseAI();
			MonsterAI val = (MonsterAI)(object)((baseAI is MonsterAI) ? baseAI : null);
			if ((Object)(object)val == (Object)null)
			{
				return false;
			}
			if (((BaseAI)val).m_aggravatable && !((BaseAI)val).IsAggravated())
			{
				return false;
			}
			if ((Object)(object)ZoneSystem.instance != (Object)null && ZoneSystem.instance.GetGlobalKey((GlobalKeys)30))
			{
				return false;
			}
			return true;
		}

		private static void Remove(Character creature)
		{
			if (_tracked.TryGetValue(creature, out Tracked value))
			{
				_tracked.Remove(creature);
				if ((Object)(object)Minimap.instance != (Object)null && value.Pin != null)
				{
					Minimap.instance.RemovePin(value.Pin);
				}
			}
		}

		private static string GivenName(Character creature)
		{
			Tameable component = ((Component)creature).GetComponent<Tameable>();
			if ((Object)(object)component == (Object)null)
			{
				return null;
			}
			string text = component.GetText();
			if (!string.IsNullOrEmpty(text))
			{
				return text;
			}
			return null;
		}

		public static void RestylePins()
		{
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			if (_tracked.Count == 0 || (Object)(object)Minimap.instance == (Object)null)
			{
				return;
			}
			bool value = Plugin.tintTamedCreatures.Value;
			bool value2 = Plugin.tintHostileCreatures.Value;
			foreach (KeyValuePair<Character, Tracked> item in _tracked)
			{
				Tracked value3 = item.Value;
				PinData pin = value3.Pin;
				if ((Object)(object)pin?.m_iconElement == (Object)null)
				{
					continue;
				}
				if (value3.Tamed)
				{
					if (value)
					{
						((Graphic)pin.m_iconElement).color = TamedTint;
					}
				}
				else if (value2 && value3.Hostile && !value3.HasIcon)
				{
					((Graphic)pin.m_iconElement).color = HostileTint;
				}
			}
		}

		public static void Clear()
		{
			if ((Object)(object)Minimap.instance != (Object)null)
			{
				foreach (KeyValuePair<Character, Tracked> item in _tracked)
				{
					if (item.Value.Pin != null)
					{
						Minimap.instance.RemovePin(item.Value.Pin);
					}
				}
			}
			_tracked.Clear();
		}
	}
	[HarmonyPatch]
	public static class CreaturePatches
	{
		[HarmonyPostfix]
		[HarmonyPatch(typeof(Minimap), "UpdatePins")]
		private static void Minimap_UpdatePins_Postfix()
		{
			CreatureTracker.RestylePins();
		}
	}
}
namespace BetterMap.Scripts.Pins
{
	public enum PinCategory
	{
		Ore,
		Forage,
		Dungeon,
		Loot,
		Spawner,
		Vegvisir,
		Beehive,
		Tar,
		Sap,
		Boss,
		Portal
	}
	public static class PinRules
	{
		public class Rule
		{
			public string Name;

			public string Description;

			public string NameToken;

			public string[] Prefabs;

			public Biome Biome;

			public PinCategory Category;

			public bool DefaultOn;

			public bool IsLocation;

			public ConfigEntry<bool> Enabled;
		}

		public static readonly List<Rule> All = new List<Rule>
		{
			new Rule
			{
				Name = "Beehives",
				Description = "Wild beehives, in and around the abandoned houses. Honey and a queen bee.",
				NameToken = "$piece_beehive",
				Prefabs = new string[1] { "Beehive" },
				Biome = (Biome)1,
				Category = PinCategory.Beehive,
				DefaultOn = true,
				IsLocation = false
			},
			new Rule
			{
				Name = "Vegvisirs",
				Description = "The runestones that reveal a boss on your map.",
				NameToken = "$piece_vegvisir",
				Prefabs = new string[7] { "Vegvisir_Eikthyr", "Vegvisir_GDKing", "Vegvisir_Bonemass", "Vegvisir_DragonQueen", "Vegvisir_GoblinKing", "Vegvisir_Fader", "Vegvisir_DNBoss" },
				Biome = (Biome)1,
				Category = PinCategory.Vegvisir,
				DefaultOn = true,
				IsLocation = false
			},
			new Rule
			{
				Name = "Raspberry Bushes",
				Description = "Raspberry bushes.",
				Prefabs = new string[1] { "RaspberryBush" },
				Biome = (Biome)1,
				Category = PinCategory.Forage,
				DefaultOn = false,
				IsLocation = false
			},
			new Rule
			{
				Name = "Flint",
				Description = "Flint along the shoreline.",
				Prefabs = new string[1] { "Pickable_Flint" },
				Biome = (Biome)1,
				Category = PinCategory.Forage,
				DefaultOn = false,
				IsLocation = false
			},
			new Rule
			{
				Name = "Mushrooms",
				Description = "Ordinary mushrooms.",
				Prefabs = new string[1] { "Pickable_Mushroom" },
				Biome = (Biome)1,
				Category = PinCategory.Forage,
				DefaultOn = false,
				IsLocation = false
			},
			new Rule
			{
				Name = "Dandelions",
				Description = "Dandelions.",
				Prefabs = new string[1] { "Pickable_Dandelion" },
				Biome = (Biome)1,
				Category = PinCategory.Forage,
				DefaultOn = false,
				IsLocation = false
			},
			new Rule
			{
				Name = "Boar Runestones",
				Description = "Runestones ringed by boar spawners. A place to farm, not a place to gather.",
				Prefabs = new string[1] { "Runestone_Boars" },
				Biome = (Biome)1,
				Category = PinCategory.Spawner,
				DefaultOn = false,
				IsLocation = true
			},
			new Rule
			{
				Name = "Altar of Eikthyr",
				Description = "Where Eikthyr is summoned. Off by default: use a vegvisir and the game pins it for you.",
				Prefabs = new string[1] { "Eikthyrnir" },
				Biome = (Biome)1,
				Category = PinCategory.Boss,
				DefaultOn = false,
				IsLocation = true
			},
			new Rule
			{
				Name = "Vegvisirs",
				Description = "The runestones that reveal a boss on your map. Pinned wherever they stand, rather than the ruin around them.",
				NameToken = "$piece_vegvisir",
				Prefabs = new string[7] { "Vegvisir_Eikthyr", "Vegvisir_GDKing", "Vegvisir_Bonemass", "Vegvisir_DragonQueen", "Vegvisir_GoblinKing", "Vegvisir_Fader", "Vegvisir_DNBoss" },
				Biome = (Biome)8,
				Category = PinCategory.Vegvisir,
				DefaultOn = true,
				IsLocation = false
			},
			new Rule
			{
				Name = "Copper Deposits",
				Description = "The large half buried rocks you mine for copper.",
				Prefabs = new string[1] { "rock4_copper" },
				Biome = (Biome)8,
				Category = PinCategory.Ore,
				DefaultOn = true,
				IsLocation = false
			},
			new Rule
			{
				Name = "Tin Deposits",
				Description = "Tin along the water's edge.",
				Prefabs = new string[1] { "MineRock_Tin" },
				Biome = (Biome)8,
				Category = PinCategory.Ore,
				DefaultOn = true,
				IsLocation = false
			},
			new Rule
			{
				Name = "Beehives",
				Description = "Wild beehives in the abandoned houses.",
				NameToken = "$piece_beehive",
				Prefabs = new string[1] { "Beehive" },
				Biome = (Biome)8,
				Category = PinCategory.Beehive,
				DefaultOn = true,
				IsLocation = false
			},
			new Rule
			{
				Name = "Blueberry Bushes",
				Description = "Blueberry bushes. Common enough that pinning them fills the map quickly.",
				Prefabs = new string[1] { "BlueberryBush" },
				Biome = (Biome)8,
				Category = PinCategory.Forage,
				DefaultOn = false,
				IsLocation = false
			},
			new Rule
			{
				Name = "Thistle",
				Description = "Thistle, which glows at night and is easier to spot than to pin.",
				Prefabs = new string[1] { "Pickable_Thistle" },
				Biome = (Biome)8,
				Category = PinCategory.Forage,
				DefaultOn = false,
				IsLocation = false
			},
			new Rule
			{
				Name = "Carrot Seeds",
				Description = "Wild carrot seeds. Rare, and the only way to start a carrot farm.",
				Prefabs = new string[1] { "Pickable_SeedCarrot" },
				Biome = (Biome)8,
				Category = PinCategory.Forage,
				DefaultOn = true,
				IsLocation = false
			},
			new Rule
			{
				Name = "Greydwarf Nests",
				Description = "The nests that keep sending greydwarfs at you. Break one for an ancient seed.",
				NameToken = "Greydwarf Nest",
				Prefabs = new string[1] { "Spawner_GreydwarfNest" },
				Biome = (Biome)8,
				Category = PinCategory.Spawner,
				DefaultOn = false,
				IsLocation = false
			},
			new Rule
			{
				Name = "Greydwarf Runestones",
				Description = "Runestones ringed by greydwarf spawners.",
				Prefabs = new string[1] { "Runestone_Greydwarfs" },
				Biome = (Biome)8,
				Category = PinCategory.Spawner,
				DefaultOn = false,
				IsLocation = true
			},
			new Rule
			{
				Name = "Burial Chambers",
				Description = "The entrances to burial chambers, where the surtling cores are.",
				Prefabs = new string[3] { "Crypt2", "Crypt3", "Crypt4" },
				Biome = (Biome)8,
				Category = PinCategory.Dungeon,
				DefaultOn = true,
				IsLocation = true
			},
			new Rule
			{
				Name = "Troll Caves",
				Description = "Troll cave entrances.",
				Prefabs = new string[1] { "TrollCave02" },
				Biome = (Biome)8,
				Category = PinCategory.Dungeon,
				DefaultOn = true,
				IsLocation = true
			},
			new Rule
			{
				Name = "Bear Caves",
				Description = "Bear cave entrances.",
				Prefabs = new string[1] { "BearCave" },
				Biome = (Biome)8,
				Category = PinCategory.Dungeon,
				DefaultOn = true,
				IsLocation = true
			},
			new Rule
			{
				Name = "Mushrooms",
				Description = "Ordinary mushrooms.",
				Prefabs = new string[1] { "Pickable_Mushroom" },
				Biome = (Biome)8,
				Category = PinCategory.Forage,
				DefaultOn = false,
				IsLocation = false
			},
			new Rule
			{
				Name = "Altar of the Elder",
				Description = "Where the Elder is summoned. Off by default: use a vegvisir and the game pins it for you.",
				Prefabs = new string[1] { "GDKing" },
				Biome = (Biome)8,
				Category = PinCategory.Boss,
				DefaultOn = false,
				IsLocation = true
			},
			new Rule
			{
				Name = "Vegvisirs",
				Description = "The runestones that reveal a boss on your map.",
				NameToken = "$piece_vegvisir",
				Prefabs = new string[7] { "Vegvisir_Eikthyr", "Vegvisir_GDKing", "Vegvisir_Bonemass", "Vegvisir_DragonQueen", "Vegvisir_GoblinKing", "Vegvisir_Fader", "Vegvisir_DNBoss" },
				Biome = (Biome)2,
				Category = PinCategory.Vegvisir,
				DefaultOn = true,
				IsLocation = false
			},
			new Rule
			{
				Name = "Turnip Seeds",
				Description = "Wild turnip seeds. Rare, and the only way to start a turnip farm.",
				Prefabs = new string[1] { "Pickable_SeedTurnip" },
				Biome = (Biome)2,
				Category = PinCategory.Forage,
				DefaultOn = true,
				IsLocation = false
			},
			new Rule
			{
				Name = "Thistle",
				Description = "Thistle.",
				Prefabs = new string[1] { "Pickable_Thistle" },
				Biome = (Biome)2,
				Category = PinCategory.Forage,
				DefaultOn = false,
				IsLocation = false
			},
			new Rule
			{
				Name = "Sunken Crypts",
				Description = "The iron doors into the sunken crypts, where the iron scrap is.",
				Prefabs = new string[1] { "SunkenCrypt4" },
				Biome = (Biome)2,
				Category = PinCategory.Dungeon,
				DefaultOn = true,
				IsLocation = true
			},
			new Rule
			{
				Name = "Muddy Scrap Piles",
				Description = "The mud piles you dig for iron scrap. Only inside the crypts, so rarely worth a pin.",
				Prefabs = new string[1] { "mudpile_beacon" },
				Biome = (Biome)2,
				Category = PinCategory.Ore,
				DefaultOn = false,
				IsLocation = false
			},
			new Rule
			{
				Name = "Surtling Fire Holes",
				Description = "The burning holes that keep producing surtlings.",
				Prefabs = new string[1] { "FireHole" },
				Biome = (Biome)2,
				Category = PinCategory.Spawner,
				DefaultOn = false,
				IsLocation = true
			},
			new Rule
			{
				Name = "Draugr Runestones",
				Description = "Runestones ringed by draugr spawners.",
				Prefabs = new string[1] { "Runestone_Draugr" },
				Biome = (Biome)2,
				Category = PinCategory.Spawner,
				DefaultOn = false,
				IsLocation = true
			},
			new Rule
			{
				Name = "Mushrooms",
				Description = "Ordinary mushrooms.",
				Prefabs = new string[1] { "Pickable_Mushroom" },
				Biome = (Biome)2,
				Category = PinCategory.Forage,
				DefaultOn = false,
				IsLocation = false
			},
			new Rule
			{
				Name = "Altar of Bonemass",
				Description = "Where Bonemass is summoned. Off by default: use a vegvisir and the game pins it for you.",
				Prefabs = new string[1] { "Bonemass" },
				Biome = (Biome)2,
				Category = PinCategory.Boss,
				DefaultOn = false,
				IsLocation = true
			},
			new Rule
			{
				Name = "Vegvisirs",
				Description = "The runestones that reveal a boss on your map.",
				NameToken = "$piece_vegvisir",
				Prefabs = new string[7] { "Vegvisir_Eikthyr", "Vegvisir_GDKing", "Vegvisir_Bonemass", "Vegvisir_DragonQueen", "Vegvisir_GoblinKing", "Vegvisir_Fader", "Vegvisir_DNBoss" },
				Biome = (Biome)4,
				Category = PinCategory.Vegvisir,
				DefaultOn = true,
				IsLocation = false
			},
			new Rule
			{
				Name = "Silver Deposits",
				Description = "Silver under the snow. Buried, so a pin is worth more here than anywhere else.",
				Prefabs = new string[1] { "silvervein" },
				Biome = (Biome)4,
				Category = PinCategory.Ore,
				DefaultOn = true,
				IsLocation = false
			},
			new Rule
			{
				Name = "Obsidian Deposits",
				Description = "The black spires you mine for obsidian.",
				Prefabs = new string[1] { "MineRock_Obsidian" },
				Biome = (Biome)4,
				Category = PinCategory.Ore,
				DefaultOn = true,
				IsLocation = false
			},
			new Rule
			{
				Name = "Drake Nests",
				Description = "The nests on the peaks, each holding a dragon egg.",
				Prefabs = new string[1] { "DrakeNest01" },
				Biome = (Biome)4,
				Category = PinCategory.Forage,
				DefaultOn = true,
				IsLocation = true
			},
			new Rule
			{
				Name = "Altar of Moder",
				Description = "Where Moder is summoned. Off by default: use a vegvisir and the game pins it for you.",
				Prefabs = new string[1] { "Dragonqueen" },
				Biome = (Biome)4,
				Category = PinCategory.Boss,
				DefaultOn = false,
				IsLocation = true
			},
			new Rule
			{
				Name = "Vegvisirs",
				Description = "The runestones that reveal a boss on your map.",
				NameToken = "$piece_vegvisir",
				Prefabs = new string[7] { "Vegvisir_Eikthyr", "Vegvisir_GDKing", "Vegvisir_Bonemass", "Vegvisir_DragonQueen", "Vegvisir_GoblinKing", "Vegvisir_Fader", "Vegvisir_DNBoss" },
				Biome = (Biome)16,
				Category = PinCategory.Vegvisir,
				DefaultOn = true,
				IsLocation = false
			},
			new Rule
			{
				Name = "Tar Pits",
				Description = "The black pools, with growths to pick and a nest of tar blobs guarding them.",
				Prefabs = new string[6] { "TarPit1", "TarPit1_1", "TarPit2", "TarPit2_1", "TarPit3", "TarPit3_1" },
				Biome = (Biome)16,
				Category = PinCategory.Tar,
				DefaultOn = true,
				IsLocation = true
			},
			new Rule
			{
				Name = "Fuling Totems",
				Description = "The totem in a fuling village, and the only way to summon Yagluth. Pinned instead of the village around it.",
				Prefabs = new string[1] { "goblin_totempole" },
				Biome = (Biome)16,
				Category = PinCategory.Loot,
				DefaultOn = true,
				IsLocation = false
			},
			new Rule
			{
				Name = "Cloudberry Bushes",
				Description = "Cloudberry bushes.",
				Prefabs = new string[1] { "CloudberryBush" },
				Biome = (Biome)16,
				Category = PinCategory.Forage,
				DefaultOn = false,
				IsLocation = false
			},
			new Rule
			{
				Name = "Altar of Yagluth",
				Description = "Where Yagluth is summoned. Off by default: use a vegvisir and the game pins it for you.",
				Prefabs = new string[1] { "GoblinKing" },
				Biome = (Biome)16,
				Category = PinCategory.Boss,
				DefaultOn = false,
				IsLocation = true
			},
			new Rule
			{
				Name = "Yggdrasil Roots",
				Description = "The hanging roots you tap for sap.",
				Prefabs = new string[1] { "YggdrasilRoot" },
				Biome = (Biome)512,
				Category = PinCategory.Sap,
				DefaultOn = true,
				IsLocation = false
			},
			new Rule
			{
				Name = "Giant Remains",
				Description = "The bones and armour of the fallen giants. Black marble, and iron and copper scrap.",
				NameToken = "Giant Remains",
				Prefabs = new string[5] { "giant_ribs", "giant_helmet1", "giant_helmet2", "giant_sword1", "giant_sword2" },
				Biome = (Biome)512,
				Category = PinCategory.Ore,
				DefaultOn = true,
				IsLocation = false
			},
			new Rule
			{
				Name = "Magecap",
				Description = "The blue glowing mushrooms, for eitr.",
				Prefabs = new string[1] { "Pickable_Mushroom_Magecap" },
				Biome = (Biome)512,
				Category = PinCategory.Forage,
				DefaultOn = false,
				IsLocation = false
			},
			new Rule
			{
				Name = "Jotun Puffs",
				Description = "The pale puffball mushrooms, for eitr.",
				Prefabs = new string[1] { "Pickable_Mushroom_JotunPuffs" },
				Biome = (Biome)512,
				Category = PinCategory.Forage,
				DefaultOn = true,
				IsLocation = false
			},
			new Rule
			{
				Name = "Entrance to the Queen",
				Description = "The way into the infested mine where the Queen waits.",
				Prefabs = new string[1] { "Mistlands_DvergrBossEntrance1" },
				Biome = (Biome)512,
				Category = PinCategory.Dungeon,
				DefaultOn = true,
				IsLocation = true
			},
			new Rule
			{
				Name = "Dvergr Needle Crates",
				Description = "The long crate holding a dvergr needle, which is what a sap extractor is built from. One stands in each guard tower, excavation, harbour and lighthouse.",
				Prefabs = new string[1] { "dvergrprops_crate_long" },
				Biome = (Biome)512,
				Category = PinCategory.Loot,
				DefaultOn = true,
				IsLocation = false
			},
			new Rule
			{
				Name = "Dvergr Excavations",
				Description = "Dvergr dig sites, with crates to break and dvergr who mind you breaking them.",
				Prefabs = new string[3] { "Mistlands_Excavation1", "Mistlands_Excavation2", "Mistlands_Excavation3" },
				Biome = (Biome)512,
				Category = PinCategory.Loot,
				DefaultOn = true,
				IsLocation = true
			},
			new Rule
			{
				Name = "Vegvisirs",
				Description = "The runestones that reveal a boss on your map.",
				NameToken = "$piece_vegvisir",
				Prefabs = new string[7] { "Vegvisir_Eikthyr", "Vegvisir_GDKing", "Vegvisir_Bonemass", "Vegvisir_DragonQueen", "Vegvisir_GoblinKing", "Vegvisir_Fader", "Vegvisir_DNBoss" },
				Biome = (Biome)32,
				Category = PinCategory.Vegvisir,
				DefaultOn = true,
				IsLocation = false
			},
			new Rule
			{
				Name = "Flametal",
				Description = "The flametal in the lava lakes.",
				Prefabs = new string[1] { "LeviathanLava" },
				Biome = (Biome)32,
				Category = PinCategory.Ore,
				DefaultOn = true,
				IsLocation = false
			},
			new Rule
			{
				Name = "Sulfur Arches",
				Description = "The yellow arches you pick for sulfur stone.",
				Prefabs = new string[1] { "SulfurArch" },
				Biome = (Biome)32,
				Category = PinCategory.Ore,
				DefaultOn = true,
				IsLocation = true
			},
			new Rule
			{
				Name = "Unstable Lava Rock",
				Description = "The cracked rocks holding proustite powder.",
				Prefabs = new string[1] { "UnstableLavaRock" },
				Biome = (Biome)32,
				Category = PinCategory.Ore,
				DefaultOn = true,
				IsLocation = false
			},
			new Rule
			{
				Name = "Vineberries",
				Description = "The vines in the charred ruins. Vineberries, which can be replanted.",
				Prefabs = new string[1] { "VineAsh" },
				Biome = (Biome)32,
				Category = PinCategory.Forage,
				DefaultOn = true,
				IsLocation = false
			},
			new Rule
			{
				Name = "Smoke Puffs",
				Description = "The smoking mushrooms.",
				Prefabs = new string[1] { "Pickable_SmokePuff" },
				Biome = (Biome)32,
				Category = PinCategory.Forage,
				DefaultOn = false,
				IsLocation = false
			},
			new Rule
			{
				Name = "Ash Pots",
				Description = "The red clay pots, which break open for bronze and iron.",
				NameToken = "Ash Pot",
				Prefabs = new string[1] { "ashland_pot2_red" },
				Biome = (Biome)32,
				Category = PinCategory.Loot,
				DefaultOn = true,
				IsLocation = false
			},
			new Rule
			{
				Name = "Places of Mystery",
				Description = "Where the pieces of Dyrnwyn are. Three in the world, and no way to finish the sword without them.",
				Prefabs = new string[3] { "PlaceofMystery1", "PlaceofMystery2", "PlaceofMystery3" },
				Biome = (Biome)32,
				Category = PinCategory.Loot,
				DefaultOn = true,
				IsLocation = true
			},
			new Rule
			{
				Name = "Charred Fortresses",
				Description = "The fortresses, holding a molten core, a bell fragment and a great many charred.",
				Prefabs = new string[1] { "CharredFortress" },
				Biome = (Biome)32,
				Category = PinCategory.Dungeon,
				DefaultOn = true,
				IsLocation = true
			},
			new Rule
			{
				Name = "Charred Skulls",
				Description = "Skulls on the ground, picked for charred skull.",
				Prefabs = new string[1] { "Pickable_Charredskull" },
				Biome = (Biome)32,
				Category = PinCategory.Forage,
				DefaultOn = false,
				IsLocation = false
			},
			new Rule
			{
				Name = "Volture Nests",
				Description = "Volture nests, built on asksvin carrion worth picking over.",
				Prefabs = new string[1] { "VoltureNest" },
				Biome = (Biome)32,
				Category = PinCategory.Loot,
				DefaultOn = false,
				IsLocation = true
			},
			new Rule
			{
				Name = "Charred Tower Ruins",
				Description = "Ruined towers with pots and fiddlehead.",
				Prefabs = new string[1] { "CharredTowerRuins1" },
				Biome = (Biome)32,
				Category = PinCategory.Loot,
				DefaultOn = false,
				IsLocation = true
			},
			new Rule
			{
				Name = "Charred Spawner Towers",
				Description = "Ruined towers built around a charred spawner.",
				Prefabs = new string[1] { "CharredTowerRuins3" },
				Biome = (Biome)32,
				Category = PinCategory.Spawner,
				DefaultOn = false,
				IsLocation = true
			},
			new Rule
			{
				Name = "Dvergr Town",
				Description = "The dvergr settlements out on the ash sea.",
				Prefabs = new string[1] { "CharredTowerRuins1_dvergr" },
				Biome = (Biome)32,
				Category = PinCategory.Loot,
				DefaultOn = false,
				IsLocation = true
			},
			new Rule
			{
				Name = "Altar of Fader",
				Description = "Where Fader is summoned. Off by default: use a vegvisir and the game pins it for you.",
				Prefabs = new string[1] { "FaderLocation" },
				Biome = (Biome)32,
				Category = PinCategory.Boss,
				DefaultOn = false,
				IsLocation = true
			},
			new Rule
			{
				Name = "Vegvisirs",
				Description = "The runestones that reveal a boss on your map.",
				NameToken = "$piece_vegvisir",
				Prefabs = new string[7] { "Vegvisir_Eikthyr", "Vegvisir_GDKing", "Vegvisir_Bonemass", "Vegvisir_DragonQueen", "Vegvisir_GoblinKing", "Vegvisir_Fader", "Vegvisir_DNBoss" },
				Biome = (Biome)64,
				Category = PinCategory.Vegvisir,
				DefaultOn = true,
				IsLocation = false
			},
			new Rule
			{
				Name = "Frozen Trolls",
				Description = "The trolls frozen into the ice, mined for gold ore. Needs a black metal pickaxe.",
				Prefabs = new string[2] { "DN_gammeltrollFrac01", "DN_gammeltrollFrac02" },
				Biome = (Biome)64,
				Category = PinCategory.Ore,
				DefaultOn = true,
				IsLocation = true
			},
			new Rule
			{
				Name = "Morkhalla",
				Description = "The black keeps, holding the ancient gemstones.",
				Prefabs = new string[1] { "MorkBorg" },
				Biome = (Biome)64,
				Category = PinCategory.Dungeon,
				DefaultOn = true,
				IsLocation = true
			},
			new Rule
			{
				Name = "Memorial Places",
				Description = "Eleven chests around a runestone and an offering bowl.",
				Prefabs = new string[1] { "NorthMemorialPlace" },
				Biome = (Biome)64,
				Category = PinCategory.Loot,
				DefaultOn = true,
				IsLocation = true
			},
			new Rule
			{
				Name = "Kale Seeds",
				Description = "Wild kale seeds. Rare, and the only way to start a kale farm.",
				Prefabs = new string[1] { "Pickable_SeedKale" },
				Biome = (Biome)64,
				Category = PinCategory.Forage,
				DefaultOn = true,
				IsLocation = false
			},
			new Rule
			{
				Name = "Lingonberry Bushes",
				Description = "Lingonberry bushes.",
				Prefabs = new string[1] { "LingonberryBush" },
				Biome = (Biome)64,
				Category = PinCategory.Forage,
				DefaultOn = false,
				IsLocation = false
			},
			new Rule
			{
				Name = "Snowballs",
				Description = "Snowballs.",
				Prefabs = new string[1] { "Pickable_Snowball" },
				Biome = (Biome)64,
				Category = PinCategory.Forage,
				DefaultOn = false,
				IsLocation = false
			},
			new Rule
			{
				Name = "The Hole",
				Description = "A camp built around a hole in the ice, with real goods in it.",
				Prefabs = new string[1] { "TheHole01" },
				Biome = (Biome)64,
				Category = PinCategory.Loot,
				DefaultOn = false,
				IsLocation = true
			},
			new Rule
			{
				Name = "Leviathans",
				Description = "The sleeping leviathans, mined for chitin. They dive once you start.",
				NameToken = "Leviathan",
				Prefabs = new string[1] { "Leviathan" },
				Biome = (Biome)256,
				Category = PinCategory.Ore,
				DefaultOn = true,
				IsLocation = false
			}
		};
	}
	public static class PinRecord
	{
		private struct Entry
		{
			public PinCategory Category;

			public float X;

			public float Z;
		}

		private const string CustomDataKey = "BetterMap.pinned";

		private const float CellSize = 32f;

		private static readonly Dictionary<long, List<Entry>> _cells = new Dictionary<long, List<Entry>>();

		private static long _world;

		private static bool _loaded;

		private static bool _dirty;

		public static int Count { get; private set; }

		public static bool Has(PinCategory category, Vector3 position, float within)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: 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)
			Load();
			if (!_loaded)
			{
				return false;
			}
			float num = within * within;
			int num2 = Mathf.FloorToInt(position.x / 32f);
			int num3 = Mathf.FloorToInt(position.z / 32f);
			for (int i = -1; i <= 1; i++)
			{
				for (int j = -1; j <= 1; j++)
				{
					if (!_cells.TryGetValue(Key(num2 + i, num3 + j), out List<Entry> value))
					{
						continue;
					}
					foreach (Entry item in value)
					{
						if (item.Category == category)
						{
							float num4 = item.X - position.x;
							float num5 = item.Z - position.z;
							if (num4 * num4 + num5 * num5 <= num)
							{
								return true;
							}
						}
					}
				}
			}
			return false;
		}

		public static void Add(PinCategory category, Vector3 position)
		{
			//IL_0022: 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)
			Load();
			if (_loaded)
			{
				Put(new Entry
				{
					Category = category,
					X = position.x,
					Z = position.z
				});
				Count++;
				_dirty = true;
			}
		}

		public static void Flush()
		{
			if (!_dirty || !_loaded || (Object)(object)Player.m_localPlayer == (Object)null)
			{
				return;
			}
			_dirty = false;
			List<string> list = new List<string>();
			if (Player.m_localPlayer.m_customData.TryGetValue("BetterMap.pinned", out var value) && !string.IsNullOrEmpty(value))
			{
				string[] array = value.Split(new char[1] { '|' });
				foreach (string text in array)
				{
					int num = text.IndexOf(';');
					if (num > 0 && long.TryParse(text.Substring(0, num), NumberStyles.Integer, CultureInfo.InvariantCulture, out var result) && result != _world)
					{
						list.Add(text);
					}
				}
			}
			foreach (List<Entry> value2 in _cells.Values)
			{
				foreach (Entry item in value2)
				{
					string[] obj = new string[4]
					{
						_world.ToString(CultureInfo.InvariantCulture),
						null,
						null,
						null
					};
					int i = (int)item.Category;
					obj[1] = i.ToString(CultureInfo.InvariantCulture);
					float x = item.X;
					obj[2] = x.ToString("0.#", CultureInfo.InvariantCulture);
					x = item.Z;
					obj[3] = x.ToString("0.#", CultureInfo.InvariantCulture);
					list.Add(string.Join(";", obj));
				}
			}
			Player.m_localPlayer.m_customData["BetterMap.pinned"] = string.Join("|", list.ToArray());
		}

		public static void Wipe()
		{
			Load();
			if (_loaded)
			{
				_cells.Clear();
				Count = 0;
				_dirty = true;
				Flush();
				Plugin.Logger.LogInfo((object)"PinRecord: wiped");
			}
		}

		public static void Forget()
		{
			_cells.Clear();
			_loaded = false;
			_dirty = false;
			_world = 0L;
			Count = 0;
		}

		private static void Load()
		{
			if ((Object)(object)Player.m_localPlayer == (Object)null || (Object)(object)ZNet.instance == (Object)null)
			{
				return;
			}
			long worldUID = ZNet.instance.GetWorldUID();
			if (_loaded && _world == worldUID)
			{
				return;
			}
			_cells.Clear();
			_world = worldUID;
			_loaded = true;
			_dirty = false;
			Count = 0;
			if (!Player.m_localPlayer.m_customData.TryGetValue("BetterMap.pinned", out var value) || string.IsNullOrEmpty(value))
			{
				return;
			}
			string[] array = value.Split(new char[1] { '|' });
			for (int i = 0; i < array.Length; i++)
			{
				string[] array2 = array[i].Split(new char[1] { ';' });
				if (array2.Length == 4 && long.TryParse(array2[0], NumberStyles.Integer, CultureInfo.InvariantCulture, out var result) && result == worldUID && int.TryParse(array2[1], NumberStyles.Integer, CultureInfo.InvariantCulture, out var result2) && float.TryParse(array2[2], NumberStyles.Float, CultureInfo.InvariantCulture, out var result3) && float.TryParse(array2[3], NumberStyles.Float, CultureInfo.InvariantCulture, out var result4))
				{
					Put(new Entry
					{
						Category = (PinCategory)result2,
						X = result3,
						Z = result4
					});
					Count++;
				}
			}
			if (Plugin.debugMode.Value)
			{
				Plugin.Logger.LogInfo((object)$"PinRecord: {Count} places already pinned");
			}
		}

		private static void Put(Entry entry)
		{
			long key = Key(Mathf.FloorToInt(entry.X / 32f), Mathf.FloorToInt(entry.Z / 32f));
			if (!_cells.TryGetValue(key, out List<Entry> value))
			{
				value = new List<Entry>();
				_cells[key] = value;
			}
			value.Add(entry);
		}

		private static long Key(int x, int z)
		{
			return ((long)x << 32) ^ (uint)z;
		}
	}
	public static class PinNames
	{
		private static Dictionary<string, PinCategory> _categories;

		private static readonly HashSet<string> Filler = new HashSet<string> { "Stone", "Wood", "RoundLog", "FineWood", "ElderBark", "YggdrasilWood", "Grausten" };

		public static string For(PinRules.Rule rule, GameObject prefab)
		{
			if (!string.IsNullOrEmpty(rule.NameToken))
			{
				return rule.NameToken;
			}
			return For(prefab) ?? rule.Name;
		}

		public static string For(GameObject prefab)
		{
			if ((Object)(object)prefab == (Object)null)
			{
				return null;
			}
			Piece component = prefab.GetComponent<Piece>();
			if ((Object)(object)component != (Object)null && !string.IsNullOrEmpty(component.m_name))
			{
				return component.m_name;
			}
			Pickable component2 = prefab.GetComponent<Pickable>();
			if ((Object)(object)component2?.m_itemPrefab != (Object)null)
			{
				string text = ItemName(component2.m_itemPrefab);
				if (text != null)
				{
					return text;
				}
			}
			MineRock component3 = prefab.GetComponent<MineRock>();
			if ((Object)(object)component3 != (Object)null)
			{
				string text2 = DropName(component3.m_dropItems);
				if (text2 != null)
				{
					return text2;
				}
			}
			MineRock5 component4 = prefab.GetComponent<MineRock5>();
			if ((Object)(object)component4 != (Object)null)
			{
				string text3 = DropName(component4.m_dropItems);
				if (text3 != null)
				{
					return text3;
				}
			}
			DropOnDestroyed component5 = prefab.GetComponent<DropOnDestroyed>();
			if (component5?.m_dropWhenDestroyed != null)
			{
				string text4 = DropName(component5.m_dropWhenDestroyed);
				if (text4 != null)
				{
					return text4;
				}
			}
			Destructible component6 = prefab.GetComponent<Destructible>();
			if ((Object)(object)component6?.m_spawnWhenDestroyed != (Object)null)
			{
				return For(component6.m_spawnWhenDestroyed);
			}
			HoverText component7 = prefab.GetComponent<HoverText>();
			if ((Object)(object)component7 != (Object)null && !string.IsNullOrEmpty(component7.m_text))
			{
				return component7.m_text;
			}
			return null;
		}

		public static bool Category(string name, out PinCategory category)
		{
			Build();
			category = PinCategory.Ore;
			if (!string.IsNullOrEmpty(name) && _categories != null)
			{
				return _categories.TryGetValue(name, out category);
			}
			return false;
		}

		public static void Build()
		{
			if (_categories != null)
			{
				return;
			}
			ZNetScene instance = ZNetScene.instance;
			if ((Object)(object)instance == (Object)null)
			{
				return;
			}
			Dictionary<string, PinCategory> dictionary = new Dictionary<string, PinCategory>();
			foreach (PinRules.Rule item in PinRules.All)
			{
				string[] prefabs = item.Prefabs;
				foreach (string text in prefabs)
				{
					GameObject val = (item.IsLocation ? null : instance.GetPrefab(text));
					if (!((Object)(object)val == (Object)null) || item.IsLocation)
					{
						string key = For(item, val);
						dictionary[key] = item.Category;
					}
				}
			}
			_categories = dictionary;
			if (Plugin.debugMode.Value)
			{
				Plugin.Logger.LogInfo((object)$"PinNames: {dictionary.Count} names known");
			}
		}

		private static string ItemName(GameObject item)
		{
			SharedData val = item.GetComponent<ItemDrop>()?.m_itemData?.m_shared;
			if (!string.IsNullOrEmpty(val?.m_name))
			{
				return val.m_name;
			}
			return null;
		}

		private static string DropName(DropTable table)
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: 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_005c: Unknown result type (might be due to invalid IL or missing references)
			if (table?.m_drops == null)
			{
				return null;
			}
			string text = null;
			foreach (DropData drop in table.m_drops)
			{
				if ((Object)(object)drop.m_item == (Object)null)
				{
					continue;
				}
				string text2 = ItemName(drop.m_item);
				if (text2 != null)
				{
					if (!Filler.Contains(((Object)drop.m_item).name))
					{
						return text2;
					}
					if (text == null)
					{
						text = text2;
					}
				}
			}
			return text;
		}
	}
	public static class AutoPins
	{
		private class Watch
		{
			public readonly List<PinRules.Rule> Rules = new List<PinRules.Rule>();

			public PinCategory? Shared;

			public bool IsLocation;
		}

		private static readonly FieldRef<ZNetScene, Dictionary<ZDO, ZNetView>> Instances = AccessTools.FieldRefAccess<ZNetScene, Dictionary<ZDO, ZNetView>>("m_instances");

		private static Dictionary<int, Watch> _byPrefab;

		private static Dictionary<int, Watch> _byLocation;

		private static int _proxyHash;

		private static float _nextSweep;

		private static bool _forgotten;

		public static void Tick()
		{
			if (!Plugin.autoPin.Value || (Object)(object)Minimap.instance == (Object)null || (Object)(object)Player.m_localPlayer == (Object)null || (Object)(object)ZNetScene.instance == (Object)null || Time.time < _nextSweep)
			{
				return;
			}
			_nextSweep = Time.time + Plugin.autoPinInterval.Value;
			Build();
			if (_byPrefab.Count != 0 || _byLocation.Count != 0)
			{
				if (_proxyHash == 0 && (Object)(object)ZoneSystem.instance != (Object)null && (Object)(object)ZoneSystem.instance.m_locationProxyPrefab != (Object)null)
				{
					_proxyHash = StringExtensionMethods.GetStableHashCode(((Object)ZoneSystem.instance.m_locationProxyPrefab).name);
				}
				if (Plugin.forgetPinned.Value && !_forgotten)
				{
					_forgotten = true;
					PinRecord.Wipe();
				}
				Sweep();
				PinRecord.Flush();
			}
		}

		private static void Sweep()
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_0118: Unknown result type (might be due to invalid IL or missing references)
			//IL_011a: Unknown result type (might be due to invalid IL or missing references)
			//IL_011f: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_013f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0144: Unknown result type (might be due to invalid IL or missing references)
			//IL_016f: Unknown result type (might be due to invalid IL or missing references)
			//IL_019c: Unknown result type (might be due to invalid IL or missing references)
			Vector3 position = ((Component)Player.m_localPlayer).transform.position;
			float value = Plugin.explorationRadius.Value;
			float num = value * value;
			float value2 = Plugin.autoPinMergeDistance.Value;
			foreach (KeyValuePair<ZDO, ZNetView> item in Instances.Invoke(ZNetScene.instance))
			{
				ZDO key = item.Key;
				if (key == null || !key.IsValid())
				{
					continue;
				}
				int prefab = key.GetPrefab();
				if (PortalPins.IsPortal(prefab))
				{
					Portal(key, position, num, value2);
					continue;
				}
				Watch value3;
				if (prefab == _proxyHash)
				{
					if (!_byLocation.TryGetValue(key.GetInt(ZDOVars.s_location, 0), out value3))
					{
						continue;
					}
				}
				else if (!_byPrefab.TryGetValue(prefab, out value3))
				{
					continue;
				}
				Vector3 position2 = key.GetPosition();
				Vector3 val = position2 - position;
				if (((Vector3)(ref val)).sqrMagnitude > num || (value3.Shared.HasValue && PinRecord.Has(value3.Shared.Value, position2, value2)))
				{
					continue;
				}
				Biome val2 = Heightmap.FindBiome(position2);
				foreach (PinRules.Rule rule in value3.Rules)
				{
					if (rule.Biome == val2 && rule.Enabled != null && rule.Enabled.Value)
					{
						if (!PinRecord.Has(rule.Category, position2, value2))
						{
							Place(rule, value3.IsLocation ? null : item.Value, position2);
						}
						break;
					}
				}
			}
		}

		private unsafe static void Portal(ZDO zdo, Vector3 origin, float rangeSqr, float merge)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: 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_0042: 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_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Expected O, but got Unknown
			//IL_0073: 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)
			if (!Plugin.autoPinPortals.Value)
			{
				return;
			}
			Vector3 position = zdo.GetPosition();
			Vector3 val = position - origin;
			if (!(((Vector3)(ref val)).sqrMagnitude > rangeSqr) && !PinRecord.Has(PinCategory.Portal, position, merge))
			{
				PinData val2 = Minimap.instance.AddPin(position, PortalPins.PinType, PortalPins.Label(PortalPins.TagOf(zdo)), true, false, 0L, default(PlatformUserID));
				val2.m_NamePinData = new PinNameData(val2);
				PinRecord.Add(PinCategory.Portal, position);
				if (Plugin.debugMode.Value)
				{
					ManualLogSource logger = Plugin.Logger;
					val = position;
					logger.LogInfo((object)("AutoPins: portal at " + ((object)(*(Vector3*)(&val))/*cast due to .constrained prefix*/).ToString() + " as " + val2.m_name));
				}
			}
		}

		private static void Place(PinRules.Rule rule, ZNetView nview, Vector3 position)
		{
			//IL_0024: 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_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: 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_007f: Expected O, but got Unknown
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			string text = PinNames.For(rule, ((Object)(object)nview != (Object)null) ? ((Component)nview).gameObject : null);
			PinData val = Minimap.instance.AddPin(position, PinLegend.TypeOf(rule.Category), text, true, false, 0L, default(PlatformUserID));
			Sprite val2 = Icons.For(rule.Category);
			if ((Object)(object)val2 != (Object)null)
			{
				val.m_icon = val2;
			}
			if (!string.IsNullOrEmpty(val.m_name))
			{
				val.m_NamePinData = new PinNameData(val);
			}
			PinRecord.Add(rule.Category, position);
			if (Plugin.debugMode.Value)
			{
				Plugin.Logger.LogInfo((object)$"AutoPins: {rule.Name} ({rule.Category}) at {position} as \"{val.m_name}\"");
			}
		}

		public static void Restore()
		{
			//IL_0046: 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_005e: Invalid comparison between Unknown and I4
			if ((Object)(object)Minimap.instance == (Object)null || (Object)(object)ZNetScene.instance == (Object)null)
			{
				return;
			}
			PinNames.Build();
			int num = 0;
			foreach (PinData item in MapPins.Of(Minimap.instance))
			{
				if (PinLegend.CategoryOf(item.m_type, out var category) || ((int)item.m_type == 3 && PinNames.Category(item.m_name, out category)))
				{
					Sprite val = Icons.For(category);
					if (!((Object)(object)val == (Object)null) && !((Object)(object)item.m_icon == (Object)(object)val))
					{
						item.m_icon = val;
						num++;
					}
				}
			}
			if (num > 0 && Plugin.debugMode.Value)
			{
				Plugin.Logger.LogInfo((object)$"AutoPins: {num} icons put back");
			}
		}

		private static void Build()
		{
			if (_byPrefab != null)
			{
				return;
			}
			_byPrefab = new Dictionary<int, Watch>();
			_byLocation = new Dictionary<int, Watch>();
			foreach (PinRules.Rule item in PinRules.All)
			{
				Dictionary<int, Watch> dictionary = (item.IsLocation ? _byLocation : _byPrefab);
				string[] prefabs = item.Prefabs;
				for (int i = 0; i < prefabs.Length; i++)
				{
					int stableHashCode = StringExtensionMethods.GetStableHashCode(prefabs[i]);
					if (!dictionary.TryGetValue(stableHashCode, out var value))
					{
						value = (dictionary[stableHashCode] = new Watch
						{
							IsLocation = item.IsLocation
						});
					}
					value.Rules.Add(item);
				}
			}
			foreach (Watch value2 in _byPrefab.Values)
			{
				value2.Shared = value2.Rules[0].Category;
				foreach (PinRules.Rule rule in value2.Rules)
				{
					if (rule.Category != value2.Shared)
					{
						value2.Shared = null;
					}
				}
			}
			foreach (Watch value3 in _byLocation.Values)
			{
				value3.Shared = value3.Rules[0].Category;
				foreach (PinRules.Rule rule2 in value3.Rules)
				{
					if (rule2.Category != value3.Shared)
					{
						value3.Shared = null;
					}
				}
			}
			Verify();
			if (Plugin.debugMode.Value)
			{
				Plugin.Logger.LogInfo((object)$"AutoPins: watching {_byPrefab.Count} prefabs and {_byLocation.Count} places");
			}
		}

		private static void Verify()
		{
			ZNetScene instance = ZNetScene.instance;
			ZoneSystem instance2 = ZoneSystem.instance;
			foreach (PinRules.Rule item in PinRules.All)
			{
				string[] prefabs = item.Prefabs;
				foreach (string text in prefabs)
				{
					if (item.IsLocation)
					{
						if ((Object)(object)instance2 == (Object)null || instance2.m_locations == null)
						{
							continue;
						}
						bool flag = false;
						foreach (ZoneLocation location in instance2.m_locations)
						{
							if (location != null && location.m_prefabName == text)
							{
								flag = true;
								break;
							}
						}
						if (!flag)
						{
							Plugin.Logger.LogWarning((object)("AutoPins: \"" + item.Name + "\" watches a place named " + text + ", which this game has none of. Nothing will ever be pinned for it."));
						}
					}
					else if ((Object)(object)instance != (Object)null && (Object)(object)instance.GetPrefab(text) == (Object)null)
					{
						Plugin.Logger.LogWarning((object)("AutoPins: \"" + item.Name + "\" watches a prefab named " + text + ", which this game has none of. Nothing will ever be pinned for it."));
					}
				}
			}
		}
	}
	public static class PortalPins
	{
		private static readonly FieldRef<Minimap, List<SpriteData>> Icons = AccessTools.FieldRefAccess<Minimap, List<SpriteData>>("m_icons");

		private static PinType _type = (PinType)6;

		private static bool _typeFound;

		private static HashSet<int> _prefabs;

		public static PinType PinType => _type;

		public static string Label(string tag)
		{
			if (!string.IsNullOrEmpty(tag))
			{
				return tag;
			}
			return "$piece_portal";
		}

		public static bool IsPortal(int prefab)
		{
			if (_prefabs == null)
			{
				ZNetScene instance = ZNetScene.instance;
				if ((Object)(object)instance == (Object)null || instance.m_prefabs == null)
				{
					return false;
				}
				_prefabs = new HashSet<int>();
				foreach (GameObject prefab2 in instance.m_prefabs)
				{
					if (!((Object)(object)prefab2 == (Object)null) && !((Object)(object)prefab2.GetComponent<TeleportWorld>() == (Object)null))
					{
						_prefabs.Add(StringExtensionMethods.GetStableHashCode(((Object)prefab2).name));
					}
				}
				FindPinType();
			}
			return _prefabs.Contains(prefab);
		}

		private static void FindPinType()
		{
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			if (_typeFound || (Object)(object)Minimap.instance == (Object)null)
			{
				return;
			}
			_typeFound = true;
			foreach (SpriteData item in Icons.Invoke(Minimap.instance))
			{
				if (!((Object)(object)item.m_icon == (Object)null) && ((Object)item.m_icon).name.IndexOf("portal", StringComparison.OrdinalIgnoreCase) >= 0)
				{
					_type = item.m_name;
					if (Plugin.debugMode.Value)
					{
						Plugin.Logger.LogInfo((object)$"PortalPins: portals go on {_type}, drawn as {((Object)item.m_icon).name}");
					}
					return;
				}
			}
			Plugin.Logger.LogWarning((object)$"PortalPins: no pin type is drawn with a portal, so portals will use {_type}. Their icon will be whatever that type carries.");
		}

		public static string TagOf(ZDO zdo)
		{
			return zdo.GetString(ZDOVars.s_tag, "");
		}
	}
	public static class PinLegend
	{
		private static readonly PinCategory[] Ours = new PinCategory[9]
		{
			PinCategory.Ore,
			PinCategory.Forage,
			PinCategory.Dungeon,
			PinCategory.Loot,
			PinCategory.Spawner,
			PinCategory.Vegvisir,
			PinCategory.Beehive,
			PinCategory.Tar,
			PinCategory.Sap
		};

		private const float Margin = 10f;

		private const float Gap = 6f;

		private static readonly FieldRef<Minimap, bool[]> VisibleIconTypes = AccessTools.FieldRefAccess<Minimap, bool[]>("m_visibleIconTypes");

		private static readonly FieldRef<Minimap, Dictionary<PinType, Image>> SelectedIcons = AccessTools.FieldRefAccess<Minimap, Dictionary<PinType, Image>>("m_selectedIcons");

		private static readonly Dictionary<PinCategory, PinType> _types = new Dictionary<PinCategory, PinType>();

		private static readonly Dictionary<PinType, PinCategory> _categories = new Dictionary<PinType, PinCategory>();

		private static Minimap _builtInto;

		private static readonly Action<Minimap, PinType> IconPressed = AccessTools.MethodDelegate<Action<Minimap, PinType>>(AccessTools.Method(typeof(Minimap), "IconPressed", (Type[])null, (Type[])null), (object)null, false);

		private static readonly Action<Minimap, PinType> ToggleIconFilter = AccessTools.MethodDelegate<Action<Minimap, PinType>>(AccessTools.Method(typeof(Minimap), "ToggleIconFilter", (Type[])null, (Type[])null), (object)null, false);

		public static PinType CreatureType { get; private set; } = (PinType)3;

		public static PinType VehicleType { get; private set; } = (PinType)0;

		public static PinType TypeOf(PinCategory category)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			if (!_types.TryGetValue(category, out var value))
			{
				return (PinType)3;
			}
			return value;
		}

		public static bool CategoryOf(PinType type, out PinCategory category)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			return _categories.TryGetValue(type, out category);
		}

		public static void Install()
		{
			Minimap instance = Minimap.instance;
			if ((Object)(object)instance == (Object)null || (Object)(object)_builtInto == (Object)(object)instance)
			{
				return;
			}
			_builtInto = instance;
			_types.Clear();
			_categories.Clear();
			CreatureType = (PinType)3;
			VehicleType = (PinType)0;
			try
			{
				Build(instance);
			}
			catch (Exception arg)
			{
				Plugin.Logger.LogError((object)$"PinLegend: could not add our pins to the legend, they will share a plain pin instead: {arg}");
				_types.Clear();
				_categories.Clear();
			}
		}

		private static void Build(Minimap map)
		{
			//IL_00b1: 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_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_0108: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0118: Unknown result type (might be due to invalid IL or missing references)
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_013f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0144: Unknown result type (might be due to invalid IL or missing references)
			//IL_014b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0150: Unknown result type (might be due to invalid IL or missing references)
			//IL_0161: Unknown result type (might be due to invalid IL or missing references)
			//IL_016d: Unknown result type (might be due to invalid IL or missing references)
			RectTransform val = Parent(map.m_selectedIcon4);
			RectTransform val2 = Parent(map.m_selectedIcon0);
			if ((Object)(object)val == (Object)null || (Object)(object)val2 == (Object)null || (Object)(object)((Transform)val).parent == (Object)null)
			{
				Plugin.Logger.LogWarning((object)"PinLegend: the map legend does not look the way it used to, leaving it alone");
				return;
			}
			Transform parent = ((Transform)val).parent;
			RectTransform val3 = (RectTransform)(object)((parent is RectTransform) ? parent : null);
			RectTransform val4 = Parent(map.m_selectedIconDeath);
			RectTransform extras = (RectTransform)(((Object)(object)val4 != (Object)null) ? /*isinst with value type is only supported in some contexts*/: null);
			int length = Enum.GetValues(typeof(PinType)).Length;
			Grow(map, length + Ours.Length + 2);
			Vector2 val5 = Step(map);
			Stretch(val3, val5, 5 + Ours.Length);
			for (int i = 0; i < Ours.Length; i++)
			{
				PinCategory pinCategory = Ours[i];
				PinType val6 = (PinType)(length + i);
				Sprite val7 = Icons.For(pinCategory);
				if (!((Object)(object)val7 == (Object)null))
				{
					map.m_icons.Add(new SpriteData
					{
						m_name = val6,
						m_icon = val7
					});
					RectTransform val8 = Clone(map, (Transform)(object)val, (Transform)(object)val3, val6, val7, pinCategory);
					if (!((Object)(object)val8 == (Object)null))
					{
						val8.anchoredPosition = val2.anchoredPosition + val5 * (float)(5 + i);
						_types[pinCategory] = val6;
						_categories[val6] = pinCategory;
					}
				}
			}
			Unlisted(map, length + Ours.Length);
			Arrange(map, val3, extras);
			Plugin.Logger.LogInfo((object)$"PinLegend: {_types.Count} of our pins added to the legend");
		}

		private static void Arrange(Minimap map, RectTransform vanilla, RectTransform extras)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: 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_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0102: Unknown result type (might be due to invalid IL or missing references)
			//IL_0117: Unknown result type (might be due to invalid IL or missing references)
			//IL_015b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0170: Unknown result type (might be due to invalid IL or missing references)
			//IL_0185: Unknown result type (might be due to invalid IL or missing references)
			//IL_019a: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)vanilla == (Object)null))
			{
				Anchor(vanilla, new Vector2(1f, 0.5f), new Vector2(1f, 0.5f));
				vanilla.anchoredPosition = new Vector2(-10f, 0f);
				if ((Object)(object)extras != (Object)null)
				{
					Anchor(extras, new Vector2(1f, 0.5f), new Vector2(1f, 1f));
					Rect rect = vanilla.rect;
					float num = -10f - ((Rect)(ref rect)).width - 6f;
					rect = vanilla.rect;
					extras.anchoredPosition = new Vector2(num, ((Rect)(ref rect)).height / 2f);
				}
				RectTransform val = (RectTransform)(((Object)(object)map.m_publicPosition != (Object)null) ? /*isinst with value type is only supported in some contexts*/: null);
				if ((Object)(object)val != (Object)null)
				{
					Anchor(val, new Vector2(1f, 0f), new Vector2(1f, 0f));
					val.anchoredPosition = new Vector2(-10f, 10f);
				}
				RectTransform val2 = (((Object)(object)map.m_biomeNameLarge != (Object)null) ? map.m_biomeNameLarge.rectTransform : null);
				if ((Object)(object)val2 != (Object)null)
				{
					val2.anchorMin = new Vector2(0.5f, 1f);
					val2.anchorMax = new Vector2(0.5f, 1f);
					val2.pivot = new Vector2(0.5f, 1f);
					val2.anchoredPosition = new Vector2(0f, -10f);
					map.m_biomeNameLarge.alignment = (TextAlignmentOptions)258;
				}
			}
		}

		private static void Anchor(RectTransform rect, Vector2 anchor, Vector2 pivot)
		{
			//IL_0001: 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_000f: Unknown result type (might be due to invalid IL or missing references)
			rect.anchorMin = anchor;
			rect.anchorMax = anchor;
			rect.pivot = pivot;
		}

		private static void Unlisted(Minimap map, int first)
		{
			//IL_0028: 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_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			Sprite icon = map.m_icons.Find((SpriteData x) => (int)x.m_name == 3).m_icon;
			CreatureType = (PinType)first;
			VehicleType = (PinType)(first + 1);
			map.m_icons.Add(new SpriteData
			{
				m_name = CreatureType,
				m_icon = icon
			});
			map.m_icons.Add(new SpriteData
			{
				m_name = VehicleType,
				m_icon = icon
			});
		}

		private static void Stretch(RectTransform panel, Vector2 step, int slots)
		{
			//IL_000d: 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_002b: 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_004e: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)panel == (Object)null))
			{
				float num = Mathf.Abs(step.y);
				if (!(num <= 0f))
				{
					Rect rect = panel.rect;
					float num2 = ((Rect)(ref rect)).height - num * 5f;
					panel.sizeDelta = new Vector2(panel.sizeDelta.x, num * (float)slots + num2);
				}
			}
		}

		private static void Grow(Minimap map, int length)
		{
			bool[] array = VisibleIconTypes.Invoke(map);
			if (array == null || array.Length < length)
			{
				bool[] array2 = new bool[length];
				for (int i = 0; i < array2.Length; i++)
				{
					array2[i] = array == null || i >= array.Length || array[i];
				}
				VisibleIconTypes.Invoke(map) = array2;
			}
		}

		private static Vector2 Step(Minimap map)
		{
			//IL_003a: 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: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			RectTransform val = Parent(map.m_selectedIcon3);
			RectTransform val2 = Parent(map.m_selectedIcon4);
			if ((Object)(object)val == (Object)null || (Object)(object)val2 == (Object)null)
			{
				return new Vector2(0f, -56f);
			}
			return val2.anchoredPosition - val.anchoredPosition;
		}

		private static RectTransform Clone(Minimap map, Transform template, Transform panel, PinType type, Sprite sprite, PinCategory category)
		{
			//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_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Expected O, but got Unknown
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Expected O, but got Unknown
			//IL_0129: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)panel == (Object)null)
			{
				return null;
			}
			GameObject obj = Object.Instantiate<GameObject>(((Component)template).gameObject, panel);
			((Object)obj).name = "BetterMap_" + category;
			Image component = obj.GetComponent<Image>();
			if ((Object)(object)component != (Object)null)
			{
				component.sprite = sprite;
			}
			Button component2 = obj.GetComponent<Button>();
			if ((Object)(object)component2 != (Object)null)
			{
				Silence((UnityEventBase)(object)component2.onClick);
				((UnityEvent)component2.onClick).AddListener((UnityAction)delegate
				{
					//IL_0001: Unknown result type (might be due to invalid IL or missing references)
					Pressed(type);
				});
			}
			MouseClick component3 = obj.GetComponent<MouseClick>();
			if ((Object)(object)component3 != (Object)null)
			{
				Silence((UnityEventBase)(object)component3.m_leftClick);
				Silence((UnityEventBase)(object)component3.m_middleClick);
				Silence((UnityEventBase)(object)component3.m_rightClick);
				component3.m_rightClick.AddListener((UnityAction)delegate
				{
					//IL_0001: Unknown result type (might be due to invalid IL or missing references)
					Filter(type);
				});
			}
			Transform val = obj.transform.Find("Selected");
			if ((Object)(object)val != (Object)null)
			{
				Image component4 = ((Component)val).GetComponent<Image>();
				if ((Object)(object)component4 != (Object)null)
				{
					((Behaviour)component4).enabled = false;
					SelectedIcons.Invoke(map)[type] = component4;
				}
			}
			Transform transform = obj.transform;
			return (RectTransform)(object)((transform is RectTransform) ? transform : null);
		}

		private static RectTransform Parent(Image image)
		{
			if (!((Object)(object)image != (Object)null))
			{
				return null;
			}
			Transform parent = ((Component)image).transform.parent;
			return (RectTransform)(object)((parent is RectTransform) ? parent : null);
		}

		private static void Silence(UnityEventBase e)
		{
			for (int i = 0; i < e.GetPersistentEventCount(); i++)
			{
				e.SetPersistentListenerState(i, (UnityEventCallState)0);
			}
		}

		private static void Pressed(PinType type)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)Minimap.instance != (Object)null)
			{
				IconPressed(Minimap.instance, type);
			}
		}

		private static void Filter(PinType type)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)Minimap.instance != (Object)null)
			{
				ToggleIconFilter(Minimap.instance, type);
			}
		}
	}
	public static class NamedPins
	{
		private static readonly FieldRef<Minimap, Dictionary<Vector3, PinData>> LocationPins = AccessTools.FieldRefAccess<Minimap, Dictionary<Vector3, PinData>>("m_locationPins");

		private static readonly Dictionary<string, string> Occupants = new Dictionary<string, string>
		{
			{ "Vendor_BlackForest", "$npc_haldor" },
			{ "Hildir_camp", "$npc_hildir" },
			{ "BogWitch_Camp", "$npc_bogwitch" }
		};

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

		public static void RevealTraders(ZoneSystem zones, Dictionary<Vector3, string> icons)
		{
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			if (!Plugin.revealTraders.Value || (Object)(object)ZNet.instance == (Object)null || !ZNet.instance.IsServer() || zones.m_locationInstances == null)
			{
				return;
			}
			foreach (LocationInstance value in zones.m_locationInstances.Values)
			{
				ZoneLocation location = value.m_location;
				if (location != null && Occupants.ContainsKey(location.m_prefabName))
				{
					icons[value.m_position] = location.m_prefab.Name;
				}
			}
		}

		public static void NameLocationPins()
		{
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Expected O, but got Unknown
			if (!Plugin.nameTraderPins.Value || (Object)(object)Minimap.instance == (Object)null || (Object)(object)ZoneSystem.instance == (Object)null)
			{
				return;
			}
			Dictionary<Vector3, PinData> dictionary = LocationPins.Invoke(Minimap.instance);
			if (dictionary.Count == 0)
			{
				return;
			}
			_icons.Clear();
			ZoneSystem.instance.GetLocationIcons(_icons);
			foreach (KeyValuePair<Vector3, PinData> item in dictionary)
			{
				PinData value = item.Value;
				if (value != null && string.IsNullOrEmpty(value.m_name) && _icons.TryGetValue(item.Key, out string value2) && Occupants.TryGetValue(value2, out string value3))
				{
					value.m_name = value3;
					value.m_NamePinData = new PinNameData(value);
					MapPins.RequestRedraw();
				}
			}
		}

		public static void Retag(Vector3 position, string tag)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Expected O, but got Unknown
			Minimap instance = Minimap.instance;
			if ((Object)(object)instance == (Object)null)
			{
				return;
			}
			PinType pinType = PortalPins.PinType;
			PinData val = null;
			float num = float.MaxValue;
			foreach (PinData item in MapPins.Of(instance))
			{
				if (item.m_type == pinType)
				{
					Vector3 val2 = item.m_pos - position;
					float sqrMagnitude = ((Vector3)(ref val2)).sqrMagnitude;
					if (!(sqrMagnitude > 4f) && !(sqrMagnitude >= num))
					{
						num = sqrMagnitude;
						val = item;
					}
				}
			}
			if (val != null)
			{
				instance.RemovePin(val);
				PinData obj = instance.AddPin(val.m_pos, pinType, PortalPins.Label(tag), true, false, 0L, default(PlatformUserID));
				obj.m_NamePinData = new PinNameData(obj);
				if (Plugin.debugMode.Value)
				{
					Plugin.Logger.LogInfo((object)("NamedPins: portal renamed to \"" + tag + "\""));
				}
			}
		}
	}
	[HarmonyPatch]
	public static class NamedPinPatches
	{
		[HarmonyPostfix]
		[HarmonyPatch(typeof(ZoneSystem), "GetLocationIcons")]
		private static void ZoneSystem_GetLocationIcons_Postfix(ZoneSystem __instance, Dictionary<Vector3, string> icons)
		{
			NamedPins.RevealTraders(__instance, icons);
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(Minimap), "UpdateLocationPins")]
		private static void Minimap_UpdateLocationPins_Postfix()
		{
			NamedPins.NameLocationPins();
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(TeleportWorld), "SetText")]
		private static void TeleportWorld_SetText_Postfix(TeleportWorld __instance, string text)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			if (Plugin.autoPinPortals.Value)
			{
				NamedPins.Retag(((Component)__instance).transform.position, text);
			}
		}
	}
}
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[ServerSync.Embedded]
	internal sealed class ServerSync.EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[ServerSync.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class ServerSync.NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

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

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

		public ServerSync.NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
	[CompilerGenerated]
	[ServerSync.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 ServerSync
{
	[ServerSync.NullableContext(1)]
	[ServerSync.Nullable(0)]
	[PublicAPI]
	public abstract class OwnConfigEntryBase
	{
		[ServerSync.Nullable(2)]
		public object LocalBaseValue;

		public bool SynchronizedConfig = true;

		public abstract ConfigEntryBase BaseConfig { get; }
	}
	[ServerSync.NullableContext(1)]
	[ServerSync.Nullable(0)]
	[PublicAPI]
	public class SyncedConfigEntry<[ServerSync.Nullable(2)] T>(ConfigEntry<T> sourceConfig) : OwnConfigEntryBase()
	{
		public readonly ConfigEntry<T> SourceConfig = sourceConfig;

		public override ConfigEntryBase BaseConfig => (ConfigEntryBase)(object)SourceConfig;

		public T Value
		{
			get
			{
				return SourceConfig.Value;
			}
			set
			{
				SourceConfig.Value = value;
			}
		}

		public void AssignLocalValue(T value)
		{
			if (LocalBaseValue == null)
			{
				Value = value;
			}
			else
			{
				LocalBaseValue = value;
			}
		}
	}
	[ServerSync.NullableContext(2)]
	[ServerSync.Nullable(0)]
	public abstract class CustomSyncedValueBase
	{
		public object LocalBaseValue;

		[ServerSync.Nullable(1)]
		public readonly string Identifier;

		[ServerSync.Nullable(1)]
		public readonly Type Type;

		private object boxedValue;

		protected bool localIsOwner;

		public readonly int Priority;

		public object BoxedValue
		{
			get
			{
				return boxedValue;
			}
			set
			{
				boxedValue = value;
				this.ValueChanged?.Invoke();
			}
		}

		public event Action ValueChanged;

		[ServerSync.NullableContext(1)]
		protected CustomSyncedValueBase(ConfigSync configSync, string identifier, Type type, int priority)
		{
			Priority = priority;
			Identifier = identifier;
			Type = type;
			configSync.AddCustomValue(this);
			localIsOwner = configSync.IsSourceOfTruth;
			configSync.SourceOfTruthChanged += delegate(bool truth)
			{
				localIsOwner = truth;
			};
		}
	}
	[ServerSync.NullableContext(1)]
	[ServerSync.Nullable(0)]
	[PublicAPI]
	public sealed class CustomSyncedValue<[ServerSync.Nullable(2)] T> : CustomSyncedValueBase
	{
		public T Value
		{
			get
			{
				return (T)base.BoxedValue;
			}
			set
			{
				base.BoxedValue = value;
			}
		}

		public CustomSyncedValue(ConfigSync configSync, string identifier, T value = default(T), int priority = 0)
			: base(configSync, identifier, typeof(T), priority)
		{
			Value = value;
		}

		public void AssignLocalValue(T value)
		{
			if (localIsOwner)
			{
				Value = value;
			}
			else
			{
				LocalBaseValue = value;
			}
		}
	}
	internal class ConfigurationManagerAttributes
	{
		[UsedImplicitly]
		public bool? ReadOnly = false;
	}
	[ServerSync.NullableContext(1)]
	[ServerSync.Nullable(0)]
	[PublicAPI]
	public class ConfigSync
	{
		[ServerSync.NullableContext(0)]
		[HarmonyPatch(typeof(ZRpc), "HandlePackage")]
		private static class SnatchCurrentlyHandlingRPC
		{
			[ServerSync.Nullable(2)]
			public static ZRpc currentRpc;

			[ServerSync.NullableContext(1)]
			[HarmonyPrefix]
			private static void Prefix(ZRpc __instance)
			{
				currentRpc = __instance;
			}
		}

		[ServerSync.NullableContext(0)]
		[HarmonyPatch(typeof(ZNet), "Awake")]
		internal static class RegisterRPCPatch
		{
			[ServerSync.NullableContext(1)]
			[HarmonyPostfix]
			private static void Postfix(ZNet __instance)
			{
				isServer = __instance.IsServer();
				foreach (ConfigSync configSync2 in configSyncs)
				{
					ZRoutedRpc.instance.Register<ZPackage>(configSync2.Name + " ConfigSync", (Action<long, ZPackage>)configSync2.RPC_FromOtherClientConfigSync);
					if (isServer)
					{
						configSync2.InitialSyncDone = true;
						Debug.Log((object)("Registered '" + configSync2.Name + " ConfigSync' RPC - waiting for incoming connections"));
					}
				}
				if (isServer)
				{
					((MonoBehaviour)__instance).StartCoroutine(WatchAdminListChanges());
				}
				[ServerSync.NullableContext(1)]
				static void SendAdmin(List<ZNetPeer> peers, bool isAdmin)
				{
					ZPackage package = ConfigsToPackage(null, null, new PackageEntry[1]
					{
						new PackageEntry
						{
							section = "Internal",
							key = "lockexempt",
							type = typeof(bool),
							value = isAdmin
						}
					});
					ConfigSync configSync = configSyncs.First();
					if (configSync != null)
					{
						((MonoBehaviour)ZNet.instance).StartCoroutine(configSync.sendZPackage(peers, package));
					}
				}
				[ServerSync.NullableContext(1)]
				static IEnumerator WatchAdminListChanges()
				{
					MethodInfo listContainsId = AccessTools.DeclaredMethod(typeof(ZNet), "ListContainsId", (Type[])null, (Type[])null);
					SyncedList adminList = (SyncedList)AccessTools.DeclaredField(typeof(ZNet), "m_adminList").GetValue(ZNet.instance);
					List<string> CurrentList = new List<string>(adminList.GetList());
					while (true)
					{
						yield return (object)new WaitForSeconds(30f);
						if (!adminList.GetList().SequenceEqual(CurrentList))
						{
							CurrentList = new List<string>(adminList.GetList());
							List<ZNetPeer> adminPeer = ZNet.instance.GetPeers().Where(delegate(ZNetPeer p)
							{
								string hostName = p.m_rpc.GetSocket().GetHostName();
								return ((object)listContainsId == null) ? adminList.Contains(hostName) : ((bool)listContainsId.Invoke(ZNet.instance, new object[2] { adminList, hostName }));
							}).ToList();
							List<ZNetPeer> nonAdminPeer = ZNet.instance.GetPeers().Except(adminPeer).ToList();
							SendAdmin(nonAdminPeer, isAdmin: false);
							SendAdmin(adminPeer, isAdmin: true);
						}
					}
				}
			}
		}

		[ServerSync.NullableContext(0)]
		[HarmonyPatch(typeof(ZNet), "OnNewConnection")]
		private static class RegisterClientRPCPatch
		{
			[ServerSync.NullableContext(1)]
			[HarmonyPostfix]
			private static void Postfix(ZNet __instance, ZNetPeer peer)
			{
				if (__instance.IsServer())
				{
					return;
				}
				foreach (ConfigSync configSync in configSyncs)
				{
					peer.m_rpc.Register<ZPackage>(configSync.Name + " ConfigSync", (Action<ZRpc, ZPackage>)configSync.RPC_FromServerConfigSync);
				}
			}
		}

		[ServerSync.NullableContext(0)]
		private class ParsedConfigs
		{
			[ServerSync.Nullable(new byte[] { 1, 1, 2 })]
			public readonly Dictionary<OwnConfigEntryBase, object> configValues = new Dictionary<OwnConfigEntryBase, object>();

			[ServerSync.Nullable(new byte[] { 1, 1, 2 })]
			public readonly Dictionary<CustomSyncedValueBase, object> customValues = new Dictionary<CustomSyncedValueBase, object>();
		}

		[ServerSync.NullableContext(0)]
		[HarmonyPatch(typeof(ZNet), "Shutdown")]
		private class ResetConfigsOnShutdown
		{
			[HarmonyPostfix]
			private static void Postfix()
			{
				ProcessingServerUpdate = true;
				foreach (ConfigSync configSync in configSyncs)
				{
					configSync.resetConfigsFromServer();
					configSync.IsSourceOfTruth = true;
					configSync.InitialSyncDone = false;
				}
				ProcessingServerUpdate = false;
			}
		}

		[ServerSync.Nullable(0)]
		[HarmonyPatch(typeof(ZNet), "RPC_PeerInfo")]
		private class SendConfigsAfterLogin
		{
			[ServerSync.Nullable(0)]
			private class BufferingSocket : ZPlayFabSocket, ISocket
			{
				public volatile bool finished = false;

				public volatile int versionMatchQueued = -1;

				public readonly List<ZPackage> Package = new List<ZPackage>();

				public readonly ISocket Original;

				public BufferingSocket(ISocket original)
				{
					Original = original;
					((ZPlayFabSocket)this)..ctor();
				}

				public bool IsConnected()
				{
					return Original.IsConnected();
				}

				public ZPackage Recv()
				{
					return Original.Recv();
				}

				public int GetSendQueueSize()
				{
					return Original.GetSendQueueSize();
				}

				public int GetCurrentSendRate()
				{
					return Original.GetCurrentSendRate();
				}

				public bool IsHost()
				{
					return Original.IsHost();
				}

				public void Dispose()
				{
					Original.Dispose();
				}

				public bool GotNewData()
				{
					return Original.GotNewData();
				}

				public void Close()
				{
					Original.Close();
				}

				public string GetEndPointString()
				{
					return Original.GetEndPointString();
				}

				public void GetAndResetStats(out int totalSent, out int totalRecv)
				{
					Original.GetAndResetStats(ref totalSent, ref totalRecv);
				}

				public void GetConnectionQuality(out float localQuality, out float remoteQuality, out int ping, out float outByteSec, out float inByteSec)
				{
					Original.GetConnectionQuality(ref localQuality, ref remoteQuality, ref ping, ref outByteSec, ref inByteSec);
				}

				public ISocket Accept()
				{
					return Original.Accept();
				}

				public int GetHostPort()
				{
					return Original.GetHostPort();
				}

				public bool Flush()
				{
					return Original.Flush();
				}

				public string GetHostName()
				{
					return Original.GetHostName();
				}

				public void VersionMatch()
				{
					if (finished)
					{
						Original.VersionMatch();
					}
					else
					{
						versionMatchQueued = Package.Count;
					}
				}

				public void Send(ZPackage pkg)
				{
					//IL_0066: Unknown result type (might be due to invalid IL or missing references)
					//IL_006c: Expected O, but got Unknown
					int pos = pkg.GetPos();
					pkg.SetPos(0);
					int num = pkg.ReadInt();
					if ((num == StringExtensionMethods.GetStableHashCode("PeerInfo") || num == StringExtensionMethods.GetStableHashCode("RoutedRPC") || num == StringExtensionMethods.GetStableHashCode("ZDOData")) && !finished)
					{
						ZPackage val = new ZPackage(pkg.GetArray());
						val.SetPos(pos);
						Package.Add(val);
					}
					else
					{
						pkg.SetPos(pos);
						Original.Send(pkg);
					}
				}
			}

			[HarmonyPriority(800)]
			[HarmonyPrefix]
			private static void Prefix([ServerSync.Nullable(new byte[] { 2, 1, 1 })] ref Dictionary<Assembly, BufferingSocket> __state, ZNet __instance, ZRpc rpc)
			{
				//IL_007b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0081: Invalid comparison between Unknown and I4
				if (!__instance.IsServer())
				{
					return;
				}
				BufferingSocket bufferingSocket = new BufferingSocket(rpc.GetSocket());
				AccessTools.DeclaredField(typeof(ZRpc), "m_socket").SetValue(rpc, bufferingSocket);
				object? obj = AccessTools.DeclaredMethod(typeof(ZNet), "GetPeer", new Type[1] { typeof(ZRpc) }, (Type[])null).Invoke(__instance, new object[1] { rpc });
				ZNetPeer val = (ZNetPeer)((obj is ZNetPeer) ? obj : null);
				if (val != null && (int)ZNet.m_onlineBackend > 0)
				{
					FieldInfo fieldInfo = AccessTools.DeclaredField(typeof(ZNetPeer), "m_socket");
					object? value = fieldInfo.GetValue(val);
					ZPlayFabSocket val2 = (ZPlayFabSocket)((value is ZPlayFabSocket) ? value : null);
					if (val2 != null)
					{
						typeof(ZPlayFabSocket).GetField("m_remotePlayerId").SetValue(bufferingSocket, val2.m_remotePlayerId);
					}
					fieldInfo.SetValue(val, bufferingSocket);
				}
				if (__state == null)
				{
					__state = new Dictionary<Assembly, BufferingSocket>();
				}
				__state[Assembly.GetExecutingAssembly()] = bufferingSocket;
			}

			[HarmonyPostfix]
			private static void Postfix(Dictionary<Assembly, BufferingSocket> __state, ZNet __instance, ZRpc rpc)
			{
				ZNetPeer peer;
				if (__instance.IsServer())
				{
					object obj = AccessTools.DeclaredMethod(typeof(ZNet), "GetPeer", new Type[1] { typeof(ZRpc) }, (Type[])null).Invoke(__instance, new object[1] { rpc });
					peer = (ZNetPeer)((obj is ZNetPeer) ? obj : null);
					if (peer == null)
					{
						SendBufferedData();
					}
					else
					{
						((MonoBehaviour)__instance).StartCoroutine(sendAsync());
					}
				}
				void SendBufferedData()
				{
					if (rpc.GetSocket() is BufferingSocket bufferingSocket)
					{
						AccessTools.DeclaredField(typeof(ZRpc), "m_socket").SetValue(rpc, bufferingSocket.Original);
						object? obj2 = AccessTools.DeclaredMethod(typeof(ZNet), "GetPeer", new Type[1] { typeof(ZRpc) }, (Type[])null).Invoke(__instance, new object[1] { rpc });
						ZNetPeer val = (ZNetPeer)((obj2 is ZNetPeer) ? obj2 : null);
						if (val != null)
						{
							AccessTools.DeclaredField(typeof(ZNetPeer), "m_socket").SetValue(val, bufferingSocket.Original);
						}
					}
					BufferingSocket bufferingSocket2 = __state[Assembly.GetExecutingAssembly()];
					bufferingSocket2.finished = true;
					for (int i = 0; i < bufferingSocket2.Package.Count; i++)
					{
						if (i == bufferingSocket2.versionMatchQueued)
						{
							bufferingSocket2.Original.VersionMatch();
						}
						bufferingSocket2.Original.Send(bufferingSocket2.Package[i]);
					}
					if (bufferingSocket2.Package.Count == bufferingSocket2.versionMatchQueued)
					{
						bufferingSocket2.Original.VersionMatch();
					}
				}
				IEnumerator sendAsync()
				{
					foreach (ConfigSync configSync in configSyncs)
					{
						List<PackageEntry> entries = new List<PackageEntry>();
						if (configSync.CurrentVersion != null)
						{
							entries.Add(new PackageEntry
							{
								section = "Internal",
								key = "serverversion",
								type = typeof(string),
								value = configSync.CurrentVersion
							});
						}
						MethodInfo listContainsId = AccessTools.DeclaredMethod(typeof(ZNet), "ListContainsId", (Type[])null, (Type[])null);
						SyncedList adminList = (SyncedList)AccessTools.DeclaredField(typeof(ZNet), "m_adminList").GetValue(ZNet.instance);
						entries.Add(new PackageEntry
						{
							section = "Internal",
							key = "lockexempt",
							type = typeof(bool),
							value = (((object)listContainsId == null) ? ((object)adminList.Contains(rpc.GetSocket().GetHostName())) : listContainsId.Invoke(ZNet.instance, new object[2]
							{
								adminList,
								rpc.GetSocket().GetHostName()
							}))
						});
						ZPackage package = ConfigsToPackage(configSync.allConfigs.Select([ServerSync.NullableContext(0)] (OwnConfigEntryBase c) => c.BaseConfig), configSync.allCustomValues, entries, partial: false);
						yield return ((MonoBehaviour)__instance).StartCoroutine(configSync.sendZPackage(new List<ZNetPeer> { peer }, package));
					}
					SendBufferedData();
				}
			}
		}

		[ServerSync.Nullable(0)]
		private class PackageEntry
		{
			public string section = null;

			public string key = null;

			public Type type = null;

			[ServerSync.Nullable(2)]
			public object value;
		}

		[ServerSync.NullableContext(0)]
		[HarmonyPatch(typeof(ConfigEntryBase), "GetSerializedValue")]
		private static class PreventSavingServerInfo
		{
			[ServerSync.NullableContext(1)]
			[HarmonyPrefix]
			private static bool Prefix(ConfigEntryBase __instance, ref string __result)
			{
				OwnConfigEntryBase ownConfigEntryBase = configData(__instance);
				if (ownConfigEntryBase == null || isWritableConfig(ownConfigEntryBase))
				{
					return true;
				}
				__result = TomlTypeConverter.ConvertToString(ownConfigEntryBase.LocalBaseValue, __instance.SettingType);
				return false;
			}
		}

		[ServerSync.NullableContext(0)]
		[HarmonyPatch(typeof(ConfigEntryBase), "SetSerializedValue")]
		private static class PreventConfigRereadChangingValues
		{
			[ServerSync.NullableContext(1)]
			[HarmonyPrefix]
			private static bool Prefix(ConfigEntryBase __instance, string value)
			{
				OwnConfigEntryBase ownConfigEntryBase = configData(__instance);
				if (ownConfigEntryBase == null || ownConfigEntryBase.LocalBaseValue == null)
				{
					return true;
				}
				try
				{
					ownConfigEntryBase.LocalBaseValue = TomlTypeConverter.ConvertToValue(value, __instance.SettingType);
				}
				catch (Exception ex)
				{
					Debug.LogWarning((object)$"Config value of setting \"{__instance.Definition}\" could not be parsed and will be ignored. Reason: {ex.Message}; Value: {value}");
				}
				return false;
			}
		}

		[ServerSync.Nullable(0)]
		private class InvalidDeserializationTypeException : Exception
		{
			public string expected = null;

			public string received = null;

			public string field = "";
		}

		public static bool ProcessingServerUpdate;

		public readonly string Name;

		[ServerSync.Nullable(2)]
		public string DisplayName;

		[ServerSync.Nullable(2)]
		public string CurrentVersion;

		[ServerSync.Nullable(2)]
		public string MinimumRequiredVersion;

		public bool ModRequired = false;

		private bool? forceConfigLocking;

		private bool isSourceOfTruth = true;

		private static readonly HashSet<ConfigSync> configSyncs;

		private readonly HashSet<OwnConfigEntryBase> allConfigs = new HashSet<OwnConfigEntryBase>();

		private HashSet<CustomSyncedValueBase> allCustomValues = new HashSet<CustomSyncedValueBase>();

		private static bool isServer;

		private static bool lockExempt;

		[ServerSync.Nullable(2)]
		private OwnConfigEntryBase lockedConfig = null;

		private const byte PARTIAL_CONFIGS = 1;

		private const byte FRAGMENTED_CONFIG = 2;

		private const byte COMPRESSED_CONFIG = 4;

		private readonly Dictionary<string, SortedDictionary<int, byte[]>> configValueCache = new Dictionary<string, SortedDictionary<int, byte[]>>();

		[ServerSync.Nullable(new byte[] { 1, 0, 1 })]
		private readonly List<KeyValuePair<long, string>> cacheExpirations = new List<KeyValuePair<long, string>>();

		private static long packageCounter;

		public bool IsLocked
		{
			get
			{
				bool? flag = forceConfigLocking;
				bool num;
				if (!flag.HasValue)
				{
					if (lockedConfig == null)
					{
						goto IL_0064;
					}
					num = ((IConvertible)lockedConfig.BaseConfig.BoxedValue).ToInt32(CultureInfo.InvariantCulture) != 0;
				}
				else
				{
					num = flag == true;
				}
				if (!num)
				{
					goto IL_0064;
				}
				int result = ((!lockExempt) ? 1 : 0);
				goto IL_0065;
				IL_0064:
				result = 0;
				goto IL_0065;
				IL_0065:
				return (byte)result != 0;
			}
			set
			{
				forceConfigLocking = value;
			}
		}

		public bool IsAdmin => lockExempt || isSourceOfTruth;

		public bool IsSourceOfTruth
		{
			get
			{
				return isSourceOfTruth;
			}
			private set
			{
				if (value != isSourceOfTruth)
				{
					isSourceOfTruth = value;
					this.SourceOfTruthChanged?.Invoke(value);
				}
			}
		}

		public bool InitialSyncDone { get; private set; } = false;

		[ServerSync.Nullable(2)]
		[method: ServerSync.NullableContext(2)]
		[field: ServerSync.Nullable(2)]
		public event Action<bool> SourceOfTruthChanged;

		[ServerSync.Nullable(2)]
		[method: ServerSync.NullableContext(2)]
		[field: ServerSync.Nullable(2)]
		private event Action lockedConfigChanged;

		static ConfigSync()
		{
			ProcessingServerUpdate = false;
			configSyncs = new HashSet<ConfigSync>();
			lockExempt = false;
			packageCounter = 0L;
			RuntimeHelpers.RunClassConstructor(typeof(VersionCheck).TypeHandle);
		}

		public ConfigSync(string name)
		{
			Name = name;
			configSyncs.Add(this);
			new VersionCheck(this);
		}

		public SyncedConfigEntry<T> AddConfigEntry<[ServerSync.Nullable(2)] T>(ConfigEntry<T> configEntry)
		{
			OwnConfigEntryBase ownConfigEntryBase = configData((ConfigEntryBase)(object)configEntry);
			SyncedConfigEntry<T> syncedEntry = ownConfigEntryBase as SyncedConfigEntry<T>;
			if (syncedEntry == null)
			{
				syncedEntry = new SyncedConfigEntry<T>(configEntry);
				AccessTools.DeclaredField(typeof(ConfigDescription), "<Tags>k__BackingField").SetValue(((ConfigEntryBase)configEntry).Description, new object[1]
				{
					new ConfigurationManagerAttributes()
				}.Concat(((ConfigEntryBase)configEntry).Description.Tags ?? Array.Empty<object>()).Concat(new SyncedConfigEntry<T>[1] { syncedEntry }).ToArray());
				configEntry.SettingChanged += [ServerSync.NullableContext(0)] (object _, EventArgs _) =>
				{
					if (!ProcessingServerUpdate && syncedEntry.SynchronizedConfig)
					{
						Broadcast(0L, (ConfigEntryBase)configEntry);
					}
				};
				allConfigs.Add(syncedEntry);
			}
			return syncedEntry;
		}

		public SyncedConfigEntry<T> AddLockingConfigEntry<[ServerSync.Nullable(0)] T>(ConfigEntry<T> lockingConfig) where T : IConvertible
		{
			if (lockedConfig != null)
			{
				throw new Exception("Cannot initialize locking ConfigEntry twice");
			}
			lockedConfig = AddConfigEntry<T>(lockingConfig);
			lockingConfig.SettingChanged += [ServerSync.NullableContext(0)] (object _, EventArgs _) =>
			{
				this.lockedConfigChanged?.Invoke();
			};
			return (SyncedConfigEntry<T>)lockedConfig;
		}

		internal void AddCustomValue(CustomSyncedValueBase customValue)
		{
			if (allCustomValues.Select([ServerSync.NullableContext(0)] (CustomSyncedValueBase v) => v.Identifier).Concat(new string[1] { "serverversion" }).Contains(customValue.Identifier))
			{
				throw new Exception("Cannot have multiple settings with the same name or with a reserved name (serverversion)");
			}
			allCustomValues.Add(customValue);
			allCustomValues = new HashSet<CustomSyncedValueBase>(allCustomValues.OrderByDescending([ServerSync.NullableContext(0)] (CustomSyncedValueBase v) => v.Priority));
			customValue.ValueChanged += delegate
			{
				if (!ProcessingServerUpdate)
				{
					Broadcast(0L, customValue);
				}
			};
		}

		private void RPC_FromServerConfigSync(ZRpc rpc, ZPackage package)
		{
			lockedConfigChanged += serverLockedSettingChanged;
			IsSourceOfTruth = false;
			if (HandleConfigSyncRPC(0L, package, clientUpdate: false))
			{
				InitialSyncDone = true;
			}
		}

		private void RPC_FromOtherClientConfigSync(long sender, ZPackage package)
		{
			HandleConfigSyncRPC(sender, package, clientUpdate: true);
		}

		private bool HandleConfigSyncRPC(long sender, ZPackage package, bool clientUpdate)
		{
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Expected O, but got Unknown
			//IL_027c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0283: Expected O, but got Unknown
			//IL_020b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0212: Expected O, but got Unknown
			try
			{
				if (isServer && IsLocked)
				{
					ZRpc currentRpc = SnatchCurrentlyHandlingRPC.currentRpc;
					object obj;
					if (currentRpc == null)
					{
						obj = null;
					}
					else
					{
						ISocket socket = currentRpc.GetSocket();
						obj = ((socket != null) ? socket.GetHostName() : null);
					}
					string text = (string)obj;
					if (text != null)
					{
						MethodInfo methodInfo = AccessTools.DeclaredMethod(typeof(ZNet), "ListContainsId", (Type[])null, (Type[])null);
						SyncedList val = (SyncedList)AccessTools.DeclaredField(typeof(ZNet), "m_adminList").GetValue(ZNet.instance);
						if (!(((object)methodInfo == null) ? val.Contains(text) : ((bool)methodInfo.Invoke(ZNet.instance, new object[2] { val, text }))))
						{
							return false;
						}
					}
				}
				cacheExpirations.RemoveAll(([ServerSync.Nullable(new byte[] { 0, 1 })] KeyValuePair<long, string> kv) =>
				{
					if (kv.Key < DateTimeOffset.Now.Ticks)
					{
						configValueCache.Remove(kv.Value);
						return true;
					}
					return false;
				});
				byte b = package.ReadByte();
				if ((b & 2) != 0)
				{
					long num = package.ReadLong();
					string text2 = sender.ToString() + num;
					if (!configValueCache.TryGetValue(text2, out var value))
					{
						value = new SortedDictionary<int, byte[]>();
						configValueCache[text2] = value;
						cacheExpirations.Add(new KeyValuePair<long, string>(DateTimeOffset.Now.AddSeconds(60.0).Ticks, text2));
					}
					int key = package.ReadInt();
					int num2 = package.ReadInt();
					value.Add(key, package.ReadByteArray());
					if (value.Count < num2)
					{
						return false;
					}
					configValueCache.Remove(text2);
					package = new ZPackage(value.Values.SelectMany([ServerSync.NullableContext(0)] (byte[] a) => a).ToArray());
					b = package.ReadByte();
				}
				ProcessingServerUpdate = true;
				if ((b & 4) != 0)
				{
					byte[] buffer = package.ReadByteArray();
					MemoryStream stream = new MemoryStream(buffer);
					MemoryStream memoryStream = new MemoryStream();
					using (DeflateStream deflateStream = new DeflateStream(stream, CompressionMode.Decompress))
					{
						deflateStream.CopyTo(memoryStream);
					}
					package = new ZPackage(memoryStream.ToArray());
					b = package.ReadByte();
				}
				if ((b & 1) == 0)
				{
					resetConfigsFromServer();
				}
				ParsedConfigs parsedConfigs = ReadConfigsFromPackage(package);
				ConfigFile val2 = null;
				bool saveOnConfigSet = false;
				foreach (KeyValuePair<OwnConfigEntryBase, object> configValue in parsedConfigs.configValues)
				{
					if (!isServer && configValue.Key.LocalBaseValue == null)
					{
						configValue.Key.LocalBaseValue = configValue.Key.BaseConfig.BoxedValue;
					}
					if (val2 == null)
					{
						val2 = configValue.Key.BaseConfig.ConfigFile;
						saveOnConfigSet = val2.SaveOnConfigSet;
						val2.SaveOnConfigSet = false;
					}
					configValue.Key.BaseConfig.BoxedValue = configValue.Value;
				}
				if (val2 != null)
				{
					val2.SaveOnConfigSet = saveOnConfigSet;
					val2.Save();
				}
				foreach (KeyValuePair<CustomSyncedValueBase, object> customValue in parsedConfigs.customValues)
				{
					if (!isServer)
					{
						CustomSyncedValueBase key2 = customValue.Key;
						if (key2.LocalBaseValue == null)
						{
							key2.LocalBaseValue = customValue.Key.BoxedValue;
						}
					}
					customValue.Key.BoxedValue = customValue.Value;
				}
				Debug.Log((object)string.Format("Received {0} configs and {1} custom values from {2} for mod {3}", parsedConfigs.configValues.Count, parsedConfigs.customValues.Count, (isServer || clientUpdate) ? $"client {sender}" : "the server", DisplayName ?? Name));
				if (!isServer)
				{
					serverLockedSettingChanged();
				}
				return true;
			}
			finally
			{
				ProcessingServerUpdate = false;
			}
		}

		private ParsedConfigs ReadConfigsFromPackage(ZPackage package)
		{
			ParsedConfigs parsedConfigs = new ParsedConfigs();
			Dictionary<string, OwnConfigEntryBase> dictionary = allConfigs.Where([ServerSync.NullableContext(0)] (OwnConfigEntryBase c) => c.SynchronizedConfig).ToDictionary([ServerSync.NullableContext(0)] (OwnConfigEntryBase c) => c.BaseConfig.Definition.Section + "_" + c.BaseConfig.Definition.Key, [ServerSync.NullableContext(0)] (OwnConfigEntryBase c) => c);
			Dictionary<string, CustomSyncedValueBase> dictionary2 = allCustomValues.ToDictionary([ServerSync.NullableContext(0)] (CustomSyncedValueBase c) => c.Identifier, [ServerSync.NullableContext(0)] (CustomSyncedValueBase c) => c);
			int num = package.ReadInt();
			for (int num2 = 0; num2 < num; num2++)
			{
				string text = package.ReadString();
				string text2 = package.ReadString();
				string text3 = package.ReadString();
				Type type = Type.GetType(text3);
				if (text3 == "" || type != null)
				{
					object obj;
					try
					{
						obj = ((text3 == "") ? null : ReadValueWithTypeFromZPackage(package, type));
					}
					catch (InvalidDeserializationTypeException ex)
					{
						Debug.LogWarning((object)("Got unexpected struct internal type " + ex.received + " for field " + ex.field + " struct " + text3 + " for " + text2 + " in section " + text + " for mod " + (DisplayName ?? Name) + ", expecting " + ex.expected));
						continue;
					}
					OwnConfigEntryBase value2;
					if (text == "Internal")
					{
						CustomSyncedValueBase value;
						if (text2 == "serverversion")
						{
							if (obj?.ToString() != CurrentVersion)
							{
								Debug.LogWarning((object)("Received server version is not equal: server version = " + (obj?.ToString() ?? "null") + "; local version = " + (CurrentVersion ?? "unknown")));
							}
						}
						else if (text2 == "lockexempt")
						{
							if (obj is bool flag)
							{
								lockExempt = flag;
							}
						}
						else if (dictionary2.TryGetValue(text2, out value))
						{
							if ((text3 == "" && (!value.Type.IsValueType || Nullable.GetUnderlyingType(value.Type) != null)) || GetZPackageTypeString(value.Type) == text3)
							{
								parsedConfigs.customValues[value] = obj;
								continue;
							}
							Debug.LogWarning((object)("Got unexpected type " + text3 + " for internal value " + text2 + " for mod " + (DisplayName ?? Name) + ", expecting " + value.Type.AssemblyQualifiedName));
						}
					}
					else if (dictionary.TryGetValue(text + "_" + text2, out value2))
					{
						Type type2 = configType(value2.BaseConfig);
						if ((text3 == "" && (!type2.IsValueType || Nullable.GetUnderlyingType(type2) != null)) || GetZPackageTypeString(type2) == text3)
						{
							parsedConfigs.configValues[value2] = obj;
							continue;
						}
						Debug.LogWarning((object)("Got unexpected type " + text3 + " for " + text2 + " in section " + text + " for mod " + (DisplayName ?? Name) + ", expecting " + type2.AssemblyQualifiedName));
					}
					else
					{
						Debug.LogWarning((object)("Received unknown config entry " + text2 + " in section " + text + " for mod " + (DisplayName ?? Name) + ". This may happen if client and server versions of the mod do not match."));
					}
					continue;
				}
				Debug.LogWarning((object)("Got invalid type " + text3 + ", abort reading of received configs"));
				return new ParsedConfigs();
			}
			return parsedConfigs;
		}

		private static bool isWritableConfig(OwnConfigEntryBase config)
		{
			ConfigSync configSync = configSyncs.FirstOrDefault([ServerSync.NullableContext(0)] (ConfigSync cs) => cs.allConfigs.Contains(config));
			if (configSync == null)
			{
				return true;
			}
			return configSync.IsSourceOfTruth || !config.SynchronizedConfig || config.LocalBaseValue == null || (!configSync.IsLocked && (config != configSync.lockedConfig || lockExempt));
		}

		private void serverLockedSettingChanged()
		{
			foreach (OwnConfigEntryBase allConfig in allConfigs)
			{
				configAttribute<ConfigurationManagerAttributes>(allConfig.BaseConfig).ReadOnly = !isWritableConfig(allConfig);
			}
		}

		private void resetConfigsFromServer()
		{
			ConfigFile val = null;
			bool saveOnConfigSet = false;
			foreach (OwnConfigEntryBase item in allConfigs.Where([ServerSync.NullableContext(0)] (OwnConfigEntryBase config) => config.LocalBaseValue != null))
			{
				if (val == null)
				{
					val = item.BaseConfig.ConfigFile;
					saveOnConfigSet = val.SaveOnConfigSet;
					val.SaveOnConfigSet = false;
				}
				item.BaseConfig.BoxedValue = item.LocalBaseValue;
				item.LocalBaseValue = null;
			}
			if (val != null)
			{
				val.SaveOnConfigSet = saveOnConfigSet;
			}
			foreach (CustomSyncedValueBase item2 in allCustomValues.Where([ServerSync.NullableContext(0)] (CustomSyncedValueBase config) => config.LocalBaseValue != null))
			{
				item2.BoxedValue = item2.LocalBaseValue;
				item2.LocalBaseValue = null;
			}
			lockedConfigChanged -= serverLockedSettingChanged;
			serverLockedSettingChanged();
		}

		private IEnumerator<bool> distributeConfigToPeers(ZNetPeer peer, ZPackage package)
		{
			ZRoutedRpc rpc = ZRoutedRpc.instance;
			if (rpc == null)
			{
				yield break;
			}
			byte[] data = package.GetArray();
			if (data != null && data.LongLength > 250000)
			{
				int fragments = (int)(1 + (data.LongLength - 1) / 250000);
				long packageIdentifier = ++packageCounter;
				int fragment = 0;
				while (fragment < fragments)
				{
					foreach (bool item in waitForQueue())
					{
						yield return item;
					}
					if (peer.m_socket.IsConnected())
					{
						ZPackage fragmentedPackage = new ZPackage();
						fragmentedPackage.Write((byte)2);
						fragmentedPackage.Write(packageIdentifier);
						fragmentedPackage.Write(fragment);
						fragmentedPackage.Write(fragments);
						fragmentedPackage.Write(data.Skip(250000 * fragment).Take(250000).ToArray());
						SendPackage(fragmentedPackage);
						if (fragment != fragments - 1)
						{
							yield return true;
						}
						int num = fragment + 1;
						fragment = num;
						continue;
					}
					break;
				}
				yield break;
			}
			foreach (bool item2 in waitForQueue())
			{
				yield return item2;
			}
			SendPackage(package);
			void SendPackage(ZPackage pkg)
			{
				string text = Name + " ConfigSync";
				if (isServer)
				{
					peer.m_rpc.Invoke(text, new object[1] { pkg });
				}
				else
				{
					rpc.InvokeRoutedRPC(peer.m_server ? 0 : peer.m_uid, text, new object[1] { pkg });
				}
			}
			IEnumerable<bool> waitForQueue()
			{
				float timeout = Time.time + 30f;
				while (peer.m_socket.GetSendQueueSize() > 20000)
				{
					if (Time.time > timeout)
					{
						Debug.Log((object)$"Disconnecting {peer.m_uid} after 30 seconds config sending timeout");
						peer.m_rpc.Invoke("Error", new object[1] { (object)(ConnectionStatus)5 });
						ZNet.instance.Disconnect(peer);
						break;
					}
					yield return false;
				}
			}
		}

		private IEnumerator sendZPackage(long target, ZPackage package)
		{
			if (!Object.op_Implicit((Object)(object)ZNet.instance))
			{
				return Enumerable.Empty<object>().GetEnumerator();
			}
			List<ZNetPeer> list = (List<ZNetPeer>)AccessTools.DeclaredField(typeof(ZRoutedRpc), "m_peers").GetValue(ZRoutedRpc.instance);
			if (target != 0)
			{
				list = list.Where([ServerSync.NullableContext(0)] (ZNetPeer p) => p.m_uid == target).ToList();
			}
			return sendZPackage(list, package);
		}

		private IEnumerator sendZPackage(List<ZNetPeer> peers, ZPackage package)
		{
			if (!Object.op_Implicit((Object)(object)ZNet.instance))
			{
				yield break;
			}
			byte[] rawData = package.GetArray();
			if (rawData != null && rawData.LongLength > 10000)
			{
				ZPackage compressedPackage = new ZPackage();
				compressedPackage.Write((byte)4);
				MemoryStream output = new MemoryStream();
				using (DeflateStream deflateStream = new DeflateStream(output, CompressionLevel.Optimal))
				{
					deflateStream.Write(rawData, 0, rawData.Length);
				}
				compressedPackage.Write(output.ToArray());
				package = compressedPackage;
			}
			List<IEnumerator<bool>> writers = (from p in peers
				where p.IsReady()
				select distributeConfigToPeers(p, package)).ToList();
			writers.RemoveAll((IEnumerator<bool> writer) => !writer.MoveNext());
			while (writers.Count > 0)
			{
				yield return null;
				writers.RemoveAll((IEnumerator<bool> writer) => !writer.MoveNext());
			}
		}

		private void Broadcast(long target, params ConfigEntryBase[] configs)
		{
			if (!IsLocked || isServer)
			{
				ZPackage package = ConfigsToPackage(configs);
				ZNet instance = ZNet.instance;
				if (instance != null)
				{
					((MonoBehaviour)instance).StartCoroutine(sendZPackage(target, package));
				}
			}
		}

		private void Broadcast(long target, params CustomSyncedValueBase[] customValues)
		{
			if (!IsLocked || isServer)
			{
				ZPackage package = ConfigsToPackage(null, customValues);
				ZNet instance = ZNet.instance;
				if (instance != null)
				{
					((MonoBehaviour)instance).StartCoroutine(sendZPackage(target, package));
				}
			}
		}

		[return: ServerSync.Nullable(2)]
		private static OwnConfigEntryBase configData(ConfigEntryBase config)
		{
			return config.Description.Tags?.OfType<OwnConfigEntryBase>().SingleOrDefault();
		}

		[return: ServerSync.Nullable(new byte[] { 2, 1 })]
		public static SyncedConfigEntry<T> ConfigData<[ServerSync.Nullable(2)] T>(ConfigEntry<T> config)
		{
			return ((ConfigEntryBase)config).Description.Tags?.OfType<SyncedConfigEntry<T>>().SingleOrDefault();
		}

		private static T configAttribute<[ServerSync.Nullable(2)] T>(ConfigEntryBase config)
		{
			return config.Description.Tags.OfType<T>().First();
		}

		private static Type configType(ConfigEntryBase config)
		{
			return configType(config.SettingType);
		}

		private static Type configType(Type type)
		{
			return type.IsEnum ? Enum.GetUnderlyingType(type) : type;
		}

		private static ZPackage ConfigsToPackage([ServerSync.Nullable(new byte[] { 2, 1 })] IEnumerable<ConfigEntryBase> configs = null, [ServerSync.Nullable(new byte[] { 2, 1 })] IEnumerable<CustomSyncedValueBase> customValues = null, [ServerSync.Nullable(new byte[] { 2, 1 })] IEnumerable<PackageEntry> packageEntries = null, bool partial = true)
		{
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Expected O, but got Unknown
			List<ConfigEntryBase> list = configs?.Where([ServerSync.NullableContext(0)] (ConfigEntryBase config) => configData(config).SynchronizedConfig).ToList() ?? new List<ConfigEntryBase>();
			List<CustomSyncedValueBase> list2 = customValues?.ToList() ?? new List<CustomSyncedValueBase>();
			ZPackage val = new ZPackage();
			val.Write((byte)(partial ? 1 : 0));
			val.Write(list.Count + list2.Count + (packageEntries?.Count() ?? 0));
			foreach (PackageEntry item in packageEntries ?? Array.Empty<PackageEntry>())
			{
				AddEntryToPackage(val, item);
			}
			foreach (CustomSyncedValueBase item2 in list2)
			{
				AddEntryToPackage(val, new PackageEntry
				{
					section = "Internal",
					key = item2.Identifier,
					type = item2.Type,
					value = item2.BoxedValue
				});
			}
			foreach (ConfigEntryBase item3 in list)
			{
				AddEntryToPackage(val, new PackageEntry
				{
					section = item3.Definition.Section,
					key = item3.Definition.Key,
					type = configType(item3),
					value = item3.BoxedValue
				});
			}
			return val;
		}

		private static void AddEntryToPackage(ZPackage package, PackageEntry entry)
		{
			package.Write(entry.section);
			package.Write(entry.key);
			package.Write((entry.value == null) ? "" : GetZPackageTypeString(entry.type));
			AddValueToZPackage(package, entry.value);
		}

		private static string GetZPackageTypeString(Type type)
		{
			return type.AssemblyQualifiedName;
		}

		private static void AddValueToZPackage(ZPackage package, [ServerSync.Nullable(2)] object value)
		{
			Type type = value?.GetType();
			if (value is Enum)
			{
				value = ((IConvertible)value).ToType(Enum.GetUnderlyingType(value.GetType()), CultureInfo.InvariantCulture);
			}
			else
			{
				if (value is ICollection collection)
				{
					package.Write(collection.Count);
					{
						foreach (object item in collection)
						{
							AddValueToZPackage(package, item);
						}
						return;
					}
				}
				if ((object)type != null && type.IsValueType && !type.IsPrimitive)
				{
					FieldInfo[] fields = type.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
					package.Write(fields.Length);
					FieldInfo[] array = fields;
					foreach (FieldInfo fieldInfo in array)
					{
						package.Write(GetZPackageTypeString(fieldInfo.FieldType));
						AddValueToZPackage(package, fieldInfo.GetValue(value));
					}
					return;
				}
			}
			ZRpc.Serialize(new object[1] { value }, ref package);
		}

		private static object ReadValueWithTypeFromZPackage(ZPackage package, Type type)
		{
			if ((object)type != null && type.IsValueType && !type.IsPrimitive && !type.IsEnum)
			{
				FieldInfo[] fields = type.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				int num = package.ReadInt();
				if (num != fields.Length)
				{
					throw new InvalidDeserializationTypeException
					{
						received = $"(field count: {num})",
						expected = $"(field count: {fields.Length})"
					};
				}
				object uninitializedObject = FormatterServices.GetUninitializedObject(type);
				FieldInfo[] array = fields;
				foreach (FieldInfo fieldInfo in array)
				{
					string text = package.ReadString();
					if (text != GetZPackageTypeString(fieldInfo.FieldType))
					{
						throw new InvalidDeserializationTypeException
						{
							received = text,
							expected = GetZPackageTypeString(fieldInfo.FieldType),
							field = fieldInfo.Name
						};
					}
					fieldInfo.SetValue(uninitializedObject, ReadValueWithTypeFromZPackage(package, fieldInfo.FieldType));
				}
				return uninitializedObject;
			}
			if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Dictionary<, >))
			{
				int num2 = package.ReadInt();
				IDictionary dictionary = (IDictionary)Activator.CreateInstance(type);
				Type type2 = typeof(KeyValuePair<, >).MakeGenericType(type.GenericTypeArguments);
				FieldInfo field = type2.GetField("key", BindingFlags.Instance | BindingFlags.NonPublic);
				FieldInfo field2 = type2.GetField("value", BindingFlags.Instance | BindingFlags.NonPublic);
				for (int j = 0; j < num2; j++)
				{
					object obj = ReadValueWithTypeFromZPackage(package, type2);
					dictionary.Add(field.GetValue(obj), field2.GetValue(obj));
				}
				return dictionary;
			}
			if (type != typeof(List<string>) && type.IsGenericType)
			{
				Type type3 = typeof(ICollection<>).MakeGenericType(type.GenericTypeArguments[0]);
				if ((object)type3 != null && type3.IsAssignableFrom(type))
				{
					int num3 = package.ReadInt();
					object obj2 = Activator.CreateInstance(type);
					MethodInfo method = type3.GetMethod("Add");
					for (int k = 0; k < num3; k++)
					{
						method.Invoke(obj2, new object[1] { ReadValueWithTypeFromZPackage(package, type.GenericTypeArguments[0]) });
					}
					return obj2;
				}
			}
			ParameterInfo parameterInfo = (ParameterInfo)FormatterServices.GetUninitializedObject(typeof(ParameterInfo));
			AccessTools.DeclaredField(typeof(ParameterInfo), "ClassImpl").SetValue(parameterInfo, type);
			List<object> source = new List<object>();
			ZRpc.Deserialize(new ParameterInfo[2] { null, parameterInfo }, package, ref source);
			return source.First();
		}
	}
	[ServerSync.NullableContext(1)]
	[ServerSync.Nullable(0)]
	[PublicAPI]
	[HarmonyPatch]
	public class VersionCheck
	{
		private static readonly HashSet<VersionCheck> versionChecks;

		private static readonly Dictionary<string, string> notProcessedNames;

		public string Name;

		[ServerSync.Nullable(2)]
		private string displayName;

		[ServerSync.Nullable(2)]
		private string currentVersion;

		[ServerSync.Nullable(2)]
		private string minimumRequiredVersion;

		public bool ModRequired = true;

		[ServerSync.Nullable(2)]
		private string ReceivedCurrentVersion;

		[ServerSync.Nullable(2)]
		private string ReceivedMinimumRequiredVersion;

		private readonly List<ZRpc> ValidatedClients = new List<ZRpc>();

		[ServerSync.Nullable(2)]
		private ConfigSync ConfigSync;

		public string DisplayName
		{
			get
			{
				return displayName ?? Name;
			}
			set
			{
				displayName = value;
			}
		}

		public string CurrentVersion
		{
			get
			{
				return currentVersion ?? "0.0.0";
			}
			set
			{
				currentVersion = value;
			}
		}

		public string MinimumRequiredVersion
		{
			get
			{
				return minimumRequiredVersion ?? (ModRequired ? CurrentVersion : "0.0.0");
			}
			set
			{
				minimumRequiredVersion = value;
			}
		}

		private static void PatchServerSync()
		{
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Expected O, but got Unknown
			Patches patchInfo = PatchProcessor.GetPatchInfo((MethodBase)AccessTools.DeclaredMethod(typeof(ZNet), "Awake", (Type[])null, (Type[])null));
			if (patchInfo != null && patchInfo.Postfixes.Count([ServerSync.NullableContext(0)] (Patch p) => p.PatchMethod.DeclaringType == typeof(ConfigSync.RegisterRPCPatch)) > 0)
			{
				return;
			}
			Harmony val = new Harmony("org.bepinex.helpers.ServerSync");
			foreach (Type item in from t in typeof(ConfigSync).GetNestedTypes(BindingFlags.NonPublic).Concat(new Type[1] { typeof(VersionCheck) })
				where t.IsClass
				select t)
			{
				val.PatchAll(item);
			}
		}

		static VersionCheck()
		{
			versionChecks = new HashSet<VersionCheck>();
			notProcessedNames = new Dictionary<string, string>();
			typeof(ThreadingHelper).GetMethod("StartSyncInvoke").Invoke(ThreadingHelper.Instance, new object[1]
			{
				new Action(PatchServerSync)
			});
		}

		public VersionCheck(string name)
		{
			Name = name;
			ModRequired = true;
			versionChecks.Add(this);
		}

		public VersionCheck(ConfigSync configSync)
		{
			ConfigSync = configSync;
			Name = ConfigSync.Name;
			versionChecks.Add(this);
		}

		public void Initialize()
		{
			ReceivedCurrentVersion = null;
			ReceivedMinimumRequiredVersion = null;
			if (ConfigSync != null)
			{
				Name = ConfigSync.Name;
				DisplayName = ConfigSync.DisplayName;
				CurrentVersion = ConfigSync.CurrentVersion;
				MinimumRequiredVersion = ConfigSync.MinimumRequiredVersion;
				ModRequired = ConfigSync.ModRequired;
			}
		}

		private bool IsVersionOk()
		{
			if (ReceivedMinimumRequiredVersion == null || ReceivedCurrentVersion == null)
			{
				return !ModRequired;
			}
			bool flag = new Version(CurrentVersion) >= new Version(ReceivedMinimumRequiredVersion);
			bool flag2 = new Version(ReceivedCurrentVersion) >= new Version(MinimumRequiredVersion);
			return flag && flag2;
		}

		private string ErrorClient()
		{
			if (ReceivedMinimumRequiredVersion == null)
			{
				return DisplayName + " is not installed on the server.";
			}
			return (new Version(CurrentVersion) >= new Version(ReceivedMinimumRequiredVersion)) ? (DisplayName + " may not be higher than version " + ReceivedCurrentVersion + ". You have version " + CurrentVersion + ".") : (DisplayName + " needs to be at least version " + ReceivedMinimumRequiredVersion + ". You have version " + CurrentVersion + ".");
		}

		private string ErrorServer(ZRpc rpc)
		{
			return "Disconnect: The client (" + rpc.GetSocket().GetHostName() + ") doesn't have the correct " + DisplayName + " version " + MinimumRequiredVersion;
		}

		private string Error([ServerSync.Nullable(2)] ZRpc rpc = null)
		{
			return (rpc == null) ? ErrorClient() : ErrorServer(rpc);
		}

		private static VersionCheck[] GetFailedClient()
		{
			return versionChecks.Where([ServerSync.NullableContext(0)] (VersionCheck check) => !check.IsVersionOk()).ToArray();
		}

		private static VersionCheck[] GetFailedServer(ZRpc rpc)
		{
			return versionChecks.Where([ServerSync.NullableContext(0)] (VersionCheck check) => check.ModRequired && !check.ValidatedClients.Contains(rpc)).ToArray();
		}

		private static void Logout()
		{
			Game.instance.Logout(true, true);
			AccessTools.DeclaredField(typeof(ZNet), "m_connectionStatus").SetValue(null, (object)(ConnectionStatus)3);
		}

		private static void DisconnectClient(ZRpc rpc)
		{
			rpc.Invoke("Error", new object[1] { 3 });
		}

		private static void CheckVersion(ZRpc rpc, ZPackage pkg)
		{
			CheckVersion(rpc, pkg, null);
		}

		private static void CheckVersion(ZRpc rpc, ZPackage pkg, [ServerSync.Nullable(new byte[] { 2, 1, 1 })] Action<ZRpc, ZPackage> original)
		{
			string text = pkg.ReadString();
			string text2 = pkg.ReadString();
			string text3 = pkg.ReadString();
			bool flag = false;
			foreach (VersionCheck versionCheck in versionChecks)
			{
				if (!(text != versionCheck.Name))
				{
					Debug.Log((object)("Received " + versionCheck.DisplayName + " version " + text3 + " and minimum version " + text2 + " from the " + (ZNet.instance.IsServer() ? "client" : "server") + "."));
					versionCheck.ReceivedMinimumRequiredVersion = text2;
					versionCheck.ReceivedCurrentVersion = text3;
					if (ZNet.instance.IsServer() && versionCheck.IsVersionOk())
					{
						versionCheck.ValidatedClients.Add(rpc);
					}
					flag = true;
				}
			}
			if (flag)
			{
				return;
			}
			pkg.SetPos(0);
			if (original != null)
			{
				original(rpc, pkg);
				if (pkg.GetPos() == 0)
				{
					notProcessedNames.Add(text, text3);
				}
			}
		}

		[HarmonyPatch(typeof(ZNet), "RPC_PeerInfo")]
		[HarmonyPrefix]
		private static bool RPC_PeerInfo(ZRpc rpc, ZNet __instance)
		{
			VersionCheck[] array = (__instance.IsServer() ? GetFailedServer(rpc) : GetFailedClient());
			if (array.Length == 0)
			{
				return true;
			}
			VersionCheck[] array2 = array;
			foreach (VersionCheck versionCheck in array2)
			{
				Debug.LogWarning((object)versionCheck.Error(rpc));
			}
			if (__instance.IsServer())
			{
				DisconnectClient(rpc);
			}
			else
			{
				Logout();
			}
			return false;
		}

		[HarmonyPatch(typeof(ZNet), "OnNewConnection")]
		[HarmonyPrefix]
		private static void RegisterAndCheckVersion(ZNetPeer peer, ZNet __instance)
		{
			//IL_01a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ad: Expected O, but got Unknown
			notProcessedNames.Clear();
			IDictionary dictionary = (IDictionary)typeof(ZRpc).GetField("m_functions", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(peer.m_rpc);
			if (dictionary.Contains(StringExtensionMethods.GetStableHashCode("ServerSync VersionCheck")))
			{
				object obj = dictionary[StringExtensionMethods.GetStableHashCode("ServerSync VersionCheck")];
				Action<ZRpc, ZPackage> action = (Action<ZRpc, ZPackage>)obj.GetType().GetField("m_action", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(obj);
				peer.m_rpc.Register<ZPackage>("ServerSync VersionCheck", (Action<ZRpc, ZPackage>)([ServerSync.NullableContext(0)] (ZRpc rpc, [ServerSync.Nullable(1)] ZPackage pkg) =>
				{
					CheckVersion(rpc, pkg, action);
				}));
			}
			else
			{
				peer.m_rpc.Register<ZPackage>("ServerSync VersionCheck", (Action<ZRpc, ZPackage>)CheckVersion);
			}
			foreach (VersionCheck versionCheck in versionChecks)
			{
				versionCheck.Initialize();
				if (versionCheck.ModRequired || __instance.IsServer())
				{
					Debug.Log((object)("Sending " + versionCheck.DisplayName + " version " + versionCheck.CurrentVersion + " and minimum version " + versionCheck.MinimumRequiredVersion + " to the " + (__instance.IsServer() ? "client" : "server") + "."));
					ZPackage val = new ZPackage();
					val.Write(versionCheck.Name);
					val.Write(versionCheck.MinimumRequiredVersion);
					val.Write(versionCheck.CurrentVersion);
					peer.m_rpc.Invoke("ServerSync VersionCheck", new object[1] { val });
				}
			}
		}

		[HarmonyPatch(typeof(ZNet), "Disconnect")]
		[HarmonyPrefix]
		private static void RemoveDisconnected(ZNetPeer peer, ZNet __instance)
		{
			if (!__instance.IsServer())
			{
				return;
			}
			foreach (VersionCheck versionCheck in versionChecks)
			{
				versionCheck.ValidatedClients.Remove(peer.m_rpc);
			}
		}

		[HarmonyPatch(typeof(FejdStartup), "ShowConnectError")]
		[HarmonyPostfix]
		private static void ShowConnectionError(FejdStartup __instance)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Invalid comparison between Unknown and I4
			//IL_01a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0205: Unknown result type (might be due to invalid IL or missing references)
			//IL_0213: Unknown result type (might be due to invalid IL or missing references)
			//IL_0225: Unknown result type (might be due to invalid IL or missing references)
			//IL_0234: Unknown result type (might be due to invalid IL or missing references)
			//IL_0239: Unknown result type (might be due to invalid IL or missing references)
			//IL_0244: Unknown result type (might be due to invalid IL or missing references)
			if (!__instance.m_connectionFailedPanel.activeSelf || (int)ZNet.GetConnectionStatus() != 3)
			{
				return;
			}
			bool flag = false;
			VersionCheck[] failedClient = GetFailedClient();
			if (failedClient.Length != 0)
			{
				string text = string.Join("\n", failedClient.Select([ServerSync.NullableContext(0)] (VersionCheck check) => check.Error()));
				TMP_Text connectionFailedError = __instance.m_connectionFailedError;
				connectionFailedError.text = connectionFailedError.text + "\n" + text;
				flag = true;
			}
			foreach (KeyValuePair<string, string> item in notProcessedNames.OrderBy([ServerSync.NullableContext(0)] (KeyValuePair<string, string> kv) => kv.Key))
			{
				if (!__instance.m_connectionFailedError.text.Contains(item.Key))
				{
					TMP_Text connectionFailedError2 = __instance.m_connectionFailedError;
					connectionFailedError2.text = connectionFailedError2.text + "\nServer expects you to have " + item.Key + " (Version: " + item.Value + ") installed.";
					flag = true;
				}
			}
			if (flag)
			{
				RectTransform component = ((Component)__instance.m_connectionFailedPanel.transform.Find("Image")).GetComponent<RectTransform>();
				Vector2 sizeDelta = component.sizeDelta;
				sizeDelta.x = 675f;
				component.sizeDelta = sizeDelta;
				__instance.m_connectionFailedError.ForceMeshUpdate(false, false);
				float num = __instance.m_connectionFailedError.renderedHeight + 105f;
				RectTransform component2 = ((Component)((Component)component).transform.Find("ButtonOk")).GetComponent<RectTransform>();
				component2.anchoredPosition = new Vector2(component2.anchoredPosition.x, component2.anchoredPosition.y - (num - component.sizeDelta.y) / 2f);
				sizeDelta = component.sizeDelta;
				sizeDelta.y = num;
				component.sizeDelta = sizeDelta;
			}
		}
	}
}