using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using GC.Client.AutoDoor;
using GC.Client.CarryLimit;
using GC.Client.CartCollect;
using GC.Client.Compare;
using GC.Client.Compass;
using GC.Client.DungeonMap;
using GC.Client.MassHarvest;
using GC.Client.PortalGuard;
using GC.Client.QuickTake;
using GC.Client.Sort;
using GC.Client.Trash;
using GC.Shared;
using HarmonyLib;
using Jotunn.Managers;
using Jotunn.Utils;
using Microsoft.CodeAnalysis;
using TMPro;
using UnityEngine;
using UnityEngine.Events;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: <37f69a44-49ab-4fd2-ab96-bf7462024aca>IgnoresAccessChecksTo("assembly_guiutils")]
[assembly: <37f69a44-49ab-4fd2-ab96-bf7462024aca>IgnoresAccessChecksTo("assembly_utils")]
[assembly: <37f69a44-49ab-4fd2-ab96-bf7462024aca>IgnoresAccessChecksTo("assembly_valheim")]
[assembly: TargetFramework(".NETFramework,Version=v4.8.1", FrameworkDisplayName = ".NET Framework 4.8.1")]
[assembly: AssemblyCompany("Gorduan")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.7.0.0")]
[assembly: AssemblyInformationalVersion("1.7.0+c9d5288b96ac31e780ee94b8f27fd48c2d248dff")]
[assembly: AssemblyProduct("GC_Client")]
[assembly: AssemblyTitle("GC_Client")]
[assembly: <02fd42c7-9979-487e-9c2f-76661a523373>IgnoresAccessChecksTo("assembly_guiutils")]
[assembly: <02fd42c7-9979-487e-9c2f-76661a523373>IgnoresAccessChecksTo("assembly_utils")]
[assembly: <02fd42c7-9979-487e-9c2f-76661a523373>IgnoresAccessChecksTo("assembly_valheim")]
[assembly: <5ee8f811-bd99-4463-b934-5528eb07a3d5>IgnoresAccessChecksTo("assembly_guiutils")]
[assembly: <5ee8f811-bd99-4463-b934-5528eb07a3d5>IgnoresAccessChecksTo("assembly_utils")]
[assembly: <5ee8f811-bd99-4463-b934-5528eb07a3d5>IgnoresAccessChecksTo("assembly_valheim")]
[assembly: <197c1f94-b781-4c1b-9076-9b8adab7750f>IgnoresAccessChecksTo("assembly_guiutils")]
[assembly: <197c1f94-b781-4c1b-9076-9b8adab7750f>IgnoresAccessChecksTo("assembly_utils")]
[assembly: <197c1f94-b781-4c1b-9076-9b8adab7750f>IgnoresAccessChecksTo("assembly_valheim")]
[assembly: <c1acd51f-b3b7-4440-a8e6-6769e04434a6>IgnoresAccessChecksTo("assembly_guiutils")]
[assembly: <c1acd51f-b3b7-4440-a8e6-6769e04434a6>IgnoresAccessChecksTo("assembly_utils")]
[assembly: <c1acd51f-b3b7-4440-a8e6-6769e04434a6>IgnoresAccessChecksTo("assembly_valheim")]
[assembly: <e3727a32-ffa0-41ce-99c9-4ddf745169a4>IgnoresAccessChecksTo("assembly_guiutils")]
[assembly: <e3727a32-ffa0-41ce-99c9-4ddf745169a4>IgnoresAccessChecksTo("assembly_utils")]
[assembly: <e3727a32-ffa0-41ce-99c9-4ddf745169a4>IgnoresAccessChecksTo("assembly_valheim")]
[assembly: <34a107b2-9b31-4213-baee-ba0bef277eac>IgnoresAccessChecksTo("assembly_guiutils")]
[assembly: <34a107b2-9b31-4213-baee-ba0bef277eac>IgnoresAccessChecksTo("assembly_utils")]
[assembly: <34a107b2-9b31-4213-baee-ba0bef277eac>IgnoresAccessChecksTo("assembly_valheim")]
[assembly: <fdaea21d-170e-4e2a-aeef-01470ca17251>IgnoresAccessChecksTo("assembly_guiutils")]
[assembly: <fdaea21d-170e-4e2a-aeef-01470ca17251>IgnoresAccessChecksTo("assembly_utils")]
[assembly: <fdaea21d-170e-4e2a-aeef-01470ca17251>IgnoresAccessChecksTo("assembly_valheim")]
[assembly: <64de2ee8-d827-423f-b586-6bad830e8e99>IgnoresAccessChecksTo("assembly_guiutils")]
[assembly: <64de2ee8-d827-423f-b586-6bad830e8e99>IgnoresAccessChecksTo("assembly_utils")]
[assembly: <64de2ee8-d827-423f-b586-6bad830e8e99>IgnoresAccessChecksTo("assembly_valheim")]
[assembly: <23849cb3-d487-4266-a2a8-10a7a6b42c46>IgnoresAccessChecksTo("assembly_guiutils")]
[assembly: <23849cb3-d487-4266-a2a8-10a7a6b42c46>IgnoresAccessChecksTo("assembly_utils")]
[assembly: <23849cb3-d487-4266-a2a8-10a7a6b42c46>IgnoresAccessChecksTo("assembly_valheim")]
[assembly: <eaccbbd9-7910-4348-b0e5-99fc37b2a7bf>IgnoresAccessChecksTo("assembly_guiutils")]
[assembly: <eaccbbd9-7910-4348-b0e5-99fc37b2a7bf>IgnoresAccessChecksTo("assembly_utils")]
[assembly: <eaccbbd9-7910-4348-b0e5-99fc37b2a7bf>IgnoresAccessChecksTo("assembly_valheim")]
[assembly: IgnoresAccessChecksTo("assembly_guiutils")]
[assembly: IgnoresAccessChecksTo("assembly_utils")]
[assembly: IgnoresAccessChecksTo("assembly_valheim")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.7.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[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;
		}
	}
	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
	internal sealed class <37f69a44-49ab-4fd2-ab96-bf7462024aca>IgnoresAccessChecksToAttribute : Attribute
	{
		public <37f69a44-49ab-4fd2-ab96-bf7462024aca>IgnoresAccessChecksToAttribute(string assemblyName)
		{
		}
	}
	[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 GC.Client
{
	internal static class <02fd42c7-9979-487e-9c2f-76661a523373>ClientPlugin
	{
		internal static ManualLogSource Log;

		internal static GcModule? Module;

		internal static bool Allowed
		{
			get
			{
				if (Module != null)
				{
					return Module.Allowed;
				}
				return true;
			}
		}

		internal static bool OnServer
		{
			get
			{
				if (Module != null)
				{
					return Module.OnServer;
				}
				return false;
			}
		}
	}
}
namespace GC.Client.ModDungeonKarte
{
	[BepInPlugin("gorduan.gc.dungeonkarte", "GC_DungeonKarte", "1.7.0")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[NetworkCompatibility(/*Could not decode attribute arguments.*/)]
	public class Plugin : BaseUnityPlugin
	{
		internal static GcModule Module;

		private void Awake()
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Expected O, but got Unknown
			Module = GcKern.Register((BaseUnityPlugin)(object)this, ((BaseUnityPlugin)this).Logger, GcMod.Info);
			<02fd42c7-9979-487e-9c2f-76661a523373>ClientPlugin.Log = ((BaseUnityPlugin)this).Logger;
			<02fd42c7-9979-487e-9c2f-76661a523373>ClientPlugin.Module = Module;
			Harmony harmony = new Harmony("gorduan.gc.dungeonkarte");
			GC.Client.DungeonMap.Plugin.Init(((BaseUnityPlugin)this).Config, harmony);
			Module.TakeOverOldSettings();
			GcHooks.DungeonMapLargeOpen = () => GC.Client.DungeonMap.Plugin.View != null && GC.Client.DungeonMap.Plugin.View.LargeOpen;
			GcMod.PatchAll(harmony);
			Module.MenuGroup((Func<string, string>)((string key) => GcLoc.Get("gccm_" + key, Array.Empty<object>())), (string)null).Main("dungeonmap", (ConfigEntryBase)(object)GC.Client.DungeonMap.Plugin.Enabled, (Func<bool>)(() => GC.Client.DungeonMap.Plugin.Blocked), "GC_DungeonMap", (Func<string>)null, 0.0, "", (Func<bool>)null, (Func<bool>)null, (Func<string>)null).Sub("dungeonmap_size", (ConfigEntryBase)(object)GC.Client.DungeonMap.Plugin.SmallSize, 20.0, " px", (Func<bool>)null, "", (Func<bool>)null, (Func<bool>)null, (Func<string>)null)
				.Sub("dungeonmap_zoom", (ConfigEntryBase)(object)GC.Client.DungeonMap.Plugin.SmallZoom, 0.5, "", (Func<bool>)null, "", (Func<bool>)null, (Func<bool>)null, (Func<string>)null)
				.Sub("dungeonmap_minimap", (ConfigEntryBase)(object)GC.Client.DungeonMap.Plugin.HideVanillaMinimap, 0.0, "", (Func<bool>)null, "", (Func<bool>)null, (Func<bool>)null, (Func<string>)null);
		}

		private void Update()
		{
			if (!Gc.IsHeadless)
			{
				Module.Guard("Dungeon-Karte", (Action)GC.Client.DungeonMap.Plugin.Update);
			}
		}
	}
	internal static class GcMod
	{
		public const string Id = "dungeonkarte";

		public const string Guid = "gorduan.gc.dungeonkarte";

		public const string Name = "GC_DungeonKarte";

		public const string Version = "1.7.0";

		public const int Stufe = 3;

		public static readonly Type[] PatchTypes = new Type[3]
		{
			typeof(MapModePatch),
			typeof(MenuEscPatch),
			typeof(PlayerSavePatch)
		};

		public static readonly List<string> FailedPatches = new List<string>();

		public static GcModInfo Info => new GcModInfo
		{
			Id = "dungeonkarte",
			Guid = "gorduan.gc.dungeonkarte",
			Name = "GC_DungeonKarte",
			Version = "1.7.0",
			Stufe = 3,
			Seite = (GcSeite)0,
			Braucht = Array.Empty<string>(),
			Partner = Array.Empty<string>(),
			Fremd = Array.Empty<string>(),
			AlteConfig = "gorduan.gc_client.cfg",
			Ausgleich = 0f
		};

		public static void PatchAll(Harmony harmony)
		{
			Type[] patchTypes = PatchTypes;
			foreach (Type type in patchTypes)
			{
				try
				{
					harmony.CreateClassProcessor(type).Patch();
				}
				catch (Exception arg)
				{
					FailedPatches.Add(type.Name);
					Logger.CreateLogSource("GC_DungeonKarte").LogError((object)$"Patch {type.FullName} nicht eingespielt, diese Funktion fehlt: {arg}");
				}
			}
		}
	}
}
namespace GC.Client.DungeonMap
{
	internal static class Plugin
	{
		public const string Guid = "gorduan.gc_dungeonmap";

		public const string ModName = "GC_DungeonMap";

		public const string Version = "1.0.0";

		internal static ManualLogSource Log;

		internal static ConfigEntry<bool> Enabled;

		internal static ConfigEntry<float> SmallSize;

		internal static ConfigEntry<float> SmallZoom;

		internal static ConfigEntry<Vector2> SmallOffset;

		internal static ConfigEntry<bool> HideVanillaMinimap;

		internal static MapView? View;

		internal static bool Blocked => Chainloader.PluginInfos.ContainsKey("gorduan.gc_dungeonmap");

		internal static bool On
		{
			get
			{
				if (Enabled.Value && !Blocked)
				{
					return <02fd42c7-9979-487e-9c2f-76661a523373>ClientPlugin.Allowed;
				}
				return false;
			}
		}

		internal static void Init(ConfigFile Config, Harmony harmony)
		{
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			Log = <02fd42c7-9979-487e-9c2f-76661a523373>ClientPlugin.Log;
			Enabled = Gc.Bind<bool>(Config, "9 - DungeonMap", "Enabled", true, "Funktion ein- oder ausschalten (auch im Menü GC Option).", (AcceptableValueBase)null);
			SmallSize = Gc.Bind<float>(Config, "9 - DungeonMap - Interface", "SmallMapSize", 240f, "Größe der kleinen Dungeon-Karte in Pixeln.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(120f, 500f));
			SmallZoom = Gc.Bind<float>(Config, "9 - DungeonMap - Interface", "SmallMapPixelsPerMeter", 3f, "Maßstab der kleinen Karte (Pixel pro Meter).", (AcceptableValueBase)(object)new AcceptableValueRange<float>(1f, 10f));
			SmallOffset = Gc.Bind<Vector2>(Config, "9 - DungeonMap - Interface", "SmallMapOffset", new Vector2(-24f, -24f), "Abstand der kleinen Karte von der oberen rechten Bildschirmecke.", (AcceptableValueBase)null);
			HideVanillaMinimap = Gc.Bind<bool>(Config, "9 - DungeonMap - Interface", "HideVanillaMinimapInDungeon", true, "Im Dungeon die normale Minimap ausblenden.", (AcceptableValueBase)null);
		}

		internal static void Update()
		{
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null || (Object)(object)GUIManager.CustomGUIBack == (Object)null)
			{
				View?.Hide();
				View = null;
				return;
			}
			if (!On || Gc.IsHeadless || Game.m_noMap)
			{
				View?.Hide();
				return;
			}
			if (View == null)
			{
				View = new MapView();
			}
			View.Tick(localPlayer);
		}
	}
	[HarmonyPatch(typeof(Minimap), "SetMapMode")]
	internal static class MapModePatch
	{
		private static bool Prefix(MapMode mode)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Invalid comparison between Unknown and I4
			if (!Plugin.On || Game.m_noMap || (int)mode != 2 || (Object)(object)Player.m_localPlayer == (Object)null || !((Character)Player.m_localPlayer).InInterior() || Plugin.View == null)
			{
				return true;
			}
			Plugin.View.ToggleLarge();
			return false;
		}
	}
	[HarmonyPatch(typeof(Menu), "Update")]
	internal static class MenuEscPatch
	{
		private static bool Prefix(Menu __instance)
		{
			MapView view = Plugin.View;
			if (view == null || (Object)(object)__instance.m_root == (Object)null || ((Component)__instance.m_root).gameObject.activeSelf || !ZInput.GetKeyDown((KeyCode)27, true))
			{
				return true;
			}
			if (view.LargeOpen)
			{
				view.CloseLarge();
			}
			return view.EscFrame != Time.frameCount;
		}
	}
	internal sealed class DungeonData
	{
		public string Key = "";

		public Vector3 Origin;

		public List<Room> Rooms = new List<Room>();

		public Dictionary<Room, string> RoomKeys = new Dictionary<Room, string>();

		public HashSet<string> Explored = new HashSet<string>();
	}
	internal sealed class MapView
	{
		private const string DataPrefix = "gc_dmap_";

		private static readonly Color RoomColor = new Color(0.82f, 0.72f, 0.52f, 0.95f);

		private static readonly Color CurrentColor = new Color(1f, 0.85f, 0.45f, 1f);

		private static readonly Color OtherFloorColor = new Color(0.82f, 0.72f, 0.52f, 0.25f);

		private static readonly Color DoorColor = new Color(0.25f, 0.15f, 0.07f, 1f);

		private GameObject? small;

		private RectTransform? smallContent;

		private GameObject? large;

		private RectTransform? largeContent;

		private Image? smallPlayer;

		private Image? largePlayer;

		private readonly Dictionary<Room, Image> smallRooms = new Dictionary<Room, Image>();

		private readonly Dictionary<Room, Image> largeRooms = new Dictionary<Room, Image>();

		private DungeonData? current;

		private float nextScan;

		private float nextTick;

		private bool minimapHidden;

		private bool dirty = true;

		private static Sprite? arrow;

		public bool LargeOpen
		{
			get
			{
				if ((Object)(object)large != (Object)null)
				{
					return large.activeSelf;
				}
				return false;
			}
		}

		public int EscFrame { get; private set; } = -10;

		public void CloseLarge()
		{
			if ((Object)(object)large != (Object)null)
			{
				large.SetActive(false);
			}
			EscFrame = Time.frameCount;
		}

		public void Hide()
		{
			if ((Object)(object)small != (Object)null)
			{
				small.SetActive(false);
			}
			if ((Object)(object)large != (Object)null)
			{
				large.SetActive(false);
			}
			RestoreMinimap();
		}

		public void ToggleLarge()
		{
			Build();
			bool active = !large.activeSelf;
			large.SetActive(active);
			dirty = true;
		}

		public void Tick(Player player)
		{
			if (!((Character)player).InInterior())
			{
				if (current != null)
				{
					Save(player);
					current = null;
				}
				Hide();
				return;
			}
			Build();
			if (large.activeSelf && Input.GetKeyDown((KeyCode)27))
			{
				CloseLarge();
			}
			if (Plugin.HideVanillaMinimap.Value && (Object)(object)Minimap.instance != (Object)null && (Object)(object)Minimap.instance.m_smallRoot != (Object)null && Minimap.instance.m_smallRoot.activeSelf)
			{
				Minimap.instance.m_smallRoot.SetActive(false);
				minimapHidden = true;
			}
			small.SetActive(true);
			if (Time.time >= nextScan || current == null)
			{
				nextScan = Time.time + 3f;
				Scan(player);
			}
			if (current != null)
			{
				if (Time.time >= nextTick)
				{
					nextTick = Time.time + 0.25f;
					Explore(player);
				}
				Draw(player);
			}
		}

		private void RestoreMinimap()
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Invalid comparison between Unknown and I4
			if (minimapHidden && (Object)(object)Minimap.instance != (Object)null && (int)Minimap.instance.m_mode == 1)
			{
				Minimap.instance.m_smallRoot.SetActive(true);
			}
			minimapHidden = false;
		}

		private void Scan(Player player)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: 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_0086: 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_011e: 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)
			Vector3 position = ((Component)player).transform.position;
			DungeonGenerator val = (from g in Object.FindObjectsByType<DungeonGenerator>((FindObjectsSortMode)0)
				where (Object)(object)g != (Object)null && ((Component)g).transform.position.y > 2000f
				orderby Utils.DistanceXZ(((Component)g).transform.position, position)
				select g).FirstOrDefault();
			if ((Object)(object)val == (Object)null || Utils.DistanceXZ(((Component)val).transform.position, position) > 400f)
			{
				return;
			}
			Vector3 origin = ((Component)val).transform.position;
			string arg = (((Object)(object)ZNet.instance != (Object)null) ? ZNet.instance.GetWorldName() : "world");
			string text = $"{arg}_{Mathf.RoundToInt(origin.x)}_{Mathf.RoundToInt(origin.z)}";
			if (current == null || current.Key != text)
			{
				if (current != null)
				{
					Save(player);
				}
				current = new DungeonData
				{
					Key = text,
					Origin = origin
				};
				Load(player);
				ClearImages();
			}
			List<Room> list = (from r in Object.FindObjectsByType<Room>((FindObjectsSortMode)0)
				where (Object)(object)r != (Object)null && ((Component)r).transform.position.y > 2000f && Utils.DistanceXZ(((Component)r).transform.position, origin) < 400f
				select r).ToList();
			if (list.Count != current.Rooms.Count)
			{
				current.Rooms = list;
				current.RoomKeys = list.ToDictionary((Room r) => r, (Room r) => RoomKey(r, origin));
				dirty = true;
			}
		}

		private static string RoomKey(Room room, Vector3 origin)
		{
			//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_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_0017: 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_0037: Unknown result type (might be due to invalid IL or missing references)
			Vector3 val = ((Component)room).transform.position - origin;
			return $"{Mathf.RoundToInt(val.x)}:{Mathf.RoundToInt(val.y)}:{Mathf.RoundToInt(val.z)}";
		}

		private static bool Inside(Room room, Vector3 point)
		{
			//IL_0006: 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_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: 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)
			Vector3 val = ((Component)room).transform.InverseTransformPoint(point);
			Vector3 val2 = default(Vector3);
			((Vector3)(ref val2))..ctor((float)((Vector3Int)(ref room.m_size)).x * 0.5f + 0.5f, (float)((Vector3Int)(ref room.m_size)).y * 0.5f + 1f, (float)((Vector3Int)(ref room.m_size)).z * 0.5f + 0.5f);
			if (Mathf.Abs(val.x) <= val2.x && Mathf.Abs(val.y) <= val2.y)
			{
				return Mathf.Abs(val.z) <= val2.z;
			}
			return false;
		}

		private void Explore(Player player)
		{
			//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_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			Vector3 point = ((Component)player).transform.position + Vector3.up;
			foreach (Room room in current.Rooms)
			{
				if ((Object)(object)room != (Object)null && Inside(room, point) && current.Explored.Add(current.RoomKeys[room]))
				{
					dirty = true;
				}
			}
		}

		private void Load(Player player)
		{
			if (player.m_customData.TryGetValue("gc_dmap_" + current.Key, out var value))
			{
				string[] array = value.Split(new char[1] { ',' }, StringSplitOptions.RemoveEmptyEntries);
				foreach (string item in array)
				{
					current.Explored.Add(item);
				}
			}
		}

		public void Save(Player player)
		{
			if (current != null && current.Explored.Count != 0)
			{
				player.m_customData["gc_dmap_" + current.Key] = string.Join(",", current.Explored);
			}
		}

		private void ClearImages()
		{
			foreach (Image item in smallRooms.Values.Concat(largeRooms.Values))
			{
				if ((Object)(object)item != (Object)null)
				{
					Object.Destroy((Object)(object)((Component)item).gameObject);
				}
			}
			smallRooms.Clear();
			largeRooms.Clear();
			dirty = true;
		}

		private void Draw(Player player)
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_013b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0141: Unknown result type (might be due to invalid IL or missing references)
			//IL_0146: Unknown result type (might be due to invalid IL or missing references)
			//IL_014b: 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_0168: 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_01b6: 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_01cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01dd: Unknown result type (might be due to invalid IL or missing references)
			DungeonData dungeonData = current;
			float y = ((Component)player).transform.position.y;
			Room here = ((IEnumerable<Room>)dungeonData.Rooms).FirstOrDefault((Func<Room, bool>)((Room r) => (Object)(object)r != (Object)null && Inside(r, ((Component)player).transform.position + Vector3.up)));
			if (dirty)
			{
				dirty = false;
				foreach (Room room in dungeonData.Rooms)
				{
					if (!((Object)(object)room == (Object)null) && dungeonData.RoomKeys.TryGetValue(room, out string value) && dungeonData.Explored.Contains(value))
					{
						if (!smallRooms.ContainsKey(room))
						{
							smallRooms[room] = CreateRoom(smallContent, room);
						}
						if (!largeRooms.ContainsKey(room))
						{
							largeRooms[room] = CreateRoom(largeContent, room);
						}
					}
				}
				FitLarge(dungeonData);
			}
			float value2 = Plugin.SmallZoom.Value;
			Place(smallRooms, value2, dungeonData, here, y);
			smallContent.anchoredPosition = -MapPoint(((Component)player).transform.position, dungeonData.Origin) * value2;
			PlacePlayer(smallPlayer, player, Vector2.zero);
			if (large.activeSelf)
			{
				float x = ((Transform)largeContent).localScale.x;
				Place(largeRooms, 1f, dungeonData, here, y);
				PlacePlayer(largePlayer, player, largeContent.anchoredPosition + MapPoint(((Component)player).transform.position, dungeonData.Origin) * x);
			}
		}

		private static Vector2 MapPoint(Vector3 world, Vector3 origin)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			return new Vector2(world.x - origin.x, world.z - origin.z);
		}

		private static void Place(Dictionary<Room, Image> images, float zoom, DungeonData data, Room? here, float playerY)
		{
			//IL_0049: 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_0054: 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_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: 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_0103: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_011d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Expected O, but got Unknown
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_0127: Unknown result type (might be due to invalid IL or missing references)
			//IL_013d: Unknown result type (might be due to invalid IL or missing references)
			foreach (KeyValuePair<Room, Image> image in images)
			{
				Room key = image.Key;
				Image value = image.Value;
				if ((Object)(object)key == (Object)null || (Object)(object)value == (Object)null)
				{
					continue;
				}
				RectTransform rectTransform = ((Graphic)value).rectTransform;
				rectTransform.anchoredPosition = MapPoint(((Component)key).transform.position, data.Origin) * zoom;
				rectTransform.sizeDelta = new Vector2((float)((Vector3Int)(ref key.m_size)).x, (float)((Vector3Int)(ref key.m_size)).z) * zoom;
				((Transform)rectTransform).localEulerAngles = new Vector3(0f, 0f, 0f - ((Component)key).transform.eulerAngles.y);
				bool flag = Mathf.Abs(((Component)key).transform.position.y - playerY) < (float)((Vector3Int)(ref key.m_size)).y * 0.5f + 3f;
				((Graphic)value).color = (((Object)(object)key == (Object)(object)here) ? CurrentColor : (flag ? RoomColor : OtherFloorColor));
				foreach (Transform item in (Transform)rectTransform)
				{
					((RectTransform)item).sizeDelta = Vector2.one * Mathf.Max(3f, zoom * 1.5f);
				}
			}
		}

		private static Image CreateRoom(RectTransform parent, Room room)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Expected O, but got Unknown
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: 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_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_011b: 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_016d: 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_0179: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("Room", new Type[2]
			{
				typeof(RectTransform),
				typeof(Image)
			});
			val.transform.SetParent((Transform)(object)parent, false);
			Image component = val.GetComponent<Image>();
			((Graphic)component).raycastTarget = false;
			RectTransform rectTransform = ((Graphic)component).rectTransform;
			Vector2 val2 = default(Vector2);
			((Vector2)(ref val2))..ctor(0.5f, 0.5f);
			rectTransform.anchorMax = val2;
			rectTransform.anchorMin = val2;
			rectTransform.pivot = new Vector2(0.5f, 0.5f);
			RoomConnection[] connections = room.GetConnections();
			foreach (RoomConnection val3 in connections)
			{
				if (!((Object)(object)val3 == (Object)null))
				{
					Vector3 val4 = ((Component)room).transform.InverseTransformPoint(((Component)val3).transform.position);
					GameObject val5 = new GameObject("Door", new Type[2]
					{
						typeof(RectTransform),
						typeof(Image)
					});
					val5.transform.SetParent(val.transform, false);
					Image component2 = val5.GetComponent<Image>();
					((Graphic)component2).color = DoorColor;
					((Graphic)component2).raycastTarget = false;
					RectTransform rectTransform2 = ((Graphic)component2).rectTransform;
					((Vector2)(ref val2))..ctor(Mathf.Clamp01(0.5f + val4.x / Mathf.Max(1f, (float)((Vector3Int)(ref room.m_size)).x)), Mathf.Clamp01(0.5f + val4.z / Mathf.Max(1f, (float)((Vector3Int)(ref room.m_size)).z)));
					rectTransform2.anchorMax = val2;
					rectTransform2.anchorMin = val2;
					rectTransform2.anchoredPosition = Vector2.zero;
				}
			}
			return component;
		}

		private void FitLarge(DungeonData data)
		{
			//IL_0061: 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_006c: 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_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: 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_00bd: 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_00c7: 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)
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fe: 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_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: Unknown result type (might be due to invalid IL or missing references)
			//IL_011b: Unknown result type (might be due to invalid IL or missing references)
			//IL_011c: Unknown result type (might be due to invalid IL or missing references)
			//IL_011d: Unknown result type (might be due to invalid IL or missing references)
			//IL_011e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_0124: Unknown result type (might be due to invalid IL or missing references)
			//IL_012f: Unknown result type (might be due to invalid IL or missing references)
			//IL_013b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0146: Unknown result type (might be due to invalid IL or missing references)
			//IL_016e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0175: 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_0186: Unknown result type (might be due to invalid IL or missing references)
			//IL_0187: Unknown result type (might be due to invalid IL or missing references)
			//IL_0191: Unknown result type (might be due to invalid IL or missing references)
			//IL_0196: Unknown result type (might be due to invalid IL or missing references)
			//IL_019d: Unknown result type (might be due to invalid IL or missing references)
			if (largeRooms.Count == 0)
			{
				return;
			}
			Vector2 val = default(Vector2);
			((Vector2)(ref val))..ctor(float.MaxValue, float.MaxValue);
			Vector2 val2 = default(Vector2);
			((Vector2)(ref val2))..ctor(float.MinValue, float.MinValue);
			foreach (Room key in largeRooms.Keys)
			{
				if (!((Object)(object)key == (Object)null))
				{
					Vector2 val4 = MapPoint(((Component)key).transform.position, data.Origin);
					float num = (float)Mathf.Max(((Vector3Int)(ref key.m_size)).x, ((Vector3Int)(ref key.m_size)).z) * 0.75f;
					val = Vector2.Min(val, val4 - Vector2.one * num);
					val2 = Vector2.Max(val2, val4 + Vector2.one * num);
				}
			}
			Rect rect = ((RectTransform)large.transform).rect;
			Vector2 val5 = ((Rect)(ref rect)).size - new Vector2(80f, 120f);
			Vector2 val6 = val2 - val;
			float num2 = Mathf.Clamp(Mathf.Min(val5.x / Mathf.Max(1f, val6.x), val5.y / Mathf.Max(1f, val6.y)), 1f, 12f);
			((Transform)largeContent).localScale = Vector3.one * num2;
			largeContent.anchoredPosition = -((val + val2) * 0.5f) * num2;
		}

		private static void PlacePlayer(Image marker, Player player, Vector2 position)
		{
			//IL_0006: 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_002d: Unknown result type (might be due to invalid IL or missing references)
			((Graphic)marker).rectTransform.anchoredPosition = position;
			((Transform)((Graphic)marker).rectTransform).localEulerAngles = new Vector3(0f, 0f, 0f - ((Component)player).transform.eulerAngles.y);
			((Component)marker).transform.SetAsLastSibling();
		}

		private void Build()
		{
			//IL_0069: 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_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: 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_00e0: 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_012e: Unknown result type (might be due to invalid IL or missing references)
			//IL_013d: Unknown result type (might be due to invalid IL or missing references)
			//IL_014c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0159: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)small != (Object)null) || !((Object)(object)large != (Object)null))
			{
				Transform parent = (((Object)(object)Hud.instance != (Object)null && (Object)(object)Hud.instance.m_rootObject != (Object)null) ? Hud.instance.m_rootObject.transform : GUIManager.CustomGUIBack.transform);
				small = CreateFrame("GC_DungeonMap_Small", parent, new Vector2(1f, 1f), Plugin.SmallOffset.Value, Vector2.one * Plugin.SmallSize.Value, out smallContent, out smallPlayer);
				small.transform.SetAsFirstSibling();
				large = CreateFrame("GC_DungeonMap_Large", GUIManager.CustomGUIFront.transform, new Vector2(0.5f, 0.5f), Vector2.zero, new Vector2(1000f, 760f), out largeContent, out largePlayer);
				((Graphic)GcUi.CreateLabel(large.transform, GcLoc.Get("gcdm_title", Array.Empty<object>()), new Vector2(0f, 1f), new Vector2(1f, 1f), new Vector2(20f, -60f), new Vector2(-20f, -10f), 30, (TextAnchor)4, (Color?)GUIManager.Instance.ValheimOrange, true)).raycastTarget = false;
				large.SetActive(false);
				small.SetActive(false);
			}
		}

		private static GameObject CreateFrame(string name, Transform parent, Vector2 anchor, Vector2 position, Vector2 size, out RectTransform content, out Image player)
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Expected O, but got Unknown
			//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)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: 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_0057: 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_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: 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_008f: 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_00e5: Expected O, but got Unknown
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0105: Expected O, but got Unknown
			//IL_011c: 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_0137: 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_0173: Unknown result type (might be due to invalid IL or missing references)
			//IL_017a: Expected O, but got Unknown
			//IL_01a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01dc: 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)
			GameObject val = new GameObject(name, new Type[3]
			{
				typeof(RectTransform),
				typeof(Image),
				typeof(RectMask2D)
			});
			val.transform.SetParent(parent, false);
			RectTransform val2 = (RectTransform)val.transform;
			Vector2 val3 = (val2.anchorMin = (val2.anchorMax = anchor));
			val2.pivot = anchor;
			val2.anchoredPosition = position;
			val2.sizeDelta = size;
			Image component = val.GetComponent<Image>();
			((Graphic)component).color = new Color(0.08f, 0.06f, 0.04f, 0.85f);
			((Graphic)component).raycastTarget = false;
			Sprite sprite = GUIManager.Instance.GetSprite("panel_interior_bkg_128");
			if ((Object)(object)sprite != (Object)null)
			{
				component.sprite = sprite;
				component.type = (Type)1;
			}
			GameObject val6 = new GameObject("Content", new Type[1] { typeof(RectTransform) });
			val6.transform.SetParent(val.transform, false);
			content = (RectTransform)val6.transform;
			RectTransform obj = content;
			RectTransform obj2 = content;
			((Vector2)(ref val3))..ctor(0.5f, 0.5f);
			obj2.anchorMax = val3;
			obj.anchorMin = val3;
			content.pivot = new Vector2(0.5f, 0.5f);
			content.sizeDelta = Vector2.zero;
			GameObject val7 = new GameObject("Player", new Type[2]
			{
				typeof(RectTransform),
				typeof(Image)
			});
			val7.transform.SetParent(val.transform, false);
			player = val7.GetComponent<Image>();
			player.sprite = Arrow();
			((Graphic)player).color = Color.white;
			((Graphic)player).raycastTarget = false;
			RectTransform rectTransform = ((Graphic)player).rectTransform;
			((Vector2)(ref val3))..ctor(0.5f, 0.5f);
			rectTransform.anchorMax = val3;
			rectTransform.anchorMin = val3;
			rectTransform.sizeDelta = new Vector2(18f, 18f);
			return val;
		}

		private static Sprite Arrow()
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Expected O, but got Unknown
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)arrow != (Object)null)
			{
				return arrow;
			}
			Texture2D val = new Texture2D(32, 32, (TextureFormat)4, false);
			for (int i = 0; i < 32; i++)
			{
				for (int j = 0; j < 32; j++)
				{
					float num = (float)(32 - i) * 0.45f;
					bool flag = i > 2 && Mathf.Abs((float)j - 16f) < (float)(32 - i) * 0.5f && (i >= 10 || !(Mathf.Abs((float)j - 16f) < num * 0.45f));
					val.SetPixel(j, i, flag ? new Color(1f, 0.3f, 0.2f, 1f) : new Color(0f, 0f, 0f, 0f));
				}
			}
			val.Apply();
			arrow = Sprite.Create(val, new Rect(0f, 0f, 32f, 32f), new Vector2(0.5f, 0.5f));
			return arrow;
		}
	}
	[HarmonyPatch(typeof(Player), "Save")]
	internal static class PlayerSavePatch
	{
		private static void Prefix(Player __instance)
		{
			if ((Object)(object)__instance == (Object)(object)Player.m_localPlayer && Plugin.View != null && ((Character)__instance).InInterior())
			{
				Plugin.View.Save(__instance);
			}
		}
	}
}
namespace System.Runtime.CompilerServices
{
	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
	internal sealed class <02fd42c7-9979-487e-9c2f-76661a523373>IgnoresAccessChecksToAttribute : Attribute
	{
		public <02fd42c7-9979-487e-9c2f-76661a523373>IgnoresAccessChecksToAttribute(string assemblyName)
		{
		}
	}
}
namespace GC.Client
{
	internal static class <5ee8f811-bd99-4463-b934-5528eb07a3d5>ClientPlugin
	{
		internal static ManualLogSource Log;

		internal static GcModule? Module;

		internal static bool Allowed
		{
			get
			{
				if (Module != null)
				{
					return Module.Allowed;
				}
				return true;
			}
		}

		internal static bool OnServer
		{
			get
			{
				if (Module != null)
				{
					return Module.OnServer;
				}
				return false;
			}
		}
	}
}
namespace GC.Client.ModEinsammeln
{
	[BepInPlugin("gorduan.gc.einsammeln", "GC_Einsammeln", "1.7.0")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[NetworkCompatibility(/*Could not decode attribute arguments.*/)]
	public class Plugin : BaseUnityPlugin
	{
		internal static GcModule Module;

		private void Awake()
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Expected O, but got Unknown
			Module = GcKern.Register((BaseUnityPlugin)(object)this, ((BaseUnityPlugin)this).Logger, GcMod.Info);
			<5ee8f811-bd99-4463-b934-5528eb07a3d5>ClientPlugin.Log = ((BaseUnityPlugin)this).Logger;
			<5ee8f811-bd99-4463-b934-5528eb07a3d5>ClientPlugin.Module = Module;
			Harmony harmony = new Harmony("gorduan.gc.einsammeln");
			GC.Client.CartCollect.Plugin.Init(((BaseUnityPlugin)this).Config, harmony);
			Module.TakeOverOldSettings();
			GcMod.PatchAll(harmony);
			Module.MenuGroup((Func<string, string>)((string key) => GcLoc.Get("gccm_" + key, Array.Empty<object>())), (string)null).Main("cartcollect", (ConfigEntryBase)(object)GC.Client.CartCollect.Plugin.Enabled, (Func<bool>)(() => GC.Client.CartCollect.Plugin.Blocked), "GC_CartCollect", (Func<string>)null, 0.0, "", (Func<bool>)null, (Func<bool>)null, (Func<string>)null).Sub("cartcollect_range", (ConfigEntryBase)(object)GC.Client.CartCollect.Plugin.Range, 1.0, " m", (Func<bool>)null, "", (Func<bool>)null, (Func<bool>)null, (Func<string>)null)
				.Sub("cartcollect_matching", (ConfigEntryBase)(object)GC.Client.CartCollect.Plugin.OnlyMatching, 0.0, "", (Func<bool>)null, "", (Func<bool>)null, (Func<bool>)null, (Func<string>)null)
				.Sub("cartcollect_ships", (ConfigEntryBase)(object)GC.Client.CartCollect.Plugin.IncludeShips, 0.0, "", (Func<bool>)null, "", (Func<bool>)null, (Func<bool>)null, (Func<string>)null)
				.Sub("cartcollect_pulling", (ConfigEntryBase)(object)GC.Client.CartCollect.Plugin.OnlyWhilePulling, 0.0, "", (Func<bool>)null, "", (Func<bool>)null, (Func<bool>)null, (Func<string>)null)
				.Sub("cartcollect_key", (ConfigEntryBase)(object)GC.Client.CartCollect.Plugin.ToggleKey, 0.0, "", (Func<bool>)null, "", (Func<bool>)null, (Func<bool>)null, (Func<string>)null);
		}

		private void Update()
		{
			if (!Gc.IsHeadless)
			{
				Module.Guard("Einsammeln", (Action)GC.Client.CartCollect.Plugin.Update);
			}
		}
	}
	internal static class GcMod
	{
		public const string Id = "einsammeln";

		public const string Guid = "gorduan.gc.einsammeln";

		public const string Name = "GC_Einsammeln";

		public const string Version = "1.7.0";

		public const int Stufe = 3;

		public static readonly Type[] PatchTypes = new Type[1] { typeof(GC.Client.CartCollect.PickupPatch) };

		public static readonly List<string> FailedPatches = new List<string>();

		public static GcModInfo Info
		{
			get
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				//IL_0006: Expected O, but got Unknown
				//IL_003b: Unknown result type (might be due to invalid IL or missing references)
				GcModInfo val = new GcModInfo();
				val.Id = "einsammeln";
				val.Guid = "gorduan.gc.einsammeln";
				val.Name = "GC_Einsammeln";
				val.Version = "1.7.0";
				val.Stufe = 3;
				val.Seite = (GcSeite)0;
				val.Braucht = Array.Empty<string>();
				val.Partner = Array.Empty<string>();
				val.Fremd = new string[1] { "gorduan.guilds_vehicle" };
				val.AlteConfig = "gorduan.gc_client.cfg";
				val.Ausgleich = 0f;
				return val;
			}
		}

		public static void PatchAll(Harmony harmony)
		{
			Type[] patchTypes = PatchTypes;
			foreach (Type type in patchTypes)
			{
				try
				{
					harmony.CreateClassProcessor(type).Patch();
				}
				catch (Exception arg)
				{
					FailedPatches.Add(type.Name);
					Logger.CreateLogSource("GC_Einsammeln").LogError((object)$"Patch {type.FullName} nicht eingespielt, diese Funktion fehlt: {arg}");
				}
			}
		}
	}
}
namespace GC.Client.CartCollect
{
	internal static class Plugin
	{
		public const string Guid = "gorduan.gc_cartcollect";

		public const string ModName = "GC_CartCollect";

		public const string Version = "1.0.0";

		internal static ManualLogSource Log = null;

		internal static ConfigEntry<bool> Enabled = null;

		internal static ConfigEntry<float> Range = null;

		internal static ConfigEntry<bool> OnlyMatching = null;

		internal static ConfigEntry<bool> IncludeShips = null;

		internal static ConfigEntry<bool> OnlyWhilePulling = null;

		internal static ConfigEntry<KeyboardShortcut> ToggleKey = null;

		internal static bool paused;

		internal static MethodInfo? canUseCargo;

		private static bool cargoCheckFailed;

		private static readonly Collider[] Hits = (Collider[])(object)new Collider[64];

		internal static bool Blocked => Chainloader.PluginInfos.ContainsKey("gorduan.gc_cartcollect");

		internal static bool On
		{
			get
			{
				if (Enabled.Value && !Blocked)
				{
					return <5ee8f811-bd99-4463-b934-5528eb07a3d5>ClientPlugin.Allowed;
				}
				return false;
			}
		}

		internal static void Init(ConfigFile Config, Harmony harmony)
		{
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			Log = <5ee8f811-bd99-4463-b934-5528eb07a3d5>ClientPlugin.Log;
			Enabled = Gc.Bind<bool>(Config, "5 - CartCollect", "Enabled", true, "Funktion ein- oder ausschalten (auch im Menü GC Option).", (AcceptableValueBase)null);
			Range = Gc.Bind<float>(Config, "5 - CartCollect", "Range", 10f, "Suchradius in Metern um den Spieler.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(2f, 30f));
			OnlyMatching = Gc.Bind<bool>(Config, "5 - CartCollect", "OnlyMatchingItems", true, "Nur Items, die im Fahrzeug schon liegen (Holz zu Holz, Stein zu Stein). Aus = alles, was Platz hat.", (AcceptableValueBase)null);
			IncludeShips = Gc.Bind<bool>(Config, "5 - CartCollect", "IncludeShips", true, "Auch Schiffe mit Laderaum befüllen.", (AcceptableValueBase)null);
			OnlyWhilePulling = Gc.Bind<bool>(Config, "5 - CartCollect", "OnlyWhilePulling", false, "Karren nur befüllen, während du ihn ziehst.", (AcceptableValueBase)null);
			ToggleKey = Gc.Bind<KeyboardShortcut>(Config, "5 - CartCollect", "PauseKey", new KeyboardShortcut((KeyCode)0, Array.Empty<KeyCode>()), "Optionale Taste, um die Funktion kurz an- und auszuschalten.", (AcceptableValueBase)null);
			if (Chainloader.PluginInfos.ContainsKey("gorduan.guilds_vehicle"))
			{
				Type type = AccessTools.TypeByName("GuildVehicle.VehicleAPI");
				canUseCargo = ((type == null) ? null : AccessTools.Method(type, "CanUseCargo", new Type[2]
				{
					typeof(ZNetView),
					typeof(Player)
				}, (Type[])null));
			}
		}

		internal static void Update()
		{
			if (On && (Object)(object)Player.m_localPlayer != (Object)null && Gc.Down(ToggleKey))
			{
				paused = !paused;
				Gc.Center(GcLoc.Get(paused ? "gcc_paused" : "gcc_resumed", Array.Empty<object>()));
			}
		}

		internal static Container? FindTarget(Player player, ItemData item)
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0190: 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)
			if (cargoCheckFailed)
			{
				return null;
			}
			int mask = LayerMask.GetMask(new string[3] { "vehicle", "piece", "item" });
			int num = Physics.OverlapSphereNonAlloc(((Component)player).transform.position, Range.Value, Hits, mask);
			Container val = null;
			float num2 = float.MaxValue;
			for (int i = 0; i < num; i++)
			{
				Container componentInParent = ((Component)Hits[i]).GetComponentInParent<Container>();
				if ((Object)(object)componentInParent == (Object)null || (Object)(object)componentInParent == (Object)(object)val)
				{
					continue;
				}
				Vagon componentInParent2 = ((Component)componentInParent).GetComponentInParent<Vagon>();
				Ship componentInParent3 = ((Component)componentInParent).GetComponentInParent<Ship>();
				if (((Object)(object)componentInParent2 == (Object)null && ((Object)(object)componentInParent3 == (Object)null || !IncludeShips.Value)) || ((Object)(object)componentInParent2 != (Object)null && OnlyWhilePulling.Value && !componentInParent2.IsAttached((Character)(object)player)))
				{
					continue;
				}
				ZNetView nview = componentInParent.m_nview;
				if ((Object)(object)nview == (Object)null || !nview.IsValid() || !nview.IsOwner() || componentInParent.IsInUse() || Gc.IsAutoLocked(componentInParent) || !CargoAllowed(((Object)(object)componentInParent2 != (Object)null) ? ((Component)componentInParent2).GetComponent<ZNetView>() : ((Component)componentInParent3).GetComponent<ZNetView>(), player))
				{
					continue;
				}
				componentInParent.Load();
				Inventory inventory = componentInParent.GetInventory();
				if (inventory != null && inventory.CanAddItem(item, -1) && (!OnlyMatching.Value || inventory.ContainsItemByName(item.m_shared.m_name)))
				{
					float num3 = Vector3.Distance(((Component)player).transform.position, ((Component)componentInParent).transform.position);
					if (num3 < num2)
					{
						val = componentInParent;
						num2 = num3;
					}
				}
			}
			return val;
		}

		private static bool CargoAllowed(ZNetView? vehicle, Player player)
		{
			if (canUseCargo == null || (Object)(object)vehicle == (Object)null)
			{
				return true;
			}
			try
			{
				object obj = canUseCargo.Invoke(null, new object[2] { vehicle, player });
				return obj is bool && (bool)obj;
			}
			catch (Exception ex)
			{
				canUseCargo = null;
				cargoCheckFailed = true;
				Log.LogWarning((object)("Einsammeln: Die Prüfung von Guilds_Vehicle (VehicleAPI.CanUseCargo) schlug fehl, Einsammeln ins Fahrzeug bleibt bis zum Neustart aus (" + ex.GetBaseException().Message + ")."));
				return false;
			}
		}
	}
	[HarmonyPatch(typeof(Humanoid), "Pickup")]
	internal static class PickupPatch
	{
		[HarmonyPriority(600)]
		private static bool Prefix(Humanoid __instance, GameObject go, bool autoPickupDelay, ref bool __result)
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Expected O, but got Unknown
			//IL_0136: Unknown result type (might be due to invalid IL or missing references)
			//IL_013b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0148: Unknown result type (might be due to invalid IL or missing references)
			if (!Plugin.On || Plugin.paused || (Object)(object)__instance != (Object)(object)Player.m_localPlayer || (Object)(object)go == (Object)null)
			{
				return true;
			}
			Player val = (Player)__instance;
			ItemDrop component = go.GetComponent<ItemDrop>();
			if ((Object)(object)component == (Object)null || ((Character)val).IsTeleporting() || !component.CanPickup(autoPickupDelay))
			{
				return true;
			}
			component.Load();
			ItemData itemData = component.m_itemData;
			if (itemData.m_shared.m_questItem || itemData.m_shared.m_maxStackSize <= 1 || itemData.m_customData.Count > 0)
			{
				return true;
			}
			if ((Object)(object)component.m_nview == (Object)null || !component.m_nview.IsValid() || !component.m_nview.IsOwner())
			{
				return true;
			}
			Container val2 = Plugin.FindTarget(val, itemData);
			if ((Object)(object)val2 == (Object)null)
			{
				return true;
			}
			int stack = itemData.m_stack;
			string name = itemData.m_shared.m_name;
			Inventory inventory = val2.GetInventory();
			int num = inventory.NrOfItemsIncludingStacks();
			inventory.AddItem(itemData.Clone());
			int num2 = inventory.NrOfItemsIncludingStacks() - num;
			if (num2 <= 0)
			{
				return true;
			}
			if (num2 >= stack)
			{
				ZNetScene.instance.Destroy(go);
			}
			else
			{
				itemData.m_stack = stack - num2;
				component.Save();
			}
			((Humanoid)val).m_pickupEffects.Create(((Component)val).transform.position, Quaternion.identity, (Transform)null, 1f, -1, ((Character)val).GetZDOID());
			Gc.TopLeft(GcLoc.Get("gcc_stored", new object[3]
			{
				num2,
				Localization.instance.Localize(name),
				Localization.instance.Localize(val2.m_name)
			}));
			__result = true;
			return false;
		}
	}
}
namespace System.Runtime.CompilerServices
{
	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
	internal sealed class <5ee8f811-bd99-4463-b934-5528eb07a3d5>IgnoresAccessChecksToAttribute : Attribute
	{
		public <5ee8f811-bd99-4463-b934-5528eb07a3d5>IgnoresAccessChecksToAttribute(string assemblyName)
		{
		}
	}
}
namespace GC.Client
{
	internal static class <197c1f94-b781-4c1b-9076-9b8adab7750f>ClientPlugin
	{
		internal static ManualLogSource Log;

		internal static GcModule? Module;

		internal static bool Allowed
		{
			get
			{
				if (Module != null)
				{
					return Module.Allowed;
				}
				return true;
			}
		}

		internal static bool OnServer
		{
			get
			{
				if (Module != null)
				{
					return Module.OnServer;
				}
				return false;
			}
		}
	}
}
namespace GC.Client.QuickTake
{
	internal static class Plugin
	{
		public const string Guid = "gorduan.gc_quicktake";

		public const string ModName = "GC_QuickTake";

		public const string Version = "1.1.0";

		internal static ManualLogSource Log = null;

		internal static ConfigEntry<bool> Enabled = null;

		internal static ConfigEntry<KeyCode> Modifier = null;

		internal static Container? RequestedFor;

		internal static float RequestedAt = -100f;

		internal static Container? Waiting;

		internal static float WaitingSince;

		internal static bool Blocked => Chainloader.PluginInfos.ContainsKey("gorduan.gc_quicktake");

		internal static bool On
		{
			get
			{
				if (Enabled.Value && !Blocked)
				{
					return <197c1f94-b781-4c1b-9076-9b8adab7750f>ClientPlugin.Allowed;
				}
				return false;
			}
		}

		internal static void Init(ConfigFile Config, Harmony harmony)
		{
			Log = <197c1f94-b781-4c1b-9076-9b8adab7750f>ClientPlugin.Log;
			Enabled = Gc.Bind<bool>(Config, "3 - QuickTake", "Enabled", true, "Kiste mit Umschalt+E leeren, ohne sie zu öffnen (auch im Menü GC Option).", (AcceptableValueBase)null);
			Modifier = Gc.Bind<KeyCode>(Config, "3 - QuickTake", "TakeAllModifier", (KeyCode)304, "Diese Taste halten und eine Kiste benutzen (E): alles nehmen statt öffnen.", (AcceptableValueBase)null);
		}

		internal static void Update()
		{
			if ((Object)(object)Waiting == (Object)null)
			{
				return;
			}
			Container waiting = Waiting;
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)waiting == (Object)null || (Object)(object)waiting.m_nview == (Object)null || !waiting.m_nview.IsValid() || (Object)(object)localPlayer == (Object)null)
			{
				Waiting = null;
				return;
			}
			if (!waiting.m_nview.IsOwner())
			{
				if (Time.time - WaitingSince > 3f)
				{
					Waiting = null;
					Gc.Center(GcLoc.Get("gcq_timeout", Array.Empty<object>()));
				}
				return;
			}
			Waiting = null;
			if (!waiting.IsInUse())
			{
				waiting.Load();
				Inventory inventory = waiting.GetInventory();
				int num = inventory.NrOfItemsIncludingStacks();
				InventoryGui instance = InventoryGui.instance;
				Container currentContainer = instance.m_currentContainer;
				instance.m_currentContainer = waiting;
				try
				{
					instance.OnTakeAll();
				}
				finally
				{
					instance.m_currentContainer = currentContainer;
				}
				int num2 = num - inventory.NrOfItemsIncludingStacks();
				Gc.TopLeft((num2 > 0) ? GcLoc.Get("gcq_taken", new object[2]
				{
					Localization.instance.Localize(waiting.m_name),
					num2
				}) : GcLoc.Get("gcq_nothing", Array.Empty<object>()));
			}
		}
	}
	[HarmonyPatch(typeof(Container), "Interact")]
	internal static class ContainerInteractPatch
	{
		[HarmonyPriority(0)]
		private static void Prefix(Container __instance, Humanoid character, bool hold, bool __runOriginal)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)character != (Object)(object)Player.m_localPlayer || hold))
			{
				Plugin.RequestedFor = null;
				if (__runOriginal && Plugin.On && (int)Plugin.Modifier.Value != 0 && Input.GetKey(Plugin.Modifier.Value) && !Gc.TextInputActive() && !((Character)character).IsRunning() && __instance.GetInventory() != null && __instance.GetInventory().NrOfItems() > 0)
				{
					Plugin.RequestedFor = __instance;
					Plugin.RequestedAt = Time.time;
				}
			}
		}
	}
	[HarmonyPatch(typeof(Container), "RPC_OpenResponse")]
	internal static class OpenResponsePatch
	{
		[HarmonyPriority(0)]
		private static bool Prefix(Container __instance, bool granted, bool __runOriginal)
		{
			if (!Plugin.On || (Object)(object)Plugin.RequestedFor != (Object)(object)__instance || Time.time - Plugin.RequestedAt > 3f || (Object)(object)Player.m_localPlayer == (Object)null)
			{
				return true;
			}
			Plugin.RequestedFor = null;
			if (!__runOriginal)
			{
				return false;
			}
			if (!granted)
			{
				return true;
			}
			Plugin.Waiting = __instance;
			Plugin.WaitingSince = Time.time;
			return false;
		}
	}
}
namespace GC.Client.ModKisteLeeren
{
	[BepInPlugin("gorduan.gc.kisteleeren", "GC_KisteLeeren", "1.7.0")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[NetworkCompatibility(/*Could not decode attribute arguments.*/)]
	public class Plugin : BaseUnityPlugin
	{
		internal static GcModule Module;

		private void Awake()
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Expected O, but got Unknown
			Module = GcKern.Register((BaseUnityPlugin)(object)this, ((BaseUnityPlugin)this).Logger, GcMod.Info);
			<197c1f94-b781-4c1b-9076-9b8adab7750f>ClientPlugin.Log = ((BaseUnityPlugin)this).Logger;
			<197c1f94-b781-4c1b-9076-9b8adab7750f>ClientPlugin.Module = Module;
			Harmony harmony = new Harmony("gorduan.gc.kisteleeren");
			GC.Client.QuickTake.Plugin.Init(((BaseUnityPlugin)this).Config, harmony);
			Module.TakeOverOldSettings();
			GcMod.PatchAll(harmony);
			Module.MenuGroup((Func<string, string>)((string key) => GcLoc.Get("gccm_" + key, Array.Empty<object>())), (string)null).Main("quicktake", (ConfigEntryBase)(object)GC.Client.QuickTake.Plugin.Enabled, (Func<bool>)(() => GC.Client.QuickTake.Plugin.Blocked), "GC_QuickTake", (Func<string>)null, 0.0, "", (Func<bool>)null, (Func<bool>)null, (Func<string>)null).Sub("quicktake_key", (ConfigEntryBase)(object)GC.Client.QuickTake.Plugin.Modifier, 0.0, "", (Func<bool>)null, "", (Func<bool>)null, (Func<bool>)null, (Func<string>)null);
		}

		private void Update()
		{
			if (!Gc.IsHeadless)
			{
				Module.Guard("Kiste leeren", (Action)GC.Client.QuickTake.Plugin.Update);
			}
		}
	}
	internal static class GcMod
	{
		public const string Id = "kisteleeren";

		public const string Guid = "gorduan.gc.kisteleeren";

		public const string Name = "GC_KisteLeeren";

		public const string Version = "1.7.0";

		public const int Stufe = 2;

		public static readonly Type[] PatchTypes = new Type[2]
		{
			typeof(ContainerInteractPatch),
			typeof(OpenResponsePatch)
		};

		public static readonly List<string> FailedPatches = new List<string>();

		public static GcModInfo Info => new GcModInfo
		{
			Id = "kisteleeren",
			Guid = "gorduan.gc.kisteleeren",
			Name = "GC_KisteLeeren",
			Version = "1.7.0",
			Stufe = 2,
			Seite = (GcSeite)0,
			Braucht = Array.Empty<string>(),
			Partner = Array.Empty<string>(),
			Fremd = Array.Empty<string>(),
			AlteConfig = "gorduan.gc_client.cfg",
			Ausgleich = 0f
		};

		public static void PatchAll(Harmony harmony)
		{
			Type[] patchTypes = PatchTypes;
			foreach (Type type in patchTypes)
			{
				try
				{
					harmony.CreateClassProcessor(type).Patch();
				}
				catch (Exception arg)
				{
					FailedPatches.Add(type.Name);
					Logger.CreateLogSource("GC_KisteLeeren").LogError((object)$"Patch {type.FullName} nicht eingespielt, diese Funktion fehlt: {arg}");
				}
			}
		}
	}
}
namespace System.Runtime.CompilerServices
{
	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
	internal sealed class <197c1f94-b781-4c1b-9076-9b8adab7750f>IgnoresAccessChecksToAttribute : Attribute
	{
		public <197c1f94-b781-4c1b-9076-9b8adab7750f>IgnoresAccessChecksToAttribute(string assemblyName)
		{
		}
	}
}
namespace GC.Client
{
	internal static class <c1acd51f-b3b7-4440-a8e6-6769e04434a6>ClientPlugin
	{
		internal static ManualLogSource Log;

		internal static GcModule? Module;

		internal static bool Allowed
		{
			get
			{
				if (Module != null)
				{
					return Module.Allowed;
				}
				return true;
			}
		}

		internal static bool OnServer
		{
			get
			{
				if (Module != null)
				{
					return Module.OnServer;
				}
				return false;
			}
		}
	}
}
namespace GC.Client.ModKompass
{
	[BepInPlugin("gorduan.gc.kompass", "GC_Kompass", "1.7.0")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[NetworkCompatibility(/*Could not decode attribute arguments.*/)]
	public class Plugin : BaseUnityPlugin
	{
		internal static GcModule Module;

		private void Awake()
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Expected O, but got Unknown
			Module = GcKern.Register((BaseUnityPlugin)(object)this, ((BaseUnityPlugin)this).Logger, GcMod.Info);
			<c1acd51f-b3b7-4440-a8e6-6769e04434a6>ClientPlugin.Log = ((BaseUnityPlugin)this).Logger;
			<c1acd51f-b3b7-4440-a8e6-6769e04434a6>ClientPlugin.Module = Module;
			Harmony harmony = new Harmony("gorduan.gc.kompass");
			GC.Client.Compass.Plugin.Init(((BaseUnityPlugin)this).Config, harmony);
			Module.TakeOverOldSettings();
			GcMod.PatchAll(harmony);
			Module.MenuGroup((Func<string, string>)((string key) => GcLoc.Get("gccm_" + key, Array.Empty<object>())), (string)null).Main("compass", (ConfigEntryBase)(object)GC.Client.Compass.Plugin.Enabled, (Func<bool>)null, "", (Func<string>)null, 0.0, "", (Func<bool>)null, (Func<bool>)null, (Func<string>)null).Sub("compass_focus_key", (ConfigEntryBase)(object)GC.Client.Compass.Plugin.FocusModifier, 0.0, "", (Func<bool>)null, "", (Func<bool>)null, (Func<bool>)null, (Func<string>)null)
				.Sub("compass_width", (ConfigEntryBase)(object)GC.Client.Compass.Plugin.WidthPercent, 5.0, " %", (Func<bool>)null, "", (Func<bool>)null, (Func<bool>)null, (Func<string>)null)
				.Sub("compass_fov", (ConfigEntryBase)(object)GC.Client.Compass.Plugin.FieldOfView, 15.0, "°", (Func<bool>)null, "", (Func<bool>)null, (Func<bool>)null, (Func<string>)null)
				.Sub("compass_offset", (ConfigEntryBase)(object)GC.Client.Compass.Plugin.OffsetY, 10.0, " px", (Func<bool>)null, "", (Func<bool>)null, (Func<bool>)null, (Func<string>)null)
				.Sub("compass_scale", (ConfigEntryBase)(object)GC.Client.Compass.Plugin.Scale, 0.1, " ×", (Func<bool>)null, "", (Func<bool>)null, (Func<bool>)null, (Func<string>)null)
				.Sub("compass_range", (ConfigEntryBase)(object)GC.Client.Compass.Plugin.MaxDistance, 250.0, " m", (Func<bool>)null, "", (Func<bool>)null, (Func<bool>)null, (Func<string>)null)
				.Sub("compass_names", (ConfigEntryBase)(object)GC.Client.Compass.Plugin.OtherNames, 0.0, "", (Func<bool>)null, "", (Func<bool>)null, (Func<bool>)null, (Func<string>)null)
				.Sub("compass_name_range", (ConfigEntryBase)(object)GC.Client.Compass.Plugin.NameDistance, 25.0, " m", (Func<bool>)null, "", (Func<bool>)null, (Func<bool>)null, (Func<string>)null)
				.Sub("compass_distance", (ConfigEntryBase)(object)GC.Client.Compass.Plugin.ShowDistance, 0.0, "", (Func<bool>)null, "", (Func<bool>)null, (Func<bool>)null, (Func<string>)null)
				.Sub("compass_checked", (ConfigEntryBase)(object)GC.Client.Compass.Plugin.ShowChecked, 0.0, "", (Func<bool>)null, "", (Func<bool>)null, (Func<bool>)null, (Func<string>)null)
				.Sub("compass_players", (ConfigEntryBase)(object)GC.Client.Compass.Plugin.ShowPlayers, 0.0, "", (Func<bool>)null, "", (Func<bool>)null, (Func<bool>)null, (Func<string>)null)
				.Sub("compass_icons", (ConfigEntryBase)(object)GC.Client.Compass.Plugin.Icons, 0.0, "", (Func<bool>)null, "", (Func<bool>)null, (Func<bool>)null, (Func<string>)null);
		}
	}
	internal static class GcMod
	{
		public const string Id = "kompass";

		public const string Guid = "gorduan.gc.kompass";

		public const string Name = "GC_Kompass";

		public const string Version = "1.7.0";

		public const int Stufe = 1;

		public static readonly Type[] PatchTypes = new Type[4]
		{
			typeof(CameraPatch),
			typeof(FocusClickPatch),
			typeof(FocusDoubleClickPatch),
			typeof(MapColorPatch)
		};

		public static readonly List<string> FailedPatches = new List<string>();

		public static GcModInfo Info
		{
			get
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				//IL_0006: Expected O, but got Unknown
				//IL_003b: Unknown result type (might be due to invalid IL or missing references)
				GcModInfo val = new GcModInfo();
				val.Id = "kompass";
				val.Guid = "gorduan.gc.kompass";
				val.Name = "GC_Kompass";
				val.Version = "1.7.0";
				val.Stufe = 1;
				val.Seite = (GcSeite)0;
				val.Braucht = Array.Empty<string>();
				val.Partner = new string[1] { "dungeonkarte" };
				val.Fremd = Array.Empty<string>();
				val.AlteConfig = "gorduan.gc_client.cfg";
				val.Ausgleich = 0f;
				return val;
			}
		}

		public static void PatchAll(Harmony harmony)
		{
			Type[] patchTypes = PatchTypes;
			foreach (Type type in patchTypes)
			{
				try
				{
					harmony.CreateClassProcessor(type).Patch();
				}
				catch (Exception arg)
				{
					FailedPatches.Add(type.Name);
					Logger.CreateLogSource("GC_Kompass").LogError((object)$"Patch {type.FullName} nicht eingespielt, diese Funktion fehlt: {arg}");
				}
			}
		}
	}
}
namespace GC.Client.Compass
{
	internal enum NameMode
	{
		Always,
		Near,
		Never
	}
	internal enum IconStyle
	{
		MapIcon,
		Dot
	}
	internal static class Plugin
	{
		internal static ManualLogSource Log = null;

		internal static ConfigEntry<bool> Enabled = null;

		internal static ConfigEntry<KeyCode> FocusModifier = null;

		internal static ConfigEntry<int> WidthPercent = null;

		internal static ConfigEntry<int> FieldOfView = null;

		internal static ConfigEntry<int> OffsetY = null;

		internal static ConfigEntry<float> Scale = null;

		internal static ConfigEntry<int> MaxDistance = null;

		internal static ConfigEntry<NameMode> OtherNames = null;

		internal static ConfigEntry<int> NameDistance = null;

		internal static ConfigEntry<bool> ShowDistance = null;

		internal static ConfigEntry<bool> ShowChecked = null;

		internal static ConfigEntry<bool> ShowPlayers = null;

		internal static ConfigEntry<IconStyle> Icons = null;

		internal static CompassView? View;

		private static string lastError = "";

		internal static bool On
		{
			get
			{
				if (Enabled.Value)
				{
					return <c1acd51f-b3b7-4440-a8e6-6769e04434a6>ClientPlugin.Allowed;
				}
				return false;
			}
		}

		internal static bool FocusKeyHeld
		{
			get
			{
				//IL_0013: Unknown result type (might be due to invalid IL or missing references)
				//IL_001f: Unknown result type (might be due to invalid IL or missing references)
				if (On && !Game.m_noMap && (int)FocusModifier.Value != 0)
				{
					return Input.GetKey(FocusModifier.Value);
				}
				return false;
			}
		}

		internal static void Init(ConfigFile Config, Harmony harmony)
		{
			Log = <c1acd51f-b3b7-4440-a8e6-6769e04434a6>ClientPlugin.Log;
			Enabled = Gc.Bind<bool>(Config, "11 - Compass", "Enabled", true, "Kompass oben am Bildschirm (auch im Menü GC Option).", (AcceptableValueBase)null);
			FocusModifier = Gc.Bind<KeyCode>(Config, "11 - Compass", "FocusModifier", (KeyCode)308, "Diese Taste halten und auf der großen Karte eine Markierung anklicken: wird zum Ziel (golden). Nochmal klicken oder auf eine leere Stelle klicken hebt das Ziel auf.", (AcceptableValueBase)null);
			WidthPercent = Gc.Bind<int>(Config, "11 - Compass", "WidthPercent", 50, "Breite des Kompasses in Prozent der Bildschirmbreite.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(20, 100));
			FieldOfView = Gc.Bind<int>(Config, "11 - Compass", "FieldOfView", 180, "So viel Grad zeigt die Leiste (180 = von West bis Ost, wenn du nach Norden schaust).", (AcceptableValueBase)(object)new AcceptableValueRange<int>(90, 360));
			OffsetY = Gc.Bind<int>(Config, "11 - Compass", "OffsetY", 10, "Abstand vom oberen Bildschirmrand in Pixeln. Boss- und Raid-Leiste schieben den Kompass zusätzlich nach unten.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(0, 600));
			Scale = Gc.Bind<float>(Config, "11 - Compass", "Scale", 1f, "Größe von Symbolen und Schrift.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.5f, 2f));
			MaxDistance = Gc.Bind<int>(Config, "11 - Compass", "MaxDistance", 2000, "Andere Markierungen bis zu dieser Entfernung in Metern zeigen. Ziel und Pings immer.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(250, 20000));
			OtherNames = Gc.Bind<NameMode>(Config, "11 - Compass", "OtherNames", NameMode.Near, "Namen anderer Markierungen: Always, Near (bis NameDistance) oder Never. Ziel und Pings zeigen ihren Namen immer.", (AcceptableValueBase)null);
			NameDistance = Gc.Bind<int>(Config, "11 - Compass", "NameDistance", 300, "Bis zu dieser Entfernung in Metern zeigen andere Markierungen ihren Namen (OtherNames = Near).", (AcceptableValueBase)(object)new AcceptableValueRange<int>(25, 5000));
			ShowDistance = Gc.Bind<bool>(Config, "11 - Compass", "ShowDistance", true, "Entfernung bei Ziel und Pings anzeigen.", (AcceptableValueBase)null);
			ShowChecked = Gc.Bind<bool>(Config, "11 - Compass", "ShowChecked", false, "Auf der Karte abgehakte (durchgestrichene) Markierungen zeigen. Das Ziel wird immer gezeigt.", (AcceptableValueBase)null);
			ShowPlayers = Gc.Bind<bool>(Config, "11 - Compass", "ShowPlayers", true, "Mitspieler zeigen, die auf der Karte sichtbar sind.", (AcceptableValueBase)null);
			Icons = Gc.Bind<IconStyle>(Config, "11 - Compass", "IconStyle", IconStyle.MapIcon, "Symbole: MapIcon (Kartensymbol) oder Dot (Punkt).", (AcceptableValueBase)null);
			Enabled.SettingChanged += delegate
			{
				Focus.RefreshMap();
			};
		}

		internal static void Tick(GameCamera camera)
		{
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Invalid comparison between Unknown and I4
			if (Gc.IsHeadless)
			{
				return;
			}
			try
			{
				Player localPlayer = Player.m_localPlayer;
				Focus.Tick(localPlayer);
				if (!On || !((Object)(object)localPlayer != (Object)null) || !((Object)(object)Hud.instance != (Object)null) || !((Object)(object)Hud.instance.m_rootObject != (Object)null) || !Hud.instance.IsVisible() || ((Character)localPlayer).InIntro() || GameCamera.InFreeFly() || ((Object)(object)Minimap.instance != (Object)null && (int)Minimap.instance.m_mode == 2) || GcHooks.IsDungeonMapLargeOpen())
				{
					View?.Hide();
					return;
				}
				if (View == null)
				{
					View = new CompassView();
				}
				View.Draw(localPlayer, camera);
			}
			catch (Exception ex)
			{
				View?.Hide();
				string text = ex.GetType().Name + "|" + ex.TargetSite?.Name + "|" + ex.Message;
				if (text != lastError)
				{
					lastError = text;
					Log.LogError((object)$"Kompass: {ex}");
				}
			}
		}
	}
	[HarmonyPatch(typeof(GameCamera), "LateUpdate")]
	internal static class CameraPatch
	{
		private static void Postfix(GameCamera __instance)
		{
			Plugin.Tick(__instance);
		}
	}
	[HarmonyPatch(typeof(Minimap), "OnMapLeftClick")]
	internal static class FocusClickPatch
	{
		[HarmonyPriority(800)]
		private static bool Prefix(Minimap __instance)
		{
			if (!Plugin.FocusKeyHeld)
			{
				return true;
			}
			__instance.HidePinTextInput(false);
			PinData val = Focus.PinAtCursor(__instance);
			if (val != null)
			{
				Focus.Toggle(val);
			}
			else if (Focus.Active)
			{
				Focus.Remove();
			}
			else
			{
				Gc.TopLeft(GcLoc.Get("gcc_no_pin", Array.Empty<object>()));
			}
			return false;
		}
	}
	[HarmonyPatch(typeof(Minimap), "OnMapDblClick")]
	internal static class FocusDoubleClickPatch
	{
		[HarmonyPriority(800)]
		private static bool Prefix()
		{
			return !Plugin.FocusKeyHeld;
		}
	}
	[HarmonyPatch(typeof(Minimap), "UpdatePins")]
	internal static class MapColorPatch
	{
		private static void Postfix()
		{
			//IL_0025: 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)
			PinData pin = Focus.Pin;
			if (Plugin.On && pin != null)
			{
				if ((Object)(object)pin.m_iconElement != (Object)null)
				{
					((Graphic)pin.m_iconElement).color = CompassView.FocusColor;
				}
				if (pin.m_NamePinData != null && (Object)(object)pin.m_NamePinData.PinNameText != (Object)null)
				{
					((Graphic)pin.m_NamePinData.PinNameText).color = CompassView.FocusColor;
				}
			}
		}
	}
	internal static class Focus
	{
		private const string DataPrefix = "gc_compass_focus_";

		internal static PinData? Pin;

		private static bool active;

		private static PinType type;

		private static string name = "";

		private static Vector3 position;

		private static bool everFound;

		private static float searchUntil;

		private static float nextSearch;

		private static Game? game;

		private static Player? owner;

		private static bool loaded;

		internal static bool Active => active;

		internal static void Tick(Player? player)
		{
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_014e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0155: Invalid comparison between Unknown and I4
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Invalid comparison between Unknown and I4
			//IL_00e1: 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_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			if (Game.instance != game)
			{
				game = Game.instance;
				Pin = null;
				active = false;
				owner = null;
				loaded = false;
			}
			Minimap instance = Minimap.instance;
			if ((Object)(object)player == (Object)null || (Object)(object)instance == (Object)null || (Object)(object)ZNet.instance == (Object)null)
			{
				return;
			}
			if (player != owner)
			{
				owner = player;
				if (!loaded)
				{
					loaded = true;
					Load(player);
				}
				else
				{
					Save();
				}
			}
			if (!active || !Plugin.On)
			{
				return;
			}
			if (Pin != null)
			{
				if (!instance.m_pins.Contains(Pin) || Pin.m_type != type || Pin.m_name != name)
				{
					Pin = null;
				}
				else if ((int)type != 10 && Utils.DistanceXZ(Pin.m_pos, position) > 1f)
				{
					position = Pin.m_pos;
					Save();
				}
			}
			if (Pin == null && Time.time >= nextSearch)
			{
				nextSearch = Time.time + 0.5f;
				Pin = Find(instance);
				if (Pin != null)
				{
					everFound = true;
					instance.m_pinUpdateRequired = true;
				}
				else if ((int)type != 10 && (everFound || Time.time > searchUntil))
				{
					Clear();
				}
			}
		}

		internal static PinData? PinAtCursor(Minimap map)
		{
			//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_0057: 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)
			Vector3 val = map.ScreenToWorldPoint(ZInput.pointerPosition);
			float num = map.PinInteractRadius;
			PinData result = null;
			foreach (PinData pin in map.m_pins)
			{
				if (Selectable(pin) && !((Object)(object)pin.m_uiElement == (Object)null) && ((Component)pin.m_uiElement).gameObject.activeInHierarchy)
				{
					float num2 = Utils.DistanceXZ(val, pin.m_pos);
					if (num2 < num)
					{
						num = num2;
						result = pin;
					}
				}
			}
			return result;
		}

		internal static bool Selectable(PinData pin)
		{
			//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_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Expected I4, but got Unknown
			PinType val = pin.m_type;
			switch (val - 7)
			{
			case 0:
			case 5:
			case 6:
				return false;
			case 1:
				return (Object)(object)pin.m_icon != (Object)null;
			default:
				return true;
			}
		}

		internal static void Toggle(PinData pin)
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_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)
			if (active && Pin == pin)
			{
				Remove();
				return;
			}
			Pin = pin;
			active = true;
			everFound = true;
			type = pin.m_type;
			name = pin.m_name;
			position = pin.m_pos;
			Save();
			RefreshMap();
			Gc.TopLeft(GcLoc.Get("gcc_focus_set", new object[1] { CompassView.PinName(pin, fallback: true) }));
		}

		internal static void Remove()
		{
			Clear();
			Gc.TopLeft(GcLoc.Get("gcc_focus_clear", Array.Empty<object>()));
		}

		internal static void RefreshMap()
		{
			if ((Object)(object)Minimap.instance != (Object)null)
			{
				Minimap.instance.m_pinUpdateRequired = true;
			}
		}

		private static void Clear()
		{
			active = false;
			Pin = null;
			Save();
			RefreshMap();
		}

		private static PinData? Find(Minimap map)
		{
			//IL_0017: 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_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Invalid comparison between Unknown and I4
			//IL_003f: 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)
			foreach (PinData pin in map.m_pins)
			{
				if (pin.m_type == type && pin.m_name == name && ((int)type == 10 || Utils.DistanceXZ(pin.m_pos, position) < 1f))
				{
					return pin;
				}
			}
			return null;
		}

		private static string Key()
		{
			return "gc_compass_focus_" + ZNet.instance.GetWorldUID().ToString(CultureInfo.InvariantCulture);
		}

		private static void Load(Player player)
		{
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			active = false;
			Pin = null;
			everFound = false;
			searchUntil = Time.time + 20f;
			if (player.m_customData.TryGetValue(Key(), out var value))
			{
				string[] array = value.Split(new char[1] { ';' }, 4);
				if (array.Length == 4 && int.TryParse(array[0], NumberStyles.Integer, CultureInfo.InvariantCulture, out var result) && float.TryParse(array[1], NumberStyles.Float, CultureInfo.InvariantCulture, out var result2) && float.TryParse(array[2], NumberStyles.Float, CultureInfo.InvariantCulture, out var result3))
				{
					type = (PinType)result;
					position = new Vector3(result2, 0f, result3);
					name = array[3];
					active = true;
				}
			}
		}

		private static void Save()
		{
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Expected I4, but got Unknown
			if (!((Object)(object)owner == (Object)null) && !((Object)(object)ZNet.instance == (Object)null))
			{
				if (!active)
				{
					owner.m_customData.Remove(Key());
					return;
				}
				owner.m_customData[Key()] = string.Join(";", ((int)type).ToString(CultureInfo.InvariantCulture), position.x.ToString("R", CultureInfo.InvariantCulture), position.z.ToString("R", CultureInfo.InvariantCulture), name);
			}
		}
	}
	internal sealed class CompassView
	{
		private sealed class Marker
		{
			public Image Icon;

			public Image Plate;

			public Text Label;
		}

		private struct Item
		{
			public PinData? Pin;

			public Sprite? Icon;

			public string Name;

			public Color Color;

			public float Distance;

			public float Rel;

			public bool Focus;

			public bool Faded;

			public float X;

			public float Fade;

			public Marker? Marker;
		}

		private sealed class FarFirstComparer : IComparer<Item>
		{
			public int Compare(Item a, Item b)
			{
				return b.Distance.CompareTo(a.Distance);
			}
		}

		private sealed class HighlightComparer : IComparer<Item>
		{
			public int Compare(Item a, Item b)
			{
				if (a.Focus == b.Focus)
				{
					return b.Distance.CompareTo(a.Distance);
				}
				if (!a.Focus)
				{
					return -1;
				}
				return 1;
			}
		}

		internal static readonly Color FocusColor = new Color(1f, 0.8f, 0.2f, 1f);

		private static readonly Color PingColor = new Color(0.45f, 0.62f, 1f, 1f);

		private static readonly Color NorthColor = new Color(1f, 0.6f, 0.35f, 1f);

		private static readonly Color MinorColor = new Color(0.85f, 0.85f, 0.85f, 1f);

		private static readonly Color PlateColor = new Color(0f, 0f, 0f, 0.6f);

		private const float NearDistance = 50f;

		private const int MaxNormals = 80;

		private const float RowLabel = -12f;

		private const float RowIcon = -37f;

		private const float RowLine = -55f;

		private const float RowLetters = -69f;

		private const float RowLabel1 = -92f;

		private const float RowLabel2 = -115f;

		private static readonly FarFirstComparer FarFirst = new FarFirstComparer();

		private static readonly HighlightComparer HighlightOrder = new HighlightComparer();

		private GameObject? root;

		private RectTransform rootRect;

		private RectTransform normalLayer;

		private RectTransform highlightLayer;

		private Image band;

		private Image line;

		private Image center;

		private Image leftEnd;

		private Image rightEnd;

		private readonly Text[] letters = (Text[])(object)new Text[8];

		private readonly Image[] ticks = (Image[])(object)new Image[16];

		private readonly List<Marker> normalPool = new List<Marker>();

		private readonly List<Marker> highlightPool = new List<Marker>();

		private readonly List<Item> normals = new List<Item>();

		private readonly List<Item> highlights = new List<Item>();

		private readonly List<WorldTextInstance> pings = new List<WorldTextInstance>();

		private readonly List<Vector2>[] taken = new List<Vector2>[3]
		{
			new List<Vector2>(),
			new List<Vector2>(),
			new List<Vector2>()
		};

		private readonly List<RectTransform> blockers = new List<RectTransform>();

		private readonly Vector3[] corners = (Vector3[])(object)new Vector3[4];

		private Vector3 layoutKey = new Vector3(-1f, -1f, -1f);

		private float rowLabel0;

		private float rowLabel1;

		private float rowLabel2;

		private Sprite? pingSprite;

		private static bool widthWarned;

		private static readonly string[] BossParts = new string[2] { "Health", "Name" };

		private const string LeashBarHud = "GC_LeashBar";

		private const string LeashBarGrid = "GC_LeashBarGrid";

		private RectTransform? leashBarHud;

		private RectTransform? leashBarGrid;

		private float nextLeashBarSearch;

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

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

		private static float nextLocationScan;

		public void Hide()
		{
			if ((Object)(object)root != (Object)null && root.activeSelf)
			{
				root.SetActive(false);
			}
		}

		public void Draw(Player player, GameCamera camera)
		{
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			Build();
			if (!root.activeSelf)
			{
				root.SetActive(true);
			}
			float value = Plugin.Scale.Value;
			Layout(value);
			Rect rect = rootRect.rect;
			float num = ((Rect)(ref rect)).width * 0.5f;
			if (num <= 1f)
			{
				root.SetActive(false);
				return;
			}
			float halfFov = (float)Mathf.Clamp(Plugin.FieldOfView.Value, 30, 360) * 0.5f;
			float y = ((Component)camera).transform.eulerAngles.y;
			rowLabel0 = -12f * value;
			rowLabel1 = -92f * value;
			rowLabel2 = -115f * value;
			DrawDial(y, num, halfFov, value);
			Collect(player, y, halfFov);
			DrawNormals(num, halfFov, value);
			DrawHighlights(num, halfFov, value);
		}

		private void Build()
		{
			//IL_003c: 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_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Expected O, but got Unknown
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Expected O, but got Unknown
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0134: Unknown result type (might be due to invalid IL or missing references)
			//IL_0174: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_0204: Unknown result type (might be due to invalid IL or missing references)
			//IL_0275: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)root != (Object)null))
			{
				normalPool.Clear();
				highlightPool.Clear();
				pingSprite = null;
				layoutKey = new Vector3(-1f, -1f, -1f);
				root = new GameObject("GC_Compass", new Type[2]
				{
					typeof(RectTransform),
					typeof(CanvasGroup)
				});
				root.transform.SetParent(Hud.instance.m_rootObject.transform, false);
				root.transform.SetAsFirstSibling();
				CanvasGroup component = root.GetComponent<CanvasGroup>();
				component.blocksRaycasts = false;
				component.interactable = false;
				rootRect = (RectTransform)root.transform;
				rootRect.pivot = new Vector2(0.5f, 1f);
				band = CreateImage(root.transform, "Band", Sprites.Band);
				band.preserveAspect = false;
				((Graphic)band).color = new Color(0f, 0f, 0f, 0.35f);
				line = CreateImage(root.transform, "Line", null);
				((Graphic)line).color = new Color(1f, 1f, 1f, 0.85f);
				leftEnd = CreateImage(root.transform, "LeftEnd", Sprites.Triangle);
				((Transform)((Graphic)leftEnd).rectTransform).localEulerAngles = new Vector3(0f, 0f, 180f);
				((Graphic)leftEnd).color = ((Graphic)line).color;
				rightEnd = CreateImage(root.transform, "RightEnd", Sprites.Triangle);
				((Graphic)rightEnd).color = ((Graphic)line).color;
				for (int i = 0; i < ticks.Length; i++)
				{
					ticks[i] = CreateImage(root.transform, "Tick", null);
				}
				center = CreateImage(root.transform, "Center", null);
				((Graphic)center).color = new Color(1f, 1f, 1f, 0.95f);
				string[] array = new string[8] { "n", "ne", "e", "se", "s", "sw", "w", "nw" };
				for (int j = 0; j < letters.Length; j++)
				{
					letters[j] = CreateText(root.transform, GUIManager.Instance.NorseBold);
					letters[j].text = GcLoc.Get("gcc_dir_" + array[j], Array.Empty<object>());
				}
				normalLayer = CreateLayer("Markers");
				highlightLayer = CreateLayer("Highlights");
				root.SetActive(false);
			}
		}

		private RectTransform CreateLayer(string name)
		{
			//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_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: 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_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0065: Expected O, but got Unknown
			GameObject val = new GameObject(name, new Type[1] { typeof(RectTransform) });
			val.transform.SetParent(root.transform, false);
			RectTransform val2 = (RectTransform)val.transform;
			val2.anchorMin = Vector2.zero;
			val2.anchorMax = Vector2.one;
			Vector2 offsetMin = (val2.offsetMax = Vector2.zero);
			val2.offsetMin = offsetMin;
			return val2;
		}

		private static Image CreateImage(Transform parent, string name, Sprite? sprite)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: 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_0082: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject(name, new Type[2]
			{
				typeof(RectTransform),
				typeof(Image)
			});
			val.transform.SetParent(parent, false);
			Image component = val.GetComponent<Image>();
			component.sprite = sprite;
			((Graphic)component).raycastTarget = false;
			component.preserveAspect = (Object)(object)sprite != (Object)null;
			RectTransform rectTransform = ((Graphic)component).rectTransform;
			Vector2 val2 = default(Vector2);
			((Vector2)(ref val2))..ctor(0.5f, 1f);
			rectTransform.anchorMax = val2;
			rectTransform.anchorMin = val2;
			rectTransform.pivot = new Vector2(0.5f, 0.5f);
			return component;
		}

		private static Text CreateText(Transform parent, Font font)
		{
			//IL_0015: 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_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			Text component = GUIManager.Instance.CreateText("", parent, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), Vector2.zero, font, 14, Color.white, true, Color.black, 300f, 30f, false).GetComponent<Text>();
			component.alignment = (TextAnchor)4;
			component.horizontalOverflow = (HorizontalWrapMode)1;
			component.verticalOverflow = (VerticalWrapMode)1;
			component.supportRichText = true;
			((Graphic)component).raycastTarget = false;
			return component;
		}

		private Marker GetMarker(List<Marker> pool, RectTransform layer, int index)
		{
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			while (pool.Count <= index)
			{
				Marker marker = new Marker
				{
					Plate = CreateImage((Transform)(object)layer, "Plate", null),
					Label = CreateText((Transform)(object)layer, GUIManager.Instance.AveriaSerifBold),
					Icon = CreateImage((Transform)(object)layer, "Icon", null)
				};
				((Graphic)marker.Plate).color = PlateColor;
				Show((Graphic)(object)marker.Plate, show: false);
				Show((Graphic)(object)marker.Label, show: false);
				pool.Add(marker);
			}
			return pool[index];
		}

		private static void Show(Graphic graphic, bool show)
		{
			if (((Component)graphic).gameObject.activeSelf != show)
			{
				((Component)graphic).gameObject.SetActive(show);
			}
		}

		private static void HideFrom(List<Marker> pool, int start)
		{
			for (int i = start; i < pool.Count; i++)
			{
				Show((Graphic)(object)pool[i].Icon, show: false);
				Show((Graphic)(object)pool[i].Plate, show: false);
				Show((Graphic)(object)pool[i].Label, show: false);
			}
		}

		private static void Place(Graphic graphic, float x, float y, float width, float height)
		{
			//IL_0009: 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)
			RectTransform rectTransform = graphic.rectTransform;
			rectTransform.anchoredPosition = new Vector2(x, y);
			rectTransform.sizeDelta = new Vector2(width, height);
		}

		private void Layout(float s)
		{
			//IL_0018: 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_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: 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_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			Vector3 val = default(Vector3);
			((Vector3)(ref val))..ctor((float)Plugin.WidthPercent.Value, s, 0f);
			if (val != layoutKey)
			{
				layoutKey = val;
				Stretch(s);
			}
			Rect rect = rootRect.rect;
			if (((Rect)(ref rect)).width <= 2f && MoveToCanvas())
			{
				Stretch(s);
			}
			float num = 0f - BlockerOffset(Plugin.OffsetY.Value);
			if (!Mathf.Approximately(rootRect.anchoredPosition.y, num))
			{
				rootRect.anchoredPosition = new Vector2(0f, num);
			}
		}

		private void Stretch(float s)
		{
			//IL_0033: 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_0071: Unknown result type (might be due to invalid IL or missing references)
			float num = (float)Mathf.Clamp(Plugin.WidthPercent.Value, 10, 100) / 100f;
			rootRect.anchorMin = new Vector2(0.5f - num / 2f, 1f);
			rootRect.anchorMax = new Vector2(0.5f + num / 2f, 1f);
			rootRect.sizeDelta = new Vector2(0f, 130f * s);
		}

		private unsafe bool MoveToCanvas()
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Expected O, but got Unknown
			//IL_002f: 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_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: 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)
			RectTransform val = (RectTransform)((Transform)rootRect).parent;
			Canvas componentInParent = ((Component)val).GetComponentInParent<Canvas>();
			RectTransform val2 = ((!((Object)(object)componentInParent != (Object)null)) ? ((RectTransform)null) : ((RectTransform)((Component)componentInParent.rootCanvas).transform));
			Rect rect;
			if (!widthWarned)
			{
				widthWarned = true;
				string text = ((Object)val).name;
				Transform parent = ((Transform)val).parent;
				while ((Object)(object)parent != (Object)null)
				{
					text = ((Object)parent).name + "/" + text;
					parent = parent.parent;
				}
				ManualLogSource log = Plugin.Log;
				string arg = text;
				object arg2 = val.rect;
				object arg3;
				if (!((Object)(object)val2 != (Object)null))
				{
					arg3 = "-";
				}
				else
				{
					string name = ((Object)val2).name;
					rect = val2.rect;
					arg3 = name + " " + ((obje