using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using HarmonyLib;
using Jotunn;
using Jotunn.Configs;
using Jotunn.Entities;
using Jotunn.Managers;
using Jotunn.Utils;
using Splatform;
using TMPro;
using UnityEngine;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("ExpertExplorer")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("ExpertExplorer")]
[assembly: AssemblyCopyright("Copyright ©  2025")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("e3243d22-4307-4008-ba36-9f326008cde5")]
[assembly: AssemblyFileVersion("1.5.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.5.0.0")]
namespace ExpertExplorer
{
	internal static class LocalizationHelper
	{
		private static readonly List<string> languages = new List<string>
		{
			"English", "Swedish", "French", "Italian", "German", "Spanish", "Russian", "Romanian", "Bulgarian", "Macedonian",
			"Finnish", "Danish", "Norwegian", "Icelandic", "Turkish", "Lithuanian", "Czech", "Hungarian", "Slovak", "Polish",
			"Dutch", "Portuguese_European", "Portuguese_Brazilian", "Chinese", "Chinese_Trad", "Japanese", "Korean", "Hindi", "Thai", "Abenaki",
			"Croatian", "Georgian", "Greek", "Serbian", "Ukrainian", "Latvian"
		};

		public static bool IsLanguageSupported(string language)
		{
			return languages.Contains(language);
		}
	}
	public class PlayerExplorationData : MonoBehaviour
	{
		public Dictionary<Vector2i, int> DiscoveredLocations = new Dictionary<Vector2i, int>();

		public List<int> DiscoveredBiomes = new List<int>();

		public Dictionary<Vector2i, string> PinnedLocations = new Dictionary<Vector2i, string>();

		public bool IsZoneLocationAlreadyDiscovered(Vector2i zone)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			return DiscoveredLocations.ContainsKey(zone);
		}

		public void FlagAsDiscovered(ZoneData zoneData)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			if (zoneData != null && !string.IsNullOrEmpty(zoneData.LocationPrefab))
			{
				DiscoveredLocations[zoneData.ZoneId] = zoneData.LocationHash;
				Logger.LogInfo((object)("Discovered location " + zoneData.LocalizedLocationName));
			}
		}

		public void FlagAsDiscovered(Biome biome)
		{
			//IL_0005: 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)
			if (Heightmap.s_biomeToIndex.TryGetValue(biome, out var value) && !DiscoveredBiomes.Contains(value))
			{
				DiscoveredBiomes.Add(value);
				Logger.LogInfo((object)$"Discovered biome {biome}");
			}
		}

		public void FlagAsPinned(Vector2i zone, PinData pinData)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			PinnedLocations[zone] = pinData.m_name;
		}

		public void RemovePin(Vector2i zone)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			PinnedLocations.Remove(zone);
		}

		public void Save(Player player)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Expected O, but got Unknown
			//IL_0054: 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_009b: Expected O, but got Unknown
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: Expected O, but got Unknown
			//IL_0127: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)player == (Object)null)
			{
				Logger.LogError((object)"Tried to save an PlayerExplorationData without a player!");
				return;
			}
			SaveValue(player, "PlayerExplorationData", "This player is using PlayerExplorationData!");
			ZPackage val = new ZPackage();
			val.Write(DiscoveredLocations.Count);
			foreach (KeyValuePair<Vector2i, int> discoveredLocation in DiscoveredLocations)
			{
				val.Write(discoveredLocation.Key);
				val.Write(discoveredLocation.Value);
			}
			SaveValue(player, "DiscoveredLocations", val.GetBase64());
			val = new ZPackage();
			val.Write(DiscoveredBiomes.Count);
			foreach (int discoveredBiome in DiscoveredBiomes)
			{
				val.Write(discoveredBiome);
			}
			SaveValue(player, "ExpertExplorerDiscoveredBiomes", val.GetBase64());
			val = new ZPackage();
			val.Write(PinnedLocations.Count);
			foreach (KeyValuePair<Vector2i, string> pinnedLocation in PinnedLocations)
			{
				val.Write(pinnedLocation.Key);
				val.Write(pinnedLocation.Value);
			}
			SaveValue(player, "PinnedLocations", val.GetBase64());
		}

		public void Load(Player fromPlayer)
		{
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Expected O, but got Unknown
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Expected O, but got Unknown
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0136: Unknown result type (might be due to invalid IL or missing references)
			//IL_013d: Expected O, but got Unknown
			//IL_014d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0152: Unknown result type (might be due to invalid IL or missing references)
			//IL_015a: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)fromPlayer == (Object)null)
			{
				Logger.LogError((object)"Tried to load an PlayerExplorationData with a null player!");
				return;
			}
			LoadValue(fromPlayer, "PlayerExplorationData", out var _);
			if (LoadValue(fromPlayer, "DiscoveredLocations", out var value2))
			{
				ZPackage val = new ZPackage(value2);
				int num = val.ReadInt();
				for (int i = 0; i < num; i++)
				{
					Vector2i key = val.ReadVector2i();
					DiscoveredLocations[key] = val.ReadInt();
				}
			}
			fromPlayer.m_customData.Remove("DiscoveredBiomes");
			DiscoveredBiomes.Clear();
			if (LoadValue(fromPlayer, "ExpertExplorerDiscoveredBiomes", out var value3))
			{
				ZPackage val2 = new ZPackage(value3);
				int num2 = val2.ReadInt();
				for (int j = 0; j < num2; j++)
				{
					int item = val2.ReadInt();
					if (!DiscoveredBiomes.Contains(item))
					{
						DiscoveredBiomes.Add(item);
					}
				}
			}
			foreach (Biome item2 in fromPlayer.m_knownBiome)
			{
				FlagAsDiscovered(item2);
			}
			PinnedLocations.Clear();
			if (LoadValue(fromPlayer, "PinnedLocations", out var value4))
			{
				ZPackage val3 = new ZPackage(value4);
				int num3 = val3.ReadInt();
				for (int k = 0; k < num3; k++)
				{
					Vector2i key2 = val3.ReadVector2i();
					PinnedLocations[key2] = val3.ReadString();
				}
			}
		}

		private static void SaveValue(Player player, string key, string value)
		{
			if (player.m_customData.ContainsKey(key))
			{
				player.m_customData[key] = value;
			}
			else
			{
				player.m_customData.Add(key, value);
			}
		}

		private static bool LoadValue(Player player, string key, out string value)
		{
			if (player.m_customData.TryGetValue(key, out value))
			{
				return true;
			}
			return false;
		}
	}
	public static class PlayerExtensions
	{
		public static void InitializeExplorationData(this Player player)
		{
			if (!((Object)(object)player == (Object)null) && !player.HasExplorationData())
			{
				((Component)player).gameObject.AddComponent<PlayerExplorationData>().Load(player);
			}
		}

		public static bool HasExplorationData(this Player player)
		{
			return (Object)(object)((player != null) ? ((Component)player).gameObject.GetComponent<PlayerExplorationData>() : null) != (Object)null;
		}

		public static PlayerExplorationData ExplorationData(this Player player)
		{
			if (player == null)
			{
				return null;
			}
			return ((Component)player).gameObject.GetComponent<PlayerExplorationData>();
		}
	}
	[BepInPlugin("com.milkwyzard.ExpertExplorer", "ExpertExplorer", "1.5.0")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[NetworkCompatibility(/*Could not decode attribute arguments.*/)]
	public class ExpertExplorer : BaseUnityPlugin
	{
		[CompilerGenerated]
		private sealed class <AutoPinLocation>d__53 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public ZoneData zoneData;

			public PlayerExplorationData explorationData;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <AutoPinLocation>d__53(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_001d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0027: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (object)new WaitForSeconds(1f);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					PinLocation(zoneData, explorationData);
					return false;
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		public const string PluginGUID = "com.milkwyzard.ExpertExplorer";

		public const string PluginName = "ExpertExplorer";

		public const string PluginVersion = "1.5.0";

		public const string SkillId = "com.milkwyzard.ExpertExplorer.Exploration";

		public static CustomLocalization Localization = LocalizationManager.Instance.GetLocalization();

		private Harmony harmony;

		private const float POST_INTRO_DELAY = 1f;

		private const float ZONE_CHECK_FREQUENCY = 1.5f;

		private const float ZONE_RPC_REQUEST_FREQUENCY = 2f;

		private static ZoneData currentZoneData = null;

		private static Vector2i currentZone;

		private static string lastEvaluatedLocation = string.Empty;

		private static float zoneCheckTimer = 0f;

		private static float zoneRpcRequestTimer = 0f;

		private static bool introLastFrame = false;

		private static bool locationsAvailable = false;

		private static Dictionary<Vector2i, ZoneData> zoneDataCache = new Dictionary<Vector2i, ZoneData>();

		private static Dictionary<Vector2i, Sprite> locationSpriteMap = new Dictionary<Vector2i, Sprite>();

		private static Dictionary<Vector2i, PinData> locationPins = new Dictionary<Vector2i, PinData>();

		private static List<string> specialLocations = new List<string>
		{
			"StartTemple", "Eikthyrnir", "Dragonqueen", "GoblinKing", "GDKing", "Bonemass", "Vendor_BlackForest", "Hildir_camp", "Mistlands_DvergrBossEntrance1", "MWL_PlainsTavern1",
			"MWL_PlainsCamp1", "MWL_BlackForestBlacksmith1", "MWL_BlackForestBlacksmith2", "MWL_MountainsBlacksmith1", "MWL_MistlandsBlacksmith1", "MWL_OceanTavern1"
		};

		private static List<string> dungeonLocations = new List<string>
		{
			"Mistlands_DvergrBossEntrance1", "Hildir_cave", "Hildir_crypt", "Crypt2", "Crypt3", "Crypt4", "Mistlands_DvergrTownEntrance1", "Mistlands_DvergrTownEntrance2", "MountainCave02", "SunkenCrypt4",
			"BFD_Exterior"
		};

		public static ConfigEntry<float> SkillXpFactor;

		public static ConfigEntry<float> MaxExploreRadius;

		public static ConfigEntry<float> DiscoverDistance;

		public static ConfigEntry<KeyboardShortcut> PinKey;

		public static ConfigEntry<KeyboardShortcut> PinPointOfInterest;

		public static ConfigEntry<KeyboardShortcut> PinOre;

		public static ConfigEntry<KeyboardShortcut> PinHome;

		public static ConfigEntry<KeyboardShortcut> PinCamp;

		public static ConfigEntry<KeyboardShortcut> PinDungeon;

		public static ConfigEntry<KeyboardShortcut> PinPortal;

		public static ConfigEntry<string> PinTextPointOfInterest;

		public static ConfigEntry<string> PinTextOre;

		public static ConfigEntry<string> PinTextHome;

		public static ConfigEntry<string> PinTextCamp;

		public static ConfigEntry<string> PinTextDungeon;

		public static ConfigEntry<string> PinTextPortal;

		public static ConfigEntry<bool> AutoPinDungeonLocations;

		public static ConfigEntry<bool> ShowLocationDiscoveryNotification;

		public static ConfigEntry<bool> PreferSailingModExploreRadius;

		public static SkillType ExplorationSkillType;

		public static bool SailingModDetected = false;

		public ExpertExplorer()
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Expected O, but got Unknown
			harmony = new Harmony("com.milkwyzard.ExpertExplorer");
		}

		public void Start()
		{
			harmony.PatchAll(Assembly.GetExecutingAssembly());
		}

		private void Awake()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Expected O, but got Unknown
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Expected O, but got Unknown
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Expected O, but got Unknown
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Expected O, but got Unknown
			//IL_00ea: 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_0149: Expected O, but got Unknown
			//IL_0171: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01df: Unknown result type (might be due to invalid IL or missing references)
			//IL_0216: 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_0284: Unknown result type (might be due to invalid IL or missing references)
			//IL_0391: Unknown result type (might be due to invalid IL or missing references)
			//IL_039b: Expected O, but got Unknown
			//IL_03c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c8: Expected O, but got Unknown
			//IL_03ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0404: Unknown result type (might be due to invalid IL or missing references)
			ConfigurationManagerAttributes val = new ConfigurationManagerAttributes
			{
				IsAdminOnly = true
			};
			SkillXpFactor = ((BaseUnityPlugin)this).Config.Bind<float>("General", "SkillXpFactor", 1.5f, new ConfigDescription("Factor applied to skill gain. Higher number means faster skill gain. Range 0-100.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 100f), new object[1] { val }));
			MaxExploreRadius = ((BaseUnityPlugin)this).Config.Bind<float>("Exploration", "MaxExploreRadius", 200f, new ConfigDescription("Max explore radius used when the Exploration Skill is at 100. Range 100-300.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(100f, 300f), new object[1] { val }));
			DiscoverDistance = ((BaseUnityPlugin)this).Config.Bind<float>("Exploration", "DiscoverDistance", 10f, new ConfigDescription("Distance between the player and the bounds of a location required to mark the location as discovered. Range 0-50.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 50f), new object[1] { val }));
			PinKey = ((BaseUnityPlugin)this).Config.Bind<KeyboardShortcut>("Hotkeys", "Pin to Mini-Map Key", new KeyboardShortcut((KeyCode)112, Array.Empty<KeyCode>()), "Hotkey used to add a pin to the mini-map when a new location is discovered.");
			AutoPinDungeonLocations = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "Auto-Pin Dungeon Locations", true, "Flag that can be set to have dungeons auto-pin to the map when discovered.");
			ShowLocationDiscoveryNotification = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "Show Location Discovery Notification", true, new ConfigDescription("Flag that can be set toggle whether a ui notification occurs when a location is discovered.", (AcceptableValueBase)null, new object[1] { val }));
			PinHome = ((BaseUnityPlugin)this).Config.Bind<KeyboardShortcut>("Hotkeys", "Pin Home Key", new KeyboardShortcut((KeyCode)256, (KeyCode[])(object)new KeyCode[1] { (KeyCode)305 }), "Hotkey used to add a home/town pin to the mini-map.");
			PinPointOfInterest = ((BaseUnityPlugin)this).Config.Bind<KeyboardShortcut>("Hotkeys", "Pin Point of Interest Key", new KeyboardShortcut((KeyCode)257, (KeyCode[])(object)new KeyCode[1] { (KeyCode)305 }), "Hotkey used to add a point of interest pin to the mini-map.");
			PinOre = ((BaseUnityPlugin)this).Config.Bind<KeyboardShortcut>("Hotkeys", "Pin Ore Key", new KeyboardShortcut((KeyCode)258, (KeyCode[])(object)new KeyCode[1] { (KeyCode)305 }), "Hotkey used to add an ore deposit pin to the mini-map.");
			PinCamp = ((BaseUnityPlugin)this).Config.Bind<KeyboardShortcut>("Hotkeys", "Pin Camp Key", new KeyboardShortcut((KeyCode)259, (KeyCode[])(object)new KeyCode[1] { (KeyCode)305 }), "Hotkey used to add a camp pin to the mini-map.");
			PinDungeon = ((BaseUnityPlugin)this).Config.Bind<KeyboardShortcut>("Hotkeys", "Pin Dungeon Key", new KeyboardShortcut((KeyCode)260, (KeyCode[])(object)new KeyCode[1] { (KeyCode)305 }), "Hotkey used to add a dungeon pin to the mini-map.");
			PinPortal = ((BaseUnityPlugin)this).Config.Bind<KeyboardShortcut>("Hotkeys", "Pin Portal Key", new KeyboardShortcut((KeyCode)261, (KeyCode[])(object)new KeyCode[1] { (KeyCode)305 }), "Hotkey used to add a portal pin to the mini-map.");
			PinTextHome = ((BaseUnityPlugin)this).Config.Bind<string>("Map Pin Text", "Pin Text Home", "Home or Town", "Text displayed when pinning a home location to the minimap with the keyboard shortcut.");
			PinTextPointOfInterest = ((BaseUnityPlugin)this).Config.Bind<string>("Map Pin Text", "Pin Text Point of Interest", "Point of Interest", "Text displayed when pinning a point of interest to the minimap with the keyboard shortcut.");
			PinTextOre = ((BaseUnityPlugin)this).Config.Bind<string>("Map Pin Text", "Pin Text Ore", "Ore Deposit", "Text displayed when pinning an ore deposit location to the minimap with the keyboard shortcut.");
			PinTextCamp = ((BaseUnityPlugin)this).Config.Bind<string>("Map Pin Text", "Pin Text Camp", "Camp", "Text displayed when pinning a camp location to the minimap with the keyboard shortcut.");
			PinTextDungeon = ((BaseUnityPlugin)this).Config.Bind<string>("Map Pin Text", "Pin Text Dungeon", "Crypt or Dungeon", "Text displayed when pinning a dungeon location to the minimap with the keyboard shortcut.");
			PinTextPortal = ((BaseUnityPlugin)this).Config.Bind<string>("Map Pin Text", "Pin Text Portal", "Portal", "Text displayed when pinning a portal to the minimap with the keyboard shortcut.");
			PreferSailingModExploreRadius = ((BaseUnityPlugin)this).Config.Bind<bool>("Compatibility", "PreferSailingModExploreRadius", true, new ConfigDescription("When the Sailing mod is present, this flag indicates that the sailing mod's explore radius should be used when sailing instead of the radius from this mod. Only affects sailing.", (AcceptableValueBase)null, new object[1] { val }));
			LocalizationManager.OnLocalizationAdded += OnLocalizationsAdded;
			ZoneManager.OnVanillaLocationsAvailable += OnVanillaLocationAvailable;
			SkillConfig val2 = new SkillConfig();
			val2.Identifier = "com.milkwyzard.ExpertExplorer.Exploration";
			val2.Name = "$skill_exploration";
			val2.Description = "$skill_exploration_desc";
			val2.IncreaseStep = SkillXpFactor.Value;
			ExplorationSkillType = SkillManager.Instance.AddSkill(val2);
			ZoneHelper.Instance.SetZoneDataAction = delegate(ZoneData zoneData)
			{
				SetZoneData(zoneData);
			};
			Logger.LogInfo((object)"ExpertExplorer v1.5.0 loaded and patched.");
		}

		private void OnLocalizationsAdded()
		{
			ResolveLocalizations();
			PluginInfo val = ((IEnumerable<PluginInfo>)Chainloader.PluginInfos.Values).FirstOrDefault((Func<PluginInfo, bool>)((PluginInfo p) => p.Metadata.GUID == "org.bepinex.plugins.sailing"));
			if (val != null)
			{
				SailingModDetected = true;
				Logger.LogWarning((object)(val.Metadata.Name + " mod detected. Using compatibility."));
			}
			else
			{
				SailingModDetected = false;
			}
		}

		private void OnVanillaLocationAvailable()
		{
			locationsAvailable = true;
		}

		private void Update()
		{
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: 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_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_02cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_014f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_0332: Unknown result type (might be due to invalid IL or missing references)
			//IL_0398: Unknown result type (might be due to invalid IL or missing references)
			//IL_034d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0363: Unknown result type (might be due to invalid IL or missing references)
			//IL_0369: Unknown result type (might be due to invalid IL or missing references)
			//IL_0304: Unknown result type (might be due to invalid IL or missing references)
			//IL_0121: Unknown result type (might be due to invalid IL or missing references)
			//IL_03fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_03cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0201: Unknown result type (might be due to invalid IL or missing references)
			//IL_0223: Unknown result type (might be due to invalid IL or missing references)
			//IL_0464: Unknown result type (might be due to invalid IL or missing references)
			//IL_0419: Unknown result type (might be due to invalid IL or missing references)
			//IL_042f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0435: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_047f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0495: Unknown result type (might be due to invalid IL or missing references)
			//IL_049b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0530: Unknown result type (might be due to invalid IL or missing references)
			//IL_04e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_04fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0501: Unknown result type (might be due to invalid IL or missing references)
			//IL_054b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0561: Unknown result type (might be due to invalid IL or missing references)
			//IL_0567: Unknown result type (might be due to invalid IL or missing references)
			if (ZInput.instance == null || !locationsAvailable || (Object)(object)Player.m_localPlayer == (Object)null)
			{
				return;
			}
			if (((Character)Player.m_localPlayer).InIntro())
			{
				introLastFrame = true;
			}
			else
			{
				if (((Character)Player.m_localPlayer).InCutscene())
				{
					return;
				}
				Vector3 position = ((Component)Player.m_localPlayer).transform.position;
				PlayerExplorationData playerExplorationData = Player.m_localPlayer.ExplorationData();
				if ((Object)(object)playerExplorationData == (Object)null)
				{
					Logger.LogWarning((object)"Update skipped because there is no exploration data.");
					return;
				}
				if (introLastFrame)
				{
					zoneCheckTimer = 1f;
					introLastFrame = false;
				}
				zoneCheckTimer = Mathf.Max(0f, zoneCheckTimer - Time.deltaTime);
				zoneRpcRequestTimer = Mathf.Max(0f, zoneRpcRequestTimer - Time.deltaTime);
				if (!((Character)Player.m_localPlayer).InInterior() && zoneCheckTimer == 0f)
				{
					Vector2i zone = ZoneSystem.GetZone(position);
					if (zone != currentZone)
					{
						currentZone = zone;
						zoneDataCache.TryGetValue(currentZone, out currentZoneData);
					}
					if (currentZoneData == null && zoneRpcRequestTimer == 0f)
					{
						zoneRpcRequestTimer = 2f;
						ZoneHelper.Instance.Client_RequestZoneData(currentZone);
					}
					zoneCheckTimer = 1.5f;
				}
				if (currentZoneData != null && currentZoneData.IsValid() && !playerExplorationData.IsZoneLocationAlreadyDiscovered(currentZone) && (IsLookingAtLocation(Player.m_localPlayer, currentZoneData) || IsInsideLocation(Player.m_localPlayer, currentZoneData)) && currentZoneData.LocationPrefab != lastEvaluatedLocation)
				{
					lastEvaluatedLocation = currentZoneData.LocationPrefab;
					playerExplorationData.FlagAsDiscovered(currentZoneData);
					playerExplorationData.Save(Player.m_localPlayer);
					((Character)Player.m_localPlayer).RaiseSkill(ExplorationSkillType, 1f);
					_ = "Discovered " + currentZoneData.LocalizedLocationName;
					Vector3 locationPosition = currentZoneData.LocationPosition;
					locationPosition.y = ZoneSystem.instance.GetGroundHeight(currentZoneData.LocationPosition) + ((Character)Player.m_localPlayer).GetHeight();
					Sprite value = null;
					locationSpriteMap.TryGetValue(currentZone, out value);
					if ((Object)(object)value == (Object)null)
					{
						Logger.LogInfo((object)("No sprite icon for location " + currentZoneData.LocationPrefab));
					}
					if (ShowLocationDiscoveryNotification.Value)
					{
						QueueFoundLocationMsg(value, "Location Discovered", currentZoneData.LocalizedLocationName, IsSpecialLocation(currentZoneData.LocationPrefab));
					}
					if (AutoPinDungeonLocations.Value && IsDungeonLocation(currentZoneData.LocationPrefab))
					{
						((MonoBehaviour)this).StartCoroutine(AutoPinLocation(currentZoneData, playerExplorationData));
					}
				}
				if (((Character)Player.m_localPlayer).TakeInput())
				{
					KeyboardShortcut value2 = PinKey.Value;
					if (ZInput.GetKeyDown(((KeyboardShortcut)(ref value2)).MainKey, true) && (IsLookingAtLocation(Player.m_localPlayer, currentZoneData) || IsInsideLocation(Player.m_localPlayer, currentZoneData)) && !locationPins.ContainsKey(currentZone) && !IsSpecialLocation(currentZoneData.LocationPrefab))
					{
						PinLocation(currentZoneData, playerExplorationData);
					}
					if (IsPinKeyPressed(PinHome.Value))
					{
						Minimap.instance.AddPin(((Component)Player.m_localPlayer).transform.position, (PinType)1, PinTextHome.Value, true, false, 0L, default(PlatformUserID));
						((Character)Player.m_localPlayer).Message((MessageType)1, PinTextHome.Value + " pinned to minimap.", 0, (Sprite)null);
					}
					if (IsPinKeyPressed(PinPointOfInterest.Value))
					{
						Minimap.instance.AddPin(((Component)Player.m_localPlayer).transform.position, (PinType)3, PinTextPointOfInterest.Value, true, false, 0L, default(PlatformUserID));
						((Character)Player.m_localPlayer).Message((MessageType)1, PinTextPointOfInterest.Value + " pinned to minimap.", 0, (Sprite)null);
					}
					if (IsPinKeyPressed(PinOre.Value))
					{
						Minimap.instance.AddPin(((Component)Player.m_localPlayer).transform.position, (PinType)2, PinTextOre.Value, true, false, 0L, default(PlatformUserID));
						((Character)Player.m_localPlayer).Message((MessageType)1, PinTextOre.Value + " pinned to minimap.", 0, (Sprite)null);
					}
					if (IsPinKeyPressed(PinCamp.Value))
					{
						Minimap.instance.AddPin(((Component)Player.m_localPlayer).transform.position, (PinType)0, PinTextCamp.Value, true, false, 0L, default(PlatformUserID));
						((Character)Player.m_localPlayer).Message((MessageType)1, PinTextCamp.Value + " pinned to minimap.", 0, (Sprite)null);
					}
					if (IsPinKeyPressed(PinDungeon.Value))
					{
						Minimap.instance.AddPin(((Component)Player.m_localPlayer).transform.position, (PinType)3, PinTextDungeon.Value, true, false, 0L, default(PlatformUserID));
						((Character)Player.m_localPlayer).Message((MessageType)1, PinTextDungeon.Value + " pinned to minimap.", 0, (Sprite)null);
					}
					if (IsPinKeyPressed(PinPortal.Value))
					{
						Minimap.instance.AddPin(((Component)Player.m_localPlayer).transform.position, (PinType)6, PinTextPortal.Value, true, false, 0L, default(PlatformUserID));
						((Character)Player.m_localPlayer).Message((MessageType)1, PinTextPortal.Value + " pinned to minimap.", 0, (Sprite)null);
					}
				}
			}
		}

		private bool IsPinKeyPressed(KeyboardShortcut pinKey)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			if (!ZInput.GetKeyDown(((KeyboardShortcut)(ref pinKey)).MainKey, true))
			{
				return false;
			}
			bool result = true;
			foreach (KeyCode modifier in ((KeyboardShortcut)(ref pinKey)).Modifiers)
			{
				if (!ZInput.GetKey(modifier, true))
				{
					result = false;
					Logger.LogInfo((object)$"Missing key modifier {modifier}");
					break;
				}
			}
			return result;
		}

		public static ZoneData GetCurrentLocation(Player player)
		{
			if (currentZoneData != null && currentZoneData.IsValid() && (((Character)player).InInterior() || IsLookingAtLocation(player, currentZoneData) || IsInsideLocation(player, currentZoneData)))
			{
				return currentZoneData;
			}
			return null;
		}

		public static bool IsSpecialLocation(string locationPrefabName)
		{
			return specialLocations.Contains(locationPrefabName);
		}

		public static bool IsDungeonLocation(string locationPrefabName)
		{
			return dungeonLocations.Contains(locationPrefabName);
		}

		public static void OnPinRemoved(PinData pinData)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: 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)
			Vector2i zone = ZoneSystem.GetZone(pinData.m_pos);
			if (locationPins.ContainsKey(zone) && locationPins[zone].m_name == pinData.m_name)
			{
				locationPins.Remove(zone);
				Player.m_localPlayer.ExplorationData()?.RemovePin(zone);
			}
		}

		[IteratorStateMachine(typeof(<AutoPinLocation>d__53))]
		private static IEnumerator AutoPinLocation(ZoneData zoneData, PlayerExplorationData explorationData)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <AutoPinLocation>d__53(0)
			{
				zoneData = zoneData,
				explorationData = explorationData
			};
		}

		private static void PinLocation(ZoneData zoneData, PlayerExplorationData explorationData)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			Vector3 locationPosition = zoneData.LocationPosition;
			Vector2i zoneId = zoneData.ZoneId;
			string localizedLocationName = zoneData.LocalizedLocationName;
			PinData val = Minimap.instance.AddPin(locationPosition, (PinType)3, localizedLocationName, true, false, 0L, default(PlatformUserID));
			locationPins[zoneId] = val;
			explorationData.FlagAsPinned(zoneId, val);
			((Character)Player.m_localPlayer).Message((MessageType)1, "Location pinned to minimap.", 0, (Sprite)null);
		}

		private static void SetZoneData(ZoneData zoneData)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: 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_0108: Unknown result type (might be due to invalid IL or missing references)
			//IL_010d: Unknown result type (might be due to invalid IL or missing references)
			//IL_010e: 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_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_012e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0139: Unknown result type (might be due to invalid IL or missing references)
			//IL_0149: Expected O, but got Unknown
			//IL_015a: Unknown result type (might be due to invalid IL or missing references)
			if (zoneData == null)
			{
				Logger.LogWarning((object)"SetZoneData called but ZoneData was null.");
			}
			else
			{
				if (!(currentZone == zoneData.ZoneId))
				{
					return;
				}
				zoneDataCache[currentZone] = zoneData;
				currentZoneData = zoneData;
				if (locationSpriteMap.ContainsKey(currentZone) || string.IsNullOrEmpty(zoneData.LocationPrefab))
				{
					return;
				}
				ZoneLocation zoneLocation = ZoneHelper.Instance.GetZoneLocation(zoneData.LocationPrefab);
				if (zoneLocation != null)
				{
					GameObject val = zoneLocation.GetLocationAsset();
					Location val2 = ((val != null) ? val.GetComponent<Location>() : null) ?? null;
					if ((Object)(object)val2 != (Object)null && val2.m_hasInterior)
					{
						Transform transform = ((Component)val2).transform;
						if ((Object)(object)transform != (Object)null)
						{
							for (int i = 0; i < transform.childCount; i++)
							{
								Transform child = transform.GetChild(i);
								if ((Object)(object)child != (Object)null && ((Object)child).name.ToLowerInvariant().Equals("exterior"))
								{
									val = ((Component)child).gameObject;
									break;
								}
							}
						}
					}
					if ((Object)(object)val != (Object)null)
					{
						Sprite val3 = RenderManager.Instance.Render(new RenderRequest(val)
						{
							Rotation = RenderManager.IsometricRotation,
							FieldOfView = 20f,
							DistanceMultiplier = 1.1f,
							Width = 256,
							Height = 256
						});
						if ((Object)(object)val3 != (Object)null)
						{
							locationSpriteMap[currentZone] = val3;
						}
					}
					else
					{
						Logger.LogWarning((object)("No asset prefab found for location " + zoneData.LocationPrefab + "."));
					}
				}
				else
				{
					Logger.LogWarning((object)("No zone location found for " + zoneData.LocationPrefab + "."));
				}
			}
		}

		private static bool IsLookingAtLocation(Player player, ZoneData zoneData)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: 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_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_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			float locationRadiusMax = zoneData.LocationRadiusMax;
			Vector3 position = ((Component)player).transform.position;
			float num = locationRadiusMax + DiscoverDistance.Value;
			bool result = false;
			if (Vector3.Distance(position, currentZoneData.LocationPosition) < num && Vector3.Angle(currentZoneData.LocationPosition - position, ((Component)Player.m_localPlayer).transform.forward) < 20f)
			{
				result = true;
			}
			return result;
		}

		private static bool IsInsideLocation(Player player, ZoneData zoneData)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			return Utils.DistanceXZ(((Component)player).transform.position, currentZoneData.LocationPosition) < zoneData.LocationRadiusMax;
		}

		public static void QueueFoundLocationMsg(Sprite icon, string topic, string description, bool isSpecialLocation)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Expected O, but got Unknown
			string text = description;
			KeyboardShortcut value = PinKey.Value;
			string text2 = ((object)(KeyboardShortcut)(ref value)).ToString();
			if (!isSpecialLocation)
			{
				text = text + "\nPress [<color=yellow><b>" + text2 + "</b></color>] to add a pin";
			}
			UnlockMsg val = new UnlockMsg();
			val.m_icon = icon;
			val.m_topic = topic;
			val.m_description = text;
			MessageHud.instance.m_unlockMsgQueue.Enqueue(val);
			MessageHud.instance.AddLog(topic + ": " + description);
		}

		public static string TryTranslate(string word)
		{
			CustomLocalization localization = Localization;
			return ((localization != null) ? localization.TryTranslate(word) : null) ?? word;
		}

		private void ResolveLocalizations()
		{
			try
			{
				DirectoryInfo directoryInfo = new DirectoryInfo(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location));
				Dictionary<string, List<FileInfo>> dictionary = new Dictionary<string, List<FileInfo>>();
				foreach (FileInfo item in directoryInfo.EnumerateFiles("*.json", SearchOption.TopDirectoryOnly))
				{
					string[] array = item.Name.Split(new char[1] { '.' }, StringSplitOptions.RemoveEmptyEntries);
					if (array.Length <= 2 || !(array.Last() == "json"))
					{
						continue;
					}
					string text = array[^2].Trim();
					if (LocalizationHelper.IsLanguageSupported(text))
					{
						if (!dictionary.ContainsKey(text))
						{
							dictionary.Add(text, new List<FileInfo>());
						}
						dictionary[text].Add(item);
					}
				}
				foreach (string key in dictionary.Keys)
				{
					if (Localization.GetLanguages().Contains(key))
					{
						continue;
					}
					foreach (FileInfo item2 in dictionary[key])
					{
						Localization.AddJsonFile(key, File.ReadAllText(item2.FullName));
						((BaseUnityPlugin)this).Logger.LogInfo((object)("Added localization file [" + item2.Name + "] from non-standard location."));
					}
				}
				foreach (string language in Localization.GetLanguages())
				{
					((BaseUnityPlugin)this).Logger.LogInfo((object)(language + " localization loaded and available."));
				}
			}
			catch (Exception)
			{
				((BaseUnityPlugin)this).Logger.LogError((object)"Error resolving localizations.");
			}
		}

		private void DebugTestLocalizations()
		{
			foreach (string language in Localization.GetLanguages())
			{
				string current = language;
				((BaseUnityPlugin)this).Logger.LogInfo((object)"---------------------------------------------------------------");
				((BaseUnityPlugin)this).Logger.LogInfo((object)("Localizations for " + current));
				foreach (KeyValuePair<string, string> translation in Localization.GetTranslations(ref current))
				{
					((BaseUnityPlugin)this).Logger.LogInfo((object)("\"" + translation.Key + "\": " + translation.Value));
				}
				((BaseUnityPlugin)this).Logger.LogInfo((object)"---------------------------------------------------------------");
			}
			string text = TryTranslate("$location_StartTemple");
			((BaseUnityPlugin)this).Logger.LogInfo((object)("Localization Test: " + text));
		}
	}
	public class ZoneData
	{
		public Vector2i ZoneId { get; set; }

		public string LocationPrefab { get; set; }

		public Vector3 LocationPosition { get; set; }

		public int LocationHash { get; set; }

		public float LocationRadiusMax { get; set; }

		public bool IsPlaced { get; set; }

		public string LocalizedLocationName { get; set; }

		public bool HasLocation { get; set; }

		public ZoneData()
		{
			//IL_0009: 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_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			ZoneId = default(Vector2i);
			LocationPrefab = string.Empty;
			LocationPosition = default(Vector3);
			LocationHash = 0;
			LocationRadiusMax = 0f;
			IsPlaced = false;
			LocalizedLocationName = string.Empty;
			HasLocation = false;
		}

		public bool IsValid()
		{
			if (HasLocation && !string.IsNullOrEmpty(LocationPrefab))
			{
				return IsPlaced;
			}
			return false;
		}
	}
	public sealed class ZoneHelper
	{
		private static readonly ZoneHelper instance;

		public Action<ZoneData> SetZoneDataAction;

		public static ZoneHelper Instance => instance;

		static ZoneHelper()
		{
			instance = new ZoneHelper();
		}

		private ZoneHelper()
		{
		}

		public void RegisterRPC(ZRoutedRpc routedRpc)
		{
			routedRpc.Register<int, int>("RequestZoneData", (Action<long, int, int>)RPC_RequestZoneData);
			routedRpc.Register<ZPackage>("SetZoneData", (Action<long, ZPackage>)RPC_SetZoneData);
		}

		public ZoneData GetZoneData(Vector2i zone)
		{
			//IL_0007: 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_0025: 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_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			ZoneData zoneData = new ZoneData();
			zoneData.ZoneId = zone;
			if (ZoneSystem.instance.m_locationInstances.TryGetValue(zone, out var value))
			{
				zoneData.LocationPrefab = ((value.m_location != null) ? value.m_location.m_prefabName : string.Empty);
				zoneData.LocationRadiusMax = ((value.m_location != null) ? Mathf.Max(value.m_location.m_exteriorRadius, value.m_location.m_interiorRadius) : 0f);
				zoneData.LocationPosition = value.m_position;
				zoneData.IsPlaced = value.m_placed;
				zoneData.LocalizedLocationName = ((value.m_location != null) ? GetLocationName(value.m_location.m_prefabName) : string.Empty);
				zoneData.HasLocation = value.m_location != null;
			}
			return zoneData;
		}

		public ZoneLocation GetZoneLocation(string zonePrefabName)
		{
			if (string.IsNullOrEmpty(zonePrefabName))
			{
				return null;
			}
			if ((Object)(object)ZoneSystem.instance == (Object)null)
			{
				return null;
			}
			if (ZoneSystem.instance.m_locations == null || ZoneSystem.instance.m_locations.Count == 0)
			{
				return null;
			}
			return ((IEnumerable<ZoneLocation>)ZoneSystem.instance.m_locations).FirstOrDefault((Func<ZoneLocation, bool>)((ZoneLocation l) => l.m_prefabName == zonePrefabName));
		}

		private string GetLocationName(string prefabName)
		{
			return ExpertExplorer.TryTranslate("$location_" + prefabName);
		}

		public void Client_RequestZoneData(Vector2i zone)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			ZRoutedRpc.instance.InvokeRoutedRPC("RequestZoneData", new object[2] { zone.x, zone.y });
		}

		private void RPC_RequestZoneData(long sender, int zoneX, int zoneY)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Expected O, but got Unknown
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			ZoneData zoneData = GetZoneData(new Vector2i(zoneX, zoneY));
			ZPackage val = new ZPackage();
			val.Write(zoneData.ZoneId);
			val.Write(zoneData.LocationPrefab);
			val.Write(zoneData.LocationPosition);
			val.Write(zoneData.LocationHash);
			val.Write(zoneData.LocationRadiusMax);
			val.Write(zoneData.IsPlaced);
			val.Write(zoneData.HasLocation);
			ZRoutedRpc.instance.InvokeRoutedRPC(sender, "SetZoneData", new object[1] { val });
		}

		private void RPC_SetZoneData(long sender, ZPackage zoneDataPkg)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			if (zoneDataPkg == null)
			{
				Logger.LogWarning((object)"Zone Data package was null.");
				return;
			}
			ZoneData zoneData = new ZoneData();
			zoneData.ZoneId = zoneDataPkg.ReadVector2i();
			zoneData.LocationPrefab = zoneDataPkg.ReadString();
			zoneData.LocationPosition = zoneDataPkg.ReadVector3();
			zoneData.LocationHash = zoneDataPkg.ReadInt();
			zoneData.LocationRadiusMax = zoneDataPkg.ReadSingle();
			zoneData.IsPlaced = zoneDataPkg.ReadBool();
			zoneData.HasLocation = zoneDataPkg.ReadBool();
			if (zoneData != null && zoneData.LocationPrefab != null)
			{
				zoneData.LocalizedLocationName = ExpertExplorer.TryTranslate("$location_" + zoneData.LocationPrefab);
			}
			SetZoneDataAction?.Invoke(zoneData);
		}
	}
	public static class ZoneLocationExtensions
	{
		public static GameObject GetLocationAsset(this ZoneLocation location)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			if (location == null)
			{
				return null;
			}
			_ = location.m_prefab;
			return location.m_prefab.Asset;
		}
	}
}
namespace ExpertExplorer.Patches
{
	[HarmonyPatch(typeof(ZNet), "Awake")]
	public static class ZNetPatch_Awake
	{
		public static void Postfix(ZNet __instance)
		{
			ZoneHelper.Instance.RegisterRPC(__instance.m_routedRpc);
		}
	}
	[HarmonyPatch]
	public static class MinimapPatch
	{
		private static TMP_Text m_LocationNameSmall;

		private static float miniMapHeight;

		[HarmonyPrefix]
		[HarmonyPatch(typeof(Minimap), "Explore", new Type[]
		{
			typeof(Vector3),
			typeof(float)
		})]
		private static void Explore(ref Minimap __instance, ref Vector3 p, ref float radius)
		{
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			bool flag = Player.m_localPlayer.m_attached && Player.m_localPlayer.m_attachedToShip;
			bool value = ExpertExplorer.PreferSailingModExploreRadius.Value;
			if (!(ExpertExplorer.SailingModDetected && flag && value))
			{
				float num = ((Character)Player.m_localPlayer).GetSkillLevel(ExpertExplorer.ExplorationSkillType) / 100f;
				radius = Mathf.Lerp(__instance.m_exploreRadius, ExpertExplorer.MaxExploreRadius.Value, num);
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(Minimap), "Awake")]
		private static void Awake(ref Minimap __instance)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: 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_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			Rect rect = ((Graphic)__instance.m_mapImageSmall).rectTransform.rect;
			miniMapHeight = ((Rect)(ref rect)).height;
			m_LocationNameSmall = Object.Instantiate<GameObject>(((Component)__instance.m_biomeNameSmall).gameObject, ((Component)__instance.m_biomeNameSmall).gameObject.transform.parent).GetComponent<TMP_Text>();
			if ((Object)(object)m_LocationNameSmall == (Object)null)
			{
				Logger.LogWarning((object)"Could not duplicate biome name text");
				return;
			}
			m_LocationNameSmall.text = "Location Text Test";
			m_LocationNameSmall.fontSize = 12f;
			((Transform)m_LocationNameSmall.rectTransform).position = new Vector3(((Transform)m_LocationNameSmall.rectTransform).position.x, ((Transform)m_LocationNameSmall.rectTransform).position.y + 25f, ((Transform)m_LocationNameSmall.rectTransform).position.z);
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(Minimap), "RemovePin", new Type[] { typeof(PinData) })]
		private static void RemovePin(ref Minimap __instance, ref PinData pin)
		{
			ExpertExplorer.OnPinRemoved(pin);
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(Minimap), "UpdateBiome")]
		private static void UpdateBiome(ref Minimap __instance, ref Player player)
		{
			UpdateLocation(player);
		}

		private static void UpdateLocation(Player localPlayer)
		{
			ZoneData currentLocation = ExpertExplorer.GetCurrentLocation(localPlayer);
			string text = ((currentLocation != null) ? currentLocation.LocalizedLocationName : string.Empty);
			m_LocationNameSmall.text = text;
		}
	}
	[HarmonyPatch]
	public static class PlayerPatch
	{
		[HarmonyPostfix]
		[HarmonyPatch(typeof(Player), "Load")]
		private static void Load(ref Player __instance, ref ZPackage pkg)
		{
			__instance.InitializeExplorationData();
			__instance.ExplorationData().Load(__instance);
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(Player), "Save")]
		private static void Save(ref Player __instance, ref ZPackage pkg)
		{
			__instance.InitializeExplorationData();
			__instance.ExplorationData().Save(__instance);
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(Player), "AddKnownBiome")]
		private static void AddKnownBiome(ref Player __instance, ref Biome biome)
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			if (!__instance.IsBiomeKnown(biome))
			{
				PlayerExplorationData playerExplorationData = Player.m_localPlayer.ExplorationData();
				if ((Object)(object)playerExplorationData != (Object)null)
				{
					playerExplorationData.FlagAsDiscovered(biome);
					((Character)__instance).RaiseSkill(ExpertExplorer.ExplorationSkillType, 1f);
				}
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(Player), "OnSpawned")]
		private static void OnSpawned(ref Player __instance)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			if (!((Character)__instance).InIntro() && !Game.instance.m_firstSpawn)
			{
				Vector2i zone = ZoneSystem.GetZone(((Component)__instance).transform.position);
				ZoneHelper.Instance.Client_RequestZoneData(zone);
			}
		}
	}
}