using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Logging;
using HarmonyLib;
using Jotunn.Configs;
using Jotunn.Entities;
using Jotunn.Managers;
using Jotunn.Utils;
using Microsoft.CodeAnalysis;
using Splatform;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETFramework,Version=v4.6.2", FrameworkDisplayName = ".NET Framework 4.6.2")]
[assembly: AssemblyCompany("RuneTablet")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+5c5184f8fb1729c07283e4a8f38a1ad7df2c259a")]
[assembly: AssemblyProduct("Make a rune tablet to locate dungeons")]
[assembly: AssemblyTitle("RuneTablet")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace RuneTablet
{
	public static class Helper
	{
		private static Dictionary<string, string> PinNames = new Dictionary<string, string>
		{
			{ "Crypt2", "$location_forestcrypt" },
			{ "Crypt3", "$location_forestcrypt" },
			{ "Crypt4", "$location_forestcrypt" },
			{ "Mistlands_DvergrTownEntrance1", "$location_dvergrtown" },
			{ "Mistlands_DvergrTownEntrance2", "$location_dvergrtown" },
			{ "Hildir_crypt", "$hud_pin_hildir1" },
			{ "Hildir_cave", "$hud_pin_hildir2" },
			{ "Hildir_plainsfortress", "$hud_pin_hildir3" },
			{ "MountainCave02", "$location_mountaincave" },
			{ "GoblinCamp2", "$enemy_goblin" },
			{ "SunkenCrypt4", "$location_sunkencrypt" },
			{ "MorgenHole1", "$location_morgenhole" },
			{ "MorgenHole2", "$location_morgenhole" },
			{ "MorgenHole3", "$location_morgenhole" }
		};

		public static string GetHashedName(RuneStone component)
		{
			//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_000d: 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)
			Vector3 position = ((Component)component).transform.position;
			int num = (int)position.x * 31 + (int)position.z * 37;
			return ((Object)component).name + "-" + num;
		}

		public static LocationInstance? GetLocationInstance(Location location)
		{
			//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_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			Vector2i zone = ZoneSystem.GetZone(((Component)location).transform.position);
			if (!ZoneSystem.instance.m_locationInstances.TryGetValue(zone, out var value))
			{
				return null;
			}
			return value;
		}

		public static string GetHashedName(Location location)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			LocationInstance? locationInstance = GetLocationInstance(location);
			if (locationInstance.HasValue)
			{
				return GetHashedName(locationInstance.Value);
			}
			Plugin.Logger.LogError((object)("Could not find location instance for " + ((Object)location).name));
			return null;
		}

		public static string GetHashedName(LocationInstance instance)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//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_0018: 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_0032: Unknown result type (might be due to invalid IL or missing references)
			Vector2i zone = ZoneSystem.GetZone(instance.m_position);
			string name = ZNet.World.m_name;
			string name2 = instance.m_location.m_prefab.Name;
			int num = zone.x * 31 + zone.y * 37;
			return $"{name}-{name2}-{num}";
		}

		public static string GetPinName(string locationName)
		{
			string value;
			return PinNames.TryGetValue(locationName, out value) ? value : locationName;
		}
	}
	[HarmonyPatch(typeof(Player))]
	public class PlayerPatches
	{
		[HarmonyPostfix]
		[HarmonyPatch("Save")]
		public static void SavePostfix()
		{
			if (!((Object)(object)Player.m_localPlayer == (Object)null))
			{
				Plugin.SaveToDisk();
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch("Load")]
		public static void LoadPostfix()
		{
			if (!((Object)(object)Player.m_localPlayer == (Object)null))
			{
				Plugin.LoadFromDisk();
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch("ConsumeItem")]
		public static bool ConsumeItemPrefix(Inventory inventory, ItemData item, ref Player __instance, ref bool __result)
		{
			if (item.m_shared.m_name != "$item_runetablet")
			{
				return true;
			}
			Plugin.Logger.LogInfo((object)"Player.ConsumeItem: Called on Rune Tablet");
			__result = RuneTablet.Consume(__instance);
			if (__result)
			{
				InventoryGui.instance.Hide();
				inventory.RemoveItem(item);
			}
			return false;
		}
	}
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInPlugin("org.bepinex.plugins.rune_tablet", "Rune Tablet", "1.1.0")]
	public class Plugin : BaseUnityPlugin
	{
		public const string RuneTabletGuid = "org.bepinex.plugins.rune_tablet";

		public const string RuneTabletName = "Rune Tablet";

		public const string NumericVersion = "1.1.0";

		private static readonly GameVersion MinSupportedGameVersion = new GameVersion(0, 219, 10);

		public static List<string> FoundRuneStones = new List<string>();

		public static List<string> FoundDungeons = new List<string>();

		private CustomLocalization Localization;

		private static readonly Harmony Harmony = new Harmony("mod.rune_tablet");

		public static string SaveFile
		{
			get
			{
				Player localPlayer = Player.m_localPlayer;
				string text = ((localPlayer != null) ? localPlayer.GetPlayerName() : null);
				if (string.IsNullOrEmpty(text) || text == "...")
				{
					return null;
				}
				text += "_runetablet.fch";
				return Path.Combine(Utils.GetSaveDataPath((FileSource)3), text);
			}
		}

		public static ManualLogSource Logger { get; private set; }

		private static bool IsGameVersionTooOld()
		{
			//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)
			return Version.CurrentVersion < MinSupportedGameVersion;
		}

		private void Awake()
		{
			Logger = ((BaseUnityPlugin)this).Logger;
			Logger.LogInfo((object)("Valheim game version: " + Version.GetVersionString(false)));
			if (IsGameVersionTooOld())
			{
				LogTooOld();
				Logger.LogFatal((object)"Aborting loading of Rune Tablet due to incompatible version.");
				return;
			}
			LoadAssets();
			AddLocalization();
			PrefabManager.OnVanillaPrefabsAvailable += AddClonedItems;
			Harmony.PatchAll();
			Logger.LogInfo((object)"Rune Tablet done loading.");
		}

		private void AddLocalization()
		{
			Localization = LocalizationManager.Instance.GetLocalization();
			CustomLocalization localization = Localization;
			string text = "English";
			localization.AddTranslation(ref text, new Dictionary<string, string>
			{
				{ "item_runecrystal", "Rune Crystal" },
				{ "item_runecrystal_desc", "A potent source of energy from a runestone" },
				{ "item_runetablet", "Rune Tablet" },
				{ "item_runetablet_desc", "A mysterious tablet inscribed with runes glowing with energy." }
			});
		}

		private void LoadAssets()
		{
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: 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)
			string directoryName = Path.GetDirectoryName(((BaseUnityPlugin)this).Info.Location);
			Texture2D val = AssetUtils.LoadTexture(Path.Combine(directoryName, "Assets/rune_crystal.png"), true);
			Texture2D val2 = AssetUtils.LoadTexture(Path.Combine(directoryName, "Assets/rune_tablet.png"), true);
			RuneCrystal.IconSprite = Sprite.Create(val, new Rect(0f, 0f, (float)((Texture)val).width, (float)((Texture)val).height), Vector2.zero);
			RuneTablet.IconSprite = Sprite.Create(val2, new Rect(0f, 0f, (float)((Texture)val2).width, (float)((Texture)val2).height), Vector2.zero);
		}

		private void AddClonedItems()
		{
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			RuneCrystal runeCrystal = new RuneCrystal();
			RuneTablet runeTablet = new RuneTablet();
			ItemManager.Instance.AddItem((CustomItem)(object)runeCrystal);
			ItemManager.Instance.AddItem((CustomItem)(object)runeTablet);
			((CustomItem)runeTablet).ItemDrop.m_itemData.m_shared.m_itemType = (ItemType)2;
			PrefabManager.OnVanillaPrefabsAvailable -= AddClonedItems;
		}

		public static void SaveLocation(LocationInstance instance)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			string hashedName = Helper.GetHashedName(instance);
			if (!FoundDungeons.Contains(hashedName))
			{
				FoundDungeons.Add(hashedName);
				Logger.LogInfo((object)("Saved location " + hashedName));
			}
		}

		public static void RecoverPins()
		{
			//IL_0022: 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_0049: 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_0076: 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_0096: Unknown result type (might be due to invalid IL or missing references)
			foreach (KeyValuePair<Vector2i, LocationInstance> locationInstance in ZoneSystem.instance.m_locationInstances)
			{
				string hashedName = Helper.GetHashedName(locationInstance.Value);
				if (FoundDungeons.Contains(hashedName) && !Minimap.instance.HavePinInRange(locationInstance.Value.m_position, 14f))
				{
					Minimap.instance.AddPin(locationInstance.Value.m_position, (PinType)14, Helper.GetPinName(locationInstance.Value.m_location.m_prefabName), true, false, 0L, default(PlatformUserID));
				}
			}
		}

		private static void LogTooOld()
		{
			//IL_0010: 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)
			Logger.LogError((object)("This version of Rune Tablet (1.1.0) expects a minimum game version of " + $"\"{MinSupportedGameVersion}\", but this game version is older at \"{Version.CurrentVersion}\". " + "Please either update the Valheim game, or use an older version of Rune Tablet."));
		}

		public static void SaveToDisk()
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Expected O, but got Unknown
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Expected O, but got Unknown
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Expected O, but got Unknown
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Expected O, but got Unknown
			if (SaveFile == null)
			{
				Logger.LogError((object)"Something went wrong when trying to save to disk");
				return;
			}
			ZPackage val = new ZPackage();
			ZPackage val2 = new ZPackage();
			foreach (string foundRuneStone in FoundRuneStones)
			{
				val2.Write(foundRuneStone);
			}
			ZPackage val3 = new ZPackage();
			foreach (string foundDungeon in FoundDungeons)
			{
				val3.Write(foundDungeon);
			}
			val.Write(FoundRuneStones.Count);
			val.Write(val2);
			val.Write(FoundDungeons.Count);
			val.Write(val3);
			byte[] array = val.GetArray();
			try
			{
				FileWriter val4 = new FileWriter(SaveFile, (FileHelperType)0, (FileSource)1);
				val4.m_binary.Write(array.Length);
				val4.m_binary.Write(array);
				val4.Finish();
			}
			catch (Exception ex)
			{
				Logger.LogWarning((object)("Error saving CoinPurse data: Path: " + SaveFile + ", Error: " + ex.Message));
			}
		}

		public static void LoadFromDisk()
		{
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Expected O, but got Unknown
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Expected O, but got Unknown
			if (SaveFile == null)
			{
				Logger.LogError((object)"Something went wrong when trying to load from disk");
				return;
			}
			if (!File.Exists(SaveFile))
			{
				File.Create(SaveFile).Close();
				return;
			}
			FoundRuneStones.Clear();
			FoundDungeons.Clear();
			FileReader val;
			try
			{
				val = new FileReader(SaveFile, (FileSource)1, (FileHelperType)0);
			}
			catch (Exception ex)
			{
				Logger.LogWarning((object)("Error loading RuneTablet data: Path: " + SaveFile + ", Error: " + ex.Message));
				return;
			}
			try
			{
				BinaryReader binary = val.m_binary;
				byte[] array = binary.ReadBytes(binary.ReadInt32());
				ZPackage val2 = new ZPackage(array);
				int num = val2.ReadInt();
				ZPackage val3 = val2.ReadPackage();
				int num2 = val2.ReadInt();
				ZPackage val4 = val2.ReadPackage();
				for (int i = 0; i < num; i++)
				{
					FoundRuneStones.Add(val3.ReadString());
				}
				for (int j = 0; j < num2; j++)
				{
					FoundDungeons.Add(val4.ReadString());
				}
			}
			catch (Exception ex2)
			{
				Logger.LogWarning((object)("Error loading RuneTablet data: Path: " + SaveFile + ", Error: " + ex2.Message));
			}
			finally
			{
				if (val != null)
				{
					val.Dispose();
				}
			}
		}
	}
	public class RuneCrystal : CustomItem
	{
		internal static Sprite IconSprite;

		public RuneCrystal()
			: base("RuneCrystal", true, new ItemConfig
			{
				Name = "$item_runecrystal",
				Description = "$item_runecrystal_desc",
				StackSize = 10,
				Weight = 1f,
				Icon = IconSprite
			})
		{
		}//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_0018: Unknown result type (might be due to invalid IL or missing references)
		//IL_0024: Unknown result type (might be due to invalid IL or missing references)
		//IL_002c: 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_0049: Expected O, but got Unknown

	}
	[HarmonyPatch(typeof(RuneStone), "Interact")]
	public class RuneStoneInteractPatch
	{
		public static void Postfix(Humanoid character, bool hold, bool alt, RuneStone __instance)
		{
			Plugin.Logger.LogInfo((object)"RuneStone.Interact: Called");
			string hashedName = Helper.GetHashedName(__instance);
			Plugin.Logger.LogInfo((object)("RuneStone.Interact: Found runestone " + hashedName));
			if (!Plugin.FoundRuneStones.Contains(hashedName))
			{
				GameObject prefab = PrefabManager.Instance.GetPrefab("RuneCrystal");
				if (character.m_inventory.CanAddItem(prefab, -1))
				{
					((Humanoid)Player.m_localPlayer).m_inventory.AddItem(prefab, 1);
					((Character)Player.m_localPlayer).Message((MessageType)1, "A mysterious crystal falls into your hand.", 0, (Sprite)null);
					Plugin.FoundRuneStones.Add(hashedName);
				}
			}
		}
	}
	public class RuneTablet : CustomItem
	{
		internal static Sprite IconSprite;

		private static Dictionary<Biome, string[]> BiomeDungeons = new Dictionary<Biome, string[]>
		{
			{
				(Biome)32,
				Array.Empty<string>()
			},
			{
				(Biome)8,
				new string[4] { "Hildir_crypt", "Crypt2", "Crypt3", "Crypt4" }
			},
			{
				(Biome)512,
				new string[2] { "Mistlands_DvergrTownEntrance1", "Mistlands_DvergrTownEntrance2" }
			},
			{
				(Biome)64,
				new string[2] { "Hildir_cave", "MountainCave02" }
			},
			{
				(Biome)4,
				new string[2] { "Hildir_cave", "MountainCave02" }
			},
			{
				(Biome)16,
				new string[4] { "GoblinCamp2", "StoneTower1", "StoneTower3", "Hildir_plainsfortress" }
			},
			{
				(Biome)2,
				new string[1] { "SunkenCrypt4" }
			}
		};

		public RuneTablet()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Expected O, but got Unknown
			//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_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Expected O, but got Unknown
			//IL_0063: 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_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Expected O, but got Unknown
			ItemConfig val = new ItemConfig();
			val.Name = "$item_runetablet";
			val.Description = "$item_runetablet_desc";
			val.CraftingStation = CraftingStations.Workbench;
			val.Icon = IconSprite;
			val.Requirements = (RequirementConfig[])(object)new RequirementConfig[2]
			{
				new RequirementConfig
				{
					Item = "Stone",
					Amount = 10
				},
				new RequirementConfig
				{
					Item = "RuneCrystal",
					Amount = 4
				}
			};
			val.Weight = 10f;
			((CustomItem)this)..ctor("RuneTablet", true, val);
		}

		public static bool Consume(Player player)
		{
			//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_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Invalid comparison between Unknown and I4
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)player == (Object)null)
			{
				Plugin.Logger.LogWarning((object)"Player.ConsumeItem: Called with null player");
				return false;
			}
			Biome currentBiome = player.GetCurrentBiome();
			Plugin.Logger.LogInfo((object)("Player.ConsumeItem: Called in biome " + ((object)(Biome)(ref currentBiome)).ToString()));
			if (((Enum)currentBiome).HasFlag((Enum)(object)(Biome)256) || ((Enum)currentBiome).HasFlag((Enum)(object)(Biome)1))
			{
				((Character)player).Message((MessageType)2, "Cannot use that in this biome.", 0, (Sprite)null);
				return false;
			}
			foreach (object value in Enum.GetValues(typeof(Biome)))
			{
				Biome val = (Biome)value;
				if ((int)val == 0 || (int)val == 895 || !((Enum)currentBiome).HasFlag((Enum)(object)val) || !player.IsBiomeKnown(val))
				{
					continue;
				}
				return DiscoverNearestDungeon(player, val);
			}
			return false;
		}

		private static Tuple<string, Vector3> FindClosestLocationFromTypes(string[] types, Vector3 point)
		{
			//IL_0003: 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_0069: 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_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: 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_00e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			string text = null;
			Vector3 item = Vector3.zero;
			float num = float.PositiveInfinity;
			List<LocationInstance> list = new List<LocationInstance>();
			foreach (string text2 in types)
			{
				List<LocationInstance> collection = new List<LocationInstance>();
				if (ZoneSystem.instance.FindLocations(text2, ref collection))
				{
					list.AddRange(collection);
				}
			}
			foreach (LocationInstance item2 in list)
			{
				string name = item2.m_location.m_prefab.Name;
				if (Minimap.instance.HavePinInRange(item2.m_position, 14f))
				{
					Plugin.SaveLocation(item2);
					continue;
				}
				string hashedName = Helper.GetHashedName(item2);
				if (!Plugin.FoundDungeons.Contains(hashedName))
				{
					float num2 = Vector3.Distance(point, item2.m_position);
					if (num2 < num)
					{
						text = name;
						item = item2.m_position;
						num = num2;
					}
				}
			}
			if (string.IsNullOrEmpty(text))
			{
				return null;
			}
			return new Tuple<string, Vector3>(text, item);
		}

		public static bool DiscoverNearestDungeon(Player player, Biome biome)
		{
			//IL_0006: 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_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			if (!BiomeDungeons.TryGetValue(biome, out var value))
			{
				Plugin.Logger.LogWarning((object)$"DiscoverNearestDungeon: Invalid biome {biome}");
				return false;
			}
			Vector3 position = ((Component)player).transform.position;
			Tuple<string, Vector3> tuple = FindClosestLocationFromTypes(value, position);
			if (tuple == null)
			{
				((Character)Player.m_localPlayer).Message((MessageType)2, "<color=red>No locations found</color>", 0, (Sprite)null);
				Plugin.Logger.LogWarning((object)"DiscoverNearestDungeon: No locations found");
				return false;
			}
			Vector3 item = tuple.Item2;
			string text = Localization.instance.Localize(Helper.GetPinName(tuple.Item1));
			return Minimap.instance.DiscoverLocation(item, (PinType)14, text, true);
		}
	}
	[HarmonyPatch(typeof(Teleport), "Interact")]
	public class Teleport_Interact_Patch
	{
		private static void Postfix(Humanoid character, Teleport __instance, ref bool __result)
		{
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			if (!__result || !((Character)character).InInterior())
			{
				return;
			}
			Teleport targetPoint = __instance.m_targetPoint;
			Location componentInParent = ((Component)targetPoint).GetComponentInParent<Location>();
			if (!((Object)(object)componentInParent == (Object)null))
			{
				LocationInstance? locationInstance = Helper.GetLocationInstance(componentInParent);
				if (locationInstance.HasValue)
				{
					Plugin.SaveLocation(locationInstance.Value);
				}
				else
				{
					Plugin.Logger.LogError((object)("Could not find location instance for " + ((Object)componentInParent).name));
				}
			}
		}
	}
	public static class MyPluginInfo
	{
		public const string PLUGIN_GUID = "RuneTablet";

		public const string PLUGIN_NAME = "Make a rune tablet to locate dungeons";

		public const string PLUGIN_VERSION = "1.0.0";
	}
}