using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using System.Text.RegularExpressions;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using SeneaLUI;
using SeneaLUI.Components;
using SeneaLUI.Core;
using SeneaLUI.Hud;
using SeneaLUI.Inv;
using SeneaLUI.Map;
using SeneaLUI.Net;
using SeneaLUI.Patches;
using SeneaLUI.Theme;
using Splatform;
using TMPro;
using UnityEngine;
using UnityEngine.EventSystems;
using UnityEngine.Events;
using UnityEngine.Networking;
using UnityEngine.Rendering;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: IgnoresAccessChecksTo("assembly_utils")]
[assembly: IgnoresAccessChecksTo("assembly_valheim")]
[assembly: IgnoresAccessChecksTo("SeneaL-UI")]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: AssemblyCompany("SeneaLUIUnlocker")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.1.0.0")]
[assembly: AssemblyInformationalVersion("1.1.0+451f989c3bd01a2c60337d6c4277b6434ef2ce2a")]
[assembly: AssemblyProduct("SeneaLUIUnlocker")]
[assembly: AssemblyTitle("SeneaLUIUnlocker")]
[assembly: InternalsVisibleTo("SeneaLUIUnlocker.WindowAdditions")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.1.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.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;
		}
	}
	[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;
		}
	}
}
namespace SeneaLUIUnlocker
{
	internal static class Accessibility
	{
		[HarmonyPatch(typeof(Hud), "DamageFlash")]
		internal static class FlashPatch
		{
			private static bool Prefix()
			{
				if (_flash != null)
				{
					return _flash.Value;
				}
				return true;
			}
		}

		[HarmonyPatch(typeof(GameCamera), "AddShake")]
		internal static class ShakePatch
		{
			private static bool Prefix()
			{
				if (_shake != null)
				{
					return _shake.Value;
				}
				return true;
			}
		}

		[HarmonyPatch(typeof(SmokeRenderer), "LateUpdate")]
		internal static class SmokePatch
		{
			private static void Postfix(SmokeRenderer __instance)
			{
				bool flag = _smoke == null || _smoke.Value;
				foreach (ParticleSystem value in __instance.m_chunkedParticleSystems.Values)
				{
					ParticleSystemRenderer val = (((Object)(object)value == (Object)null) ? null : ((Component)value).GetComponent<ParticleSystemRenderer>());
					if ((Object)(object)val != (Object)null && ((Renderer)val).enabled != flag)
					{
						((Renderer)val).enabled = flag;
					}
				}
			}
		}

		private static ConfigEntry<bool> _shake;

		private static ConfigEntry<bool> _smoke;

		private static ConfigEntry<bool> _flash;

		public static void Bind(ConfigFile cfg)
		{
			_shake = cfg.Bind<bool>("Accessibility", "Camera Shake", true, "The camera shakes from hits, explosions and heavy steps, as the game has it; off keeps it still.");
			_smoke = cfg.Bind<bool>("Accessibility", "Show Smoke", true, "Fires' smoke is drawn, as the game has it. Off hides it, while the smoke itself still gathers under roofs and still smokes you out.");
			_flash = cfg.Bind<bool>("Accessibility", "Damage Flash", true, "The screen flashes red when you are hurt, as the game has it; off keeps it clear.");
		}
	}
	internal static class AreaPreview
	{
		private const int Segments = 96;

		private static ConfigEntry<float> _seconds;

		private static readonly HashSet<(string Section, string Key)> Areas = new HashSet<(string, string)>
		{
			("Auto Pins", "Discover Radius"),
			("Auto Pins", "Resource Patch Radius"),
			("Combat HUD", "Combat Enemy Range"),
			("Party", "Party Key Reach"),
			("Party HUD", "Face Picture Distance"),
			("Fuel Helper", "Fuel Radius"),
			("Cheats: Inventory", "Cycle Chests Range"),
			("Cheats: Map", "Ship Exploration Radius (Cheat)"),
			("Cheats: Map", "Walking Exploration Radius (Cheat)"),
			("Previews", "Area Preview Distance"),
			("Unlocked Limits", "Max Craft Range"),
			("Unlocked Limits", "Max Build Range"),
			("Unlocked Limits", "Max Quick Stack Range"),
			("Unlocked Limits", "Max Area Pickup Radius"),
			("Unlocked Limits", "Max Ore Radius"),
			("Unlocked Limits", "Max Radar Range"),
			("Cheats: Beyond Maximums", "Max Chest Range Beyond"),
			("Cheats: Beyond Maximums", "Max Area Pickup Beyond"),
			("Cheats: Beyond Maximums", "Max Ore Radius Beyond"),
			("Cheats: Beyond Maximums", "Max Radar Range Beyond"),
			("Cheats: Portals", "Tames Through Portals Range"),
			("Tames", "Tame Command Range"),
			("Building", "Build Camera Range"),
			("Building", "Repair Nearby Range"),
			("Doors", "Door Open Distance"),
			("Alerts", "Production Alert Range"),
			("Find In Chests", "Find Range")
		};

		private static LineRenderer _ring;

		private static ConfigEntryBase _entry;

		private static float _until;

		public static void Bind(ConfigFile cfg)
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Expected O, but got Unknown
			_seconds = cfg.Bind<float>("Previews", "Range Preview Seconds", 20f, new ConfigDescription("How long a range drawn by an eye button on the settings page stays around you.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(3f, 120f), Array.Empty<object>()));
		}

		public static bool IsArea(ConfigEntryBase entry)
		{
			return Areas.Contains((entry.Definition.Section, entry.Definition.Key));
		}

		public static bool Showing(ConfigEntryBase entry)
		{
			if (_entry == entry)
			{
				return Time.time < _until;
			}
			return false;
		}

		public static void Toggle(ConfigEntryBase entry)
		{
			if (Showing(entry))
			{
				_until = 0f;
				return;
			}
			_entry = entry;
			_until = Time.time + _seconds.Value;
		}

		public static void Tick()
		{
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_011f: Unknown result type (might be due to invalid IL or missing references)
			Player localPlayer = Player.m_localPlayer;
			if (_entry == null || !(Time.time < _until) || !((Object)(object)localPlayer != (Object)null) || !ServerRules.Allows("Previews"))
			{
				if ((Object)(object)_ring != (Object)null && ((Component)_ring).gameObject.activeSelf)
				{
					((Component)_ring).gameObject.SetActive(false);
				}
				return;
			}
			if ((Object)(object)_ring == (Object)null)
			{
				Build();
			}
			((Component)_ring).gameObject.SetActive(true);
			float num = Convert.ToSingle(_entry.BoxedValue);
			Vector3 position = ((Component)localPlayer).transform.position;
			float num3 = default(float);
			for (int i = 0; i < 96; i++)
			{
				float num2 = (float)i * (float)Math.PI * 2f / 96f;
				Vector3 val = position + new Vector3(Mathf.Cos(num2) * num, 0f, Mathf.Sin(num2) * num);
				val.y = (((Object)(object)ZoneSystem.instance != (Object)null && ZoneSystem.instance.GetGroundHeight(val, ref num3)) ? (num3 + 0.3f) : (position.y + 0.3f));
				_ring.SetPosition(i, val);
			}
		}

		private static void Build()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Expected O, but got Unknown
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Expected O, but got Unknown
			//IL_0089: 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)
			GameObject val = new GameObject("SeneaLUIUnlocker_AreaPreview");
			Object.DontDestroyOnLoad((Object)val);
			_ring = val.AddComponent<LineRenderer>();
			_ring.loop = true;
			_ring.positionCount = 96;
			_ring.useWorldSpace = true;
			_ring.widthMultiplier = 0.25f;
			((Renderer)_ring).material = new Material(Shader.Find("Sprites/Default"));
			LineRenderer ring = _ring;
			LineRenderer ring2 = _ring;
			Color val2 = default(Color);
			((Color)(ref val2))..ctor(0.85f, 0.72f, 0.43f, 0.9f);
			ring2.endColor = val2;
			ring.startColor = val2;
			_ring.numCapVertices = 2;
		}
	}
	internal sealed class AutoDoors
	{
		private const string Section = "Doors";

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

		private static readonly int Mask = LayerMask.GetMask(new string[3] { "piece", "piece_nonsolid", "Default" });

		private readonly ConfigEntry<bool> _on;

		private readonly ConfigEntry<float> _distance;

		private readonly ConfigEntry<bool> _close;

		private readonly ConfigEntry<float> _delay;

		private readonly Dictionary<Door, float> _opened = new Dictionary<Door, float>();

		private float _next;

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

		public AutoDoors(ConfigFile cfg)
		{
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Expected O, but got Unknown
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Expected O, but got Unknown
			_on = cfg.Bind<bool>("Doors", "Auto Doors", false, "Doors and gates open as you walk up to them, never ones that need a key or sit in a ward that does not admit you. Off by default because it opens doors other players share.");
			_distance = cfg.Bind<float>("Doors", "Door Open Distance", 2.2f, new ConfigDescription("How close to a door, in meters, you walk before it opens.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(1f, 5f), Array.Empty<object>()));
			_close = cfg.Bind<bool>("Doors", "Close Doors Behind You", true, "Close a door this opened once you have walked away from it and nobody stands in it.");
			_delay = cfg.Bind<float>("Doors", "Door Close Delay", 1.5f, new ConfigDescription("Seconds after you leave a door before it closes behind you.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.2f, 10f), Array.Empty<object>()));
		}

		public void Tick(float now)
		{
			//IL_0059: 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_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0177: Unknown result type (might be due to invalid IL or missing references)
			//IL_017f: Unknown result type (might be due to invalid IL or missing references)
			Player localPlayer = Player.m_localPlayer;
			if (!_on.Value || !ServerRules.Allows("AutoDoors") || (Object)(object)localPlayer == (Object)null || ((Character)localPlayer).IsDead())
			{
				_opened.Clear();
			}
			else
			{
				if (now < _next)
				{
					return;
				}
				_next = now + 0.1f;
				Vector3 position = ((Component)localPlayer).transform.position;
				int num = Physics.OverlapSphereNonAlloc(position, _distance.Value, Near, Mask);
				for (int i = 0; i < num; i++)
				{
					Door val = (((Object)(object)Near[i] == (Object)null) ? null : ((Component)Near[i]).GetComponentInParent<Door>());
					if (!((Object)(object)val == (Object)null) && !_opened.ContainsKey(val) && Usable(val) && State(val) == 0)
					{
						Vector3 val2 = position - ((Component)val).transform.position;
						val.Open(((Vector3)(ref val2)).normalized);
						_opened[val] = float.MaxValue;
						Log(val, "opened");
					}
				}
				List<Door> list = new List<Door>();
				foreach (Door item in new List<Door>(_opened.Keys))
				{
					if ((Object)(object)item == (Object)null || !item.m_nview.IsValid() || State(item) == 0)
					{
						list.Add(item);
						continue;
					}
					if (!(Vector3.Distance(position, ((Component)item).transform.position) > _distance.Value + 0.8f))
					{
						_opened[item] = float.MaxValue;
						continue;
					}
					if (_opened[item] == float.MaxValue)
					{
						_opened[item] = now + _delay.Value;
					}
					if (now >= _opened[item] && _close.Value && !Occupied(item))
					{
						item.m_nview.InvokeRPC("UseDoor", new object[1] { true });
						Log(item, "closed");
						list.Add(item);
					}
					else if (!_close.Value)
					{
						list.Add(item);
					}
				}
				foreach (Door item2 in list)
				{
					_opened.Remove(item2);
				}
			}
		}

		private static int State(Door door)
		{
			if (!((Object)(object)door.m_nview != (Object)null) || !door.m_nview.IsValid())
			{
				return 1;
			}
			return door.m_nview.GetZDO().GetInt(ZDOVars.s_state, 0);
		}

		private static bool Usable(Door door)
		{
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)door.m_nview != (Object)null && door.m_nview.IsValid() && (Object)(object)door.m_keyItem == (Object)null && !door.m_canNotBeClosed)
			{
				if (door.m_checkGuardStone)
				{
					return PrivateArea.CheckAccess(((Component)door).transform.position, 0f, false, false);
				}
				return true;
			}
			return false;
		}

		private static bool Occupied(Door door)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			Characters.Clear();
			Character.GetCharactersInRange(((Component)door).transform.position, 1.6f, Characters);
			return Characters.Count > 0;
		}

		private static void Log(Door door, string what)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			if (DebugLog.On)
			{
				DebugLog.Write("doors", $"{what} {((Object)door).name} at {((Component)door).transform.position}");
			}
		}
	}
	internal static class AutoPickupIgnore
	{
		[HarmonyPatch(typeof(Player), "AutoPickup")]
		internal static class AutoPickupPatch
		{
			private static void Prefix()
			{
				_inAutoPickup = true;
			}

			private static void Finalizer()
			{
				_inAutoPickup = false;
			}
		}

		[HarmonyPatch(typeof(ItemDrop), "CanPickup")]
		internal static class CanPickupPatch
		{
			private static void Postfix(ItemDrop __instance, ref bool __result)
			{
				if (_inAutoPickup && __result && _set.Count != 0 && ServerRules.Allows("AutoPickupIgnore") && __instance.m_itemData != null)
				{
					ItemData itemData = __instance.m_itemData;
					if (_set.Contains(itemData.m_shared.m_name) || Labels().Contains(Shown(itemData.m_shared.m_name)) || ((Object)(object)itemData.m_dropPrefab != (Object)null && _set.Contains(((Object)itemData.m_dropPrefab).name)))
					{
						__result = false;
					}
				}
			}
		}

		private static ConfigEntry<string> _ignored;

		private static HashSet<string> _set = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

		private static bool _inAutoPickup;

		private static HashSet<string> _labels;

		private static HashSet<string> _labelsFor;

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

		public static void Bind(ConfigFile cfg)
		{
			_ignored = cfg.Bind<string>("Auto Pickup", "Never Auto Pickup", "", "Items auto-pickup leaves on the ground; you can still pick them up by hand.");
			_ignored.SettingChanged += delegate
			{
				_set = SettingsPage.Split(_ignored.Value);
			};
			_set = SettingsPage.Split(_ignored.Value);
		}

		private static string Shown(string token)
		{
			if (!ShownCache.TryGetValue(token, out var value))
			{
				value = ((Localization.instance == null) ? token : Localization.instance.Localize(token));
				ShownCache[token] = value;
			}
			return value;
		}

		private static HashSet<string> Labels()
		{
			if (_labelsFor != _set)
			{
				_labelsFor = _set;
				_labels = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
				foreach (string item in _set)
				{
					if (item.StartsWith("$", StringComparison.Ordinal))
					{
						_labels.Add(Shown(item));
					}
				}
			}
			return _labels;
		}
	}
	internal enum DungeonDone
	{
		Key_Pressed,
		All_Chests_Opened,
		Enemies_Cleared,
		Chests_And_Enemies
	}
	internal sealed class AutoPins
	{
		private sealed class Category
		{
			public ConfigEntry<bool> On;

			public ConfigEntry<string> Names;

			public PinType Icon;

			public string Kind;
		}

		private const string Section = "Auto Pins";

		private const string DataKey = "alkeari.senealuiunlocker.autopins";

		private const string DoneKey = "alkeari.senealuiunlocker.dungeonsdone";

		private static readonly Type OreScout = TypeLookup.Find("SeneaLUI.Map.OreScout");

		private static readonly MethodInfo OreWanted = ((OreScout == null) ? null : AccessTools.Method(OreScout, "Wanted", new Type[1] { typeof(string) }, (Type[])null));

		private static readonly PropertyInfo OreDetect = AccessTools.Property(TypeLookup.Find("SeneaLUI.Plugin"), "OreDetect");

		private static readonly PropertyInfo CanOreDetect = AccessTools.Property(TypeLookup.Find("SeneaLUI.Net.Policy"), "CanOreDetect");

		private static readonly FieldInfo SeneaLDungeonType = AccessTools.Field(TypeLookup.Find("SeneaLUI.Map.MapPins"), "Dungeon");

		private const float CheckSeconds = 3f;

		private const float SamePlace = 20f;

		private readonly ConfigEntry<bool> _enabled;

		private readonly ConfigEntry<float> _radius;

		private readonly Category[] _categories;

		private readonly ConfigEntry<bool> _resources;

		private readonly ConfigEntry<string> _resourceItems;

		private readonly ConfigEntry<float> _resourceCluster;

		private readonly ConfigEntry<DungeonDone> _dungeonDone;

		private readonly ConfigEntry<KeyboardShortcut> _doneKey;

		private float _insideSince = -1f;

		private ZoneSystem _audited;

		private readonly ManualLogSource _log;

		private Player _for;

		private HashSet<string> _done = new HashSet<string>();

		private HashSet<string> _dungeonsDone = new HashSet<string>();

		private float _next;

		private int _retypedAt = -1;

		private const float InteriorHeight = 3000f;

		private const float InsideSettleSeconds = 10f;

		private static (string Prefix, string Name, string English)[] KnownNames => new(string, string, string)[19]
		{
			("Mistlands_DvergrBossEntrance", Lang.T("AutoPins.PlaceTheQueen", "The Queen"), "The Queen"),
			("Mistlands_DvergrTownEntrance", Lang.T("AutoPins.PlaceInfestedMine", "Infested Mine"), "Infested Mine"),
			("Hildir_plainsfortress", Lang.T("AutoPins.PlaceSealedTower", "Sealed Tower"), "Sealed Tower"),
			("Vendor_BlackForest", Lang.T("AutoPins.PlaceHaldor", "Haldor"), "Haldor"),
			("FaderLocation", Lang.T("AutoPins.PlaceFader", "Fader"), "Fader"),
			("Hildir_crypt", Lang.T("AutoPins.PlaceSmoulderingTomb", "Smouldering Tomb"), "Smouldering Tomb"),
			("BogWitch_Camp", Lang.T("AutoPins.PlaceBogWitch", "Bog Witch"), "Bog Witch"),
			("Hildir_cave", Lang.T("AutoPins.PlaceHowlingCavern", "Howling Cavern"), "Howling Cavern"),
			("Hildir_camp", Lang.T("AutoPins.PlaceHildir", "Hildir"), "Hildir"),
			("SunkenCrypt", Lang.T("AutoPins.PlaceSunkenCrypt", "Sunken Crypt"), "Sunken Crypt"),
			("MountainCave", Lang.T("AutoPins.PlaceFrostCave", "Frost Cave"), "Frost Cave"),
			("Dragonqueen", Lang.T("AutoPins.PlaceModer", "Moder"), "Moder"),
			("Eikthyrnir", Lang.T("AutoPins.PlaceEikthyr", "Eikthyr"), "Eikthyr"),
			("GoblinKing", Lang.T("AutoPins.PlaceYagluth", "Yagluth"), "Yagluth"),
			("GoblinCamp", Lang.T("AutoPins.PlaceFulingVillage", "Fuling Village"), "Fuling Village"),
			("MorgenHole", Lang.T("AutoPins.PlacePutridHole", "Putrid Hole"), "Putrid Hole"),
			("Runestone_", Lang.T("AutoPins.PlaceRunestone", "Runestone"), "Runestone"),
			("GDKing", Lang.T("AutoPins.PlaceTheElder", "The Elder"), "The Elder"),
			("Crypt", Lang.T("AutoPins.PlaceBurialChambers", "Burial Chambers"), "Burial Chambers")
		};

		public AutoPins(ConfigFile cfg, ManualLogSource log)
		{
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Expected O, but got Unknown
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_010f: Unknown result type (might be due to invalid IL or missing references)
			//IL_012c: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ef: Expected O, but got Unknown
			_log = log;
			_enabled = cfg.Bind<bool>("Auto Pins", "Auto Pins", true, "Pin useful places and resources on the map as you come near them.");
			_radius = cfg.Bind<float>("Auto Pins", "Discover Radius", 60f, new ConfigDescription("Distance, meters, within which a place is pinned.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(10f, 200f), Array.Empty<object>()));
			_categories = new Category[6]
			{
				Make(cfg, "Boss Altars", "Eikthyrnir; GDKing; Bonemass; Dragonqueen; GoblinKing; Mistlands_DvergrBossEntrance; FaderLocation", (PinType)9),
				Make(cfg, "Traders", "Vendor_BlackForest; Hildir_camp; BogWitch_Camp", PinKinds.Of("Traders")),
				Make(cfg, "Dungeons", "Crypt; SunkenCrypt; TrollCave; MountainCave; Mistlands_DvergrTownEntrance; Hildir_crypt; Hildir_cave; Hildir_plainsfortress; MorgenHole; PlaceofMystery", PinKinds.Of("Dungeons")),
				Make(cfg, "Villages And Camps", "WoodVillage; WoodFarm; GoblinCamp; Greydwarf_camp; StoneTowerRuins; Mistlands_Harbour; Mistlands_Excavation; Mistlands_Giant; CharredFortress; CharredRuins; FortressRuins", PinKinds.Of("Villages And Camps")),
				Make(cfg, "Runestones", "Runestone_; DrakeLorestone", PinKinds.Of("Runestones")),
				Make(cfg, "Nests And Pits", "DrakeNest; TarPit; VoltureNest; InfestedTree", PinKinds.Of("Nests And Pits"))
			};
			_resources = cfg.Bind<bool>("Auto Pins", "Pin Resources", false, "Pin pickable resources listed in Resource Items, one pin per patch. Off by default, since it adds a great many pins.");
			_resourceItems = cfg.Bind<string>("Auto Pins", "Resource Items", "Raspberry; Blueberries; Cloudberry; MushroomYellow; MushroomBlue; MushroomJotunPuffs; MushroomMagecap; Thistle; Flax; Barley; CarrotSeeds; TurnipSeeds; OnionSeeds; DragonEgg; SurtlingCore; Fiddleheadfern; Vineberry", "Pickable items that get a pin, by the item's internal name, separated by semicolons.");
			_dungeonDone = cfg.Bind<DungeonDone>("Auto Pins", "Dungeon Done When", DungeonDone.Key_Pressed, "When a pinned dungeon's pin is crossed out: only when you press Mark Dungeon Done Key, or also on its own once every chest inside is empty, once no living enemy is left inside, or once both are true.");
			_doneKey = cfg.Bind<KeyboardShortcut>("Auto Pins", "Mark Dungeon Done Key", new KeyboardShortcut((KeyCode)107, Array.Empty<KeyCode>()), "Crosses out the pin of the dungeon you are in or standing at, or brings it back if it is crossed out. Works whatever Dungeon Done When says. Empty = no key.");
			_resourceCluster = cfg.Bind<float>("Auto Pins", "Resource Patch Radius", 40f, new ConfigDescription("Resources of one kind within this distance, meters, share one pin.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(5f, 200f), Array.Empty<object>()));
		}

		private static Category Make(ConfigFile cfg, string kind, string names, PinType icon)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			return new Category
			{
				Kind = kind,
				Icon = icon,
				On = cfg.Bind<bool>("Auto Pins", "Pin " + kind, true, "Pin " + kind.ToLowerInvariant() + " as you come near them."),
				Names = cfg.Bind<string>("Auto Pins", kind + " Locations", names, "Locations pinned as " + kind.ToLowerInvariant() + ", by the start of the location's internal name, separated by semicolons.")
			};
		}

		public void Tick(float now)
		{
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0183: Unknown result type (might be due to invalid IL or missing references)
			//IL_0188: Unknown result type (might be due to invalid IL or missing references)
			//IL_0194: 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)
			Player localPlayer = Player.m_localPlayer;
			Minimap instance = Minimap.instance;
			if (_enabled.Value && ServerRules.Allows("AutoPins") && (Object)(object)localPlayer != (Object)null && (Object)(object)instance != (Object)null && KeyInput.Pressed(_doneKey.Value) && !InventoryFeatures.Typing())
			{
				ToggleDone(instance, localPlayer);
			}
			if (!_enabled.Value || !ServerRules.Allows("AutoPins") || (Object)(object)localPlayer == (Object)null || (Object)(object)instance == (Object)null || now < _next)
			{
				return;
			}
			_next = now + 3f;
			Audit();
			if ((Object)(object)localPlayer != (Object)(object)_for)
			{
				_for = localPlayer;
				_done = (localPlayer.m_customData.TryGetValue("alkeari.senealuiunlocker.autopins", out var value) ? (from s in value.Split(new char[1] { '|' })
					where s.Length > 0
					select s).ToHashSet() : new HashSet<string>());
				_dungeonsDone = (localPlayer.m_customData.TryGetValue("alkeari.senealuiunlocker.dungeonsdone", out var value2) ? (from s in value2.Split(new char[1] { '|' })
					where s.Length > 0
					select s).ToHashSet() : new HashSet<string>());
			}
			Retype(instance);
			CrossOutSeneaLDungeons(instance);
			Vector3 position = ((Component)localPlayer).transform.position;
			Dungeons(instance, localPlayer, now);
			if (Locations(instance, position) + Resources(instance, position) > 0)
			{
				localPlayer.m_customData["alkeari.senealuiunlocker.autopins"] = string.Join("|", _done);
			}
		}

		private int Locations(Minimap map, Vector3 at)
		{
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: 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)
			int num = 0;
			foreach (Location s_allLocation in Location.s_allLocations)
			{
				if (!((Object)(object)s_allLocation == (Object)null) && !(Vector3.Distance(((Component)s_allLocation).transform.position, at) > _radius.Value))
				{
					string prefab = Prefab(((Component)s_allLocation).gameObject);
					Category category = _categories.FirstOrDefault((Category c) => c.On.Value && Starts(prefab, c.Names.Value));
					if ((category == null || !(category.Kind == "Dungeons") || !SeneaLMarksDungeons()) && category != null)
					{
						num += (Pin(map, ((Component)s_allLocation).transform.position, category.Icon, Label(s_allLocation, prefab), category.Kind) ? 1 : 0);
					}
				}
			}
			return num;
		}

		private int Resources(Minimap map, Vector3 at)
		{
			//IL_0082: 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_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			if (!_resources.Value)
			{
				return 0;
			}
			HashSet<string> hashSet = Split(_resourceItems.Value).ToHashSet<string>(StringComparer.OrdinalIgnoreCase);
			int num = 0;
			foreach (Pickable item in SceneObjects.Live<Pickable>(SceneObjects.Pickables))
			{
				if (!((Object)(object)item == (Object)null) && !((Object)(object)item.m_itemPrefab == (Object)null) && hashSet.Contains(((Object)item.m_itemPrefab).name) && !(Vector3.Distance(((Component)item).transform.position, at) > _radius.Value))
				{
					ItemDrop component = item.m_itemPrefab.GetComponent<ItemDrop>();
					string name = (((Object)(object)component == (Object)null) ? ((Object)item.m_itemPrefab).name : Localization.instance.Localize(component.m_itemData.m_shared.m_name));
					num += (Pin(map, ((Component)item).transform.position, PinKinds.Of("Resources"), name, "res:" + ((Object)item.m_itemPrefab).name, _resourceCluster.Value) ? 1 : 0);
				}
			}
			return num;
		}

		private void Retype(Minimap map)
		{
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Invalid comparison between Unknown and I4
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Invalid comparison between Unknown and I4
			//IL_0102: Unknown result type (might be due to invalid IL or missing references)
			//IL_0104: Unknown result type (might be due to invalid IL or missing references)
			if (map.m_pins.Count == _retypedAt)
			{
				return;
			}
			_retypedAt = map.m_pins.Count;
			foreach (PinData item in map.m_pins.Where((PinData pin) => (int)pin.m_type == 3 && pin.m_ownerID == 0))
			{
				foreach (string item2 in _done)
				{
					int num = item2.LastIndexOf('@');
					string text = ((num < 0) ? "" : item2.Substring(0, num));
					PinType val = (PinType)((!text.StartsWith("res:", StringComparison.Ordinal)) ? ((!PinKinds.Has(text)) ? 3 : ((int)PinKinds.Of(text))) : ((int)PinKinds.Of("Resources")));
					if ((int)val != 3 && Near(item2, text, item.m_pos, text.StartsWith("res:", StringComparison.Ordinal) ? _resourceCluster.Value : 20f))
					{
						item.m_type = val;
						break;
					}
				}
			}
		}

		private bool Pin(Minimap map, Vector3 pos, PinType icon, string name, string kind, float spread = 20f)
		{
			//IL_000f: 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_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Invalid comparison between Unknown and I4
			//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_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			if (_done.Any((string key) => Near(key, kind, pos, spread)))
			{
				return false;
			}
			_done.Add($"{kind}@{Mathf.RoundToInt(pos.x)},{Mathf.RoundToInt(pos.z)}");
			PinData val = ((IEnumerable<PinData>)map.m_pins).FirstOrDefault((Func<PinData, bool>)((PinData pin) => SameName(pin.m_name, name) && Vector3.Distance(pin.m_pos, pos) < spread));
			if (val == null)
			{
				map.AddPin(pos, icon, name, true, false, 0L, default(PlatformUserID));
			}
			else if ((int)val.m_type == 3)
			{
				val.m_type = icon;
			}
			return true;
		}

		private static bool Near(string key, string kind, Vector3 pos, float spread)
		{
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			int num = key.LastIndexOf('@');
			if (num < 0 || key.Substring(0, num) != kind)
			{
				return false;
			}
			string[] array = key.Substring(num + 1).Split(new char[1] { ',' });
			if (array.Length == 2 && int.TryParse(array[0], out var result) && int.TryParse(array[1], out var result2))
			{
				Vector2 val = new Vector2((float)result - pos.x, (float)result2 - pos.z);
				return ((Vector2)(ref val)).magnitude < spread;
			}
			return false;
		}

		private Location CurrentDungeon(Vector3 at)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			Category dungeons = _categories.First((Category c) => c.Kind == "Dungeons");
			return (from l in Location.s_allLocations
				where (Object)(object)l != (Object)null && Starts(Prefab(((Component)l).gameObject), dungeons.Names.Value)
				select (Location: l, Distance: Flat(((Component)l).transform.position, at)) into pair
				where pair.Distance <= Mathf.Max(new float[3]
				{
					pair.Location.m_exteriorRadius,
					pair.Location.m_interiorRadius,
					30f
				})
				orderby pair.Distance
				select pair.Location).FirstOrDefault();
		}

		private PinData DungeonPin(Minimap map, Location dungeon)
		{
			string label = Label(dungeon, Prefab(((Component)dungeon).gameObject));
			PinType? seneaL = SeneaLDungeonPinType();
			return ((IEnumerable<PinData>)map.m_pins).FirstOrDefault((Func<PinData, bool>)((PinData pin) => SameName(pin.m_name, label) && Flat(pin.m_pos, ((Component)dungeon).transform.position) < 20f)) ?? ((IEnumerable<PinData>)map.m_pins).FirstOrDefault((Func<PinData, bool>)((PinData pin) => seneaL.HasValue && pin.m_type == seneaL.Value && Flat(pin.m_pos, ((Component)dungeon).transform.position) < 20f));
		}

		private static PinType? SeneaLDungeonPinType()
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			object obj = SeneaLDungeonType?.GetValue(null);
			if (!(obj is PinType))
			{
				return null;
			}
			return (PinType)obj;
		}

		private static bool SeneaLMarksDungeons()
		{
			try
			{
				int result;
				if (SeneaLDungeonType != null && OreWanted != null && OreDetect?.GetValue(null, null) is ConfigEntry<bool> val && val.Value)
				{
					object obj = CanOreDetect?.GetValue(null, null);
					if (obj is bool && (bool)obj)
					{
						obj = OreWanted.Invoke(null, new object[1] { "dungeon" });
						result = ((obj is bool && (bool)obj) ? 1 : 0);
						goto IL_0093;
					}
				}
				result = 0;
				goto IL_0093;
				IL_0093:
				return (byte)result != 0;
			}
			catch (Exception)
			{
				return false;
			}
		}

		private static string DoneSpot(Vector3 pos)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			return $"{Mathf.RoundToInt(pos.x)},{Mathf.RoundToInt(pos.z)}";
		}

		private void SetDone(Player player, PinData pin, bool done)
		{
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			pin.m_checked = done;
			if (!pin.m_save)
			{
				_dungeonsDone.RemoveWhere((string spot) => SameSpot(spot, pin.m_pos));
				if (done)
				{
					_dungeonsDone.Add(DoneSpot(pin.m_pos));
				}
				player.m_customData["alkeari.senealuiunlocker.dungeonsdone"] = string.Join("|", _dungeonsDone);
			}
		}

		private static bool SameSpot(string spot, Vector3 pos)
		{
			//IL_0032: 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_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			string[] array = spot.Split(new char[1] { ',' });
			if (array.Length == 2 && int.TryParse(array[0], out var result) && int.TryParse(array[1], out var result2))
			{
				Vector2 val = new Vector2((float)result - pos.x, (float)result2 - pos.z);
				return ((Vector2)(ref val)).magnitude < 20f;
			}
			return false;
		}

		private void CrossOutSeneaLDungeons(Minimap map)
		{
			PinType? seneaL = SeneaLDungeonPinType();
			if (!seneaL.HasValue || _dungeonsDone.Count == 0)
			{
				return;
			}
			foreach (PinData item in map.m_pins.Where((PinData pin) => pin.m_type == seneaL.Value && !pin.m_checked && _dungeonsDone.Any((string spot) => SameSpot(spot, pin.m_pos))))
			{
				item.m_checked = true;
			}
		}

		private void ToggleDone(Minimap map, Player player)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			Location val = CurrentDungeon(((Component)player).transform.position);
			PinData val2 = (((Object)(object)val == (Object)null) ? null : DungeonPin(map, val));
			if (val2 == null)
			{
				((Character)player).Message((MessageType)1, Lang.T("AutoPins.StandInOrAtA", "Stand in or at a pinned dungeon to mark it done"), 0, (Sprite)null, false);
				return;
			}
			SetDone(player, val2, !val2.m_checked);
			((Character)player).Message((MessageType)1, val2.m_checked ? Lang.F("AutoPins.MarkedDone", "{0} marked done", val2.m_name) : Lang.F("AutoPins.MarkedNotDone", "{0} marked not done", val2.m_name), 0, (Sprite)null, false);
		}

		private void Dungeons(Minimap map, Player player, float now)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			Vector3 position = ((Component)player).transform.position;
			if (_dungeonDone.Value == DungeonDone.Key_Pressed || position.y < 3000f)
			{
				_insideSince = -1f;
				return;
			}
			if (_insideSince < 0f)
			{
				_insideSince = now;
			}
			Location dungeon = CurrentDungeon(position);
			PinData val = (((Object)(object)dungeon == (Object)null) ? null : DungeonPin(map, dungeon));
			float radius;
			if (val != null && !val.m_checked && !(now - _insideSince < 10f))
			{
				radius = Mathf.Max(dungeon.m_interiorRadius, 64f);
				bool flag = (from c in SceneObjects.Live<Container>(SceneObjects.Containers)
					where (Object)(object)c != (Object)null && Inside(((Component)c).transform.position) && c.GetInventory() != null
					select c).All((Container c) => c.GetInventory().NrOfItems() == 0);
				bool flag2 = !Character.GetAllCharacters().Any((Character c) => (Object)(object)c != (Object)null && !c.IsDead() && !c.IsPlayer() && !c.IsTamed() && Inside(((Component)c).transform.position) && BaseAI.IsEnemy((Character)(object)player, c));
				if (_dungeonDone.Value switch
				{
					DungeonDone.All_Chests_Opened => flag, 
					DungeonDone.Enemies_Cleared => flag2, 
					_ => flag && flag2, 
				})
				{
					SetDone(player, val, done: true);
					((Character)player).Message((MessageType)1, Lang.F("AutoPins.MarkedDone", "{0} marked done", val.m_name), 0, (Sprite)null, false);
				}
			}
			bool Inside(Vector3 p)
			{
				//IL_0000: 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_0019: Unknown result type (might be due to invalid IL or missing references)
				if (p.y > 3000f)
				{
					return Flat(p, ((Component)dungeon).transform.position) <= radius;
				}
				return false;
			}
		}

		private static float Flat(Vector3 a, Vector3 b)
		{
			//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)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			Vector2 val = new Vector2(a.x - b.x, a.z - b.z);
			return ((Vector2)(ref val)).magnitude;
		}

		private static string Label(Location location, string prefab)
		{
			string text = (string.IsNullOrEmpty(location.m_discoverLabel) ? "" : Localization.instance.Localize(location.m_discoverLabel));
			if (text.Length <= 0 || text.StartsWith("["))
			{
				return Readable(prefab);
			}
			return text;
		}

		internal static bool SameName(string pinName, string name)
		{
			if (!(pinName == name))
			{
				return KnownNames.Any(((string Prefix, string Name, string English) pair) => pair.Name == name && pair.English == pinName);
			}
			return true;
		}

		internal static string Readable(string prefab)
		{
			(string, string, string) tuple = KnownNames.FirstOrDefault(((string Prefix, string Name, string English) pair) => prefab.StartsWith(pair.Prefix, StringComparison.OrdinalIgnoreCase));
			if (tuple.Item2 != null)
			{
				return tuple.Item2;
			}
			string text = Regex.Replace(prefab.TrimEnd('0', '1', '2', '3', '4', '5', '6', '7', '8', '9').Replace('_', ' '), "(?<=[a-z])(?=[A-Z])", " ");
			return string.Join(" ", from word in text.Split(new char[1] { ' ' }, StringSplitOptions.RemoveEmptyEntries)
				select char.ToUpperInvariant(word[0]) + word.Substring(1));
		}

		private void Audit()
		{
			ZoneSystem instance = ZoneSystem.instance;
			if ((Object)(object)instance == (Object)null || (Object)(object)instance == (Object)(object)_audited || instance.m_locations == null || instance.m_locations.Count == 0)
			{
				return;
			}
			_audited = instance;
			List<string> known = (from l in instance.m_locations
				where l != null && !string.IsNullOrEmpty(l.m_prefabName)
				select l.m_prefabName).Distinct().ToList();
			Category[] categories = _categories;
			foreach (Category category in categories)
			{
				List<string> list = (from name in Split(category.Names.Value)
					where !known.Any((string k) => k.StartsWith(name, StringComparison.OrdinalIgnoreCase))
					select name).ToList();
				if (list.Count > 0)
				{
					_log.LogInfo((object)("Auto pins: " + category.Kind + " Locations names no location of this world: " + string.Join(", ", list) + "."));
				}
			}
			List<string> list2 = known.Where((string k) => !_categories.Any((Category c) => Starts(k, c.Names.Value))).OrderBy<string, string>((string k) => k, StringComparer.OrdinalIgnoreCase).ToList();
			_log.LogInfo((object)string.Format("Auto pins: locations no category pins ({0}): {1}.", list2.Count, string.Join(", ", list2)));
			List<string> list3 = (from name in Split(_resourceItems.Value)
				where (Object)(object)ObjectDB.instance != (Object)null && (Object)(object)ObjectDB.instance.GetItemPrefab(name) == (Object)null
				select name).ToList();
			if (list3.Count > 0)
			{
				_log.LogInfo((object)("Auto pins: Resource Items names no item: " + string.Join(", ", list3) + "."));
			}
		}

		private static string Prefab(GameObject go)
		{
			string name = ((Object)go).name;
			int num = name.IndexOf("(Clone)", StringComparison.Ordinal);
			return ((num >= 0) ? name.Substring(0, num) : name).Trim();
		}

		private static bool Starts(string prefab, string names)
		{
			return Split(names).Any((string n) => prefab.StartsWith(n, StringComparison.OrdinalIgnoreCase));
		}

		private static IEnumerable<string> Split(string text)
		{
			return from s in text.Split(new char[1] { ';' })
				select s.Trim() into s
				where s.Length > 0
				select s;
		}
	}
	internal enum ShieldChoice
	{
		LastUsed,
		BestBlock,
		BestParry,
		LeastSlowdown
	}
	internal static class AutoShield
	{
		[HarmonyPatch(typeof(Humanoid), "EquipItem")]
		internal static class EquipPatch
		{
			private static void Postfix(Humanoid __instance, ItemData item, bool triggerEquipEffects, bool __result)
			{
				//IL_001a: 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)
				//IL_0020: Unknown result type (might be due to invalid IL or missing references)
				//IL_0022: Invalid comparison between Unknown and I4
				//IL_0066: Unknown result type (might be due to invalid IL or missing references)
				//IL_0068: Invalid comparison between Unknown and I4
				if (!__result || (Object)(object)__instance != (Object)(object)Player.m_localPlayer || item == null)
				{
					return;
				}
				ItemType itemType = item.m_shared.m_itemType;
				if ((int)itemType == 5)
				{
					_last = item;
					_lastIdentity = Identity(item);
					if (item == _ours)
					{
						_ours = null;
					}
					else if (ServerRules.On(_enabled, "AutoShield"))
					{
						Remember(Player.m_localPlayer, Identity(item));
					}
				}
				else if ((int)itemType == 3 && triggerEquipEffects && item != _hiddenRight && ServerRules.On(_enabled, "AutoShield"))
				{
					_pending = item;
				}
			}
		}

		[HarmonyPatch(typeof(Player), "ToggleEquipped")]
		internal static class TogglePatch
		{
			private static void Prefix(Player __instance, ItemData item)
			{
				//IL_0016: Unknown result type (might be due to invalid IL or missing references)
				//IL_001c: Invalid comparison between Unknown and I4
				if (!((Object)(object)__instance != (Object)(object)Player.m_localPlayer) && item != null && (int)item.m_shared.m_itemType == 5 && ((Humanoid)__instance).IsItemEquiped(item) && !((Character)__instance).InAttack())
				{
					_removedAt = Time.time;
					_pending = null;
					Log(item.m_shared.m_name + " taken off by hand");
					if (ServerRules.On(_enabled, "AutoShield"))
					{
						Remember(__instance, "none");
					}
				}
			}
		}

		private static ConfigEntry<bool> _enabled;

		private static ConfigEntry<ShieldChoice> _choice;

		private static ConfigEntry<float> _pause;

		private static ConfigEntry<bool> _pairs;

		private static ConfigEntry<bool> _learn;

		private static ConfigEntry<KeyboardShortcut> _pairKey;

		private static ConfigEntry<bool> _swords;

		private static ConfigEntry<bool> _maces;

		private static ConfigEntry<bool> _axes;

		private static ConfigEntry<bool> _knives;

		private static ConfigEntry<bool> _spears;

		private static ConfigEntry<bool> _others;

		private const string PairKey = "alkeari_shield_pair";

		private const string NoShield = "none";

		private static Player _owner;

		private static ItemData _last;

		private static string _lastIdentity;

		private static ItemData _pending;

		private static ItemData _queued;

		private static ItemData _ours;

		private static ItemData _hiddenRight;

		private static float _removedAt = float.NegativeInfinity;

		public static void Bind(ConfigFile cfg)
		{
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Expected O, but got Unknown
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			_enabled = cfg.Bind<bool>("Inventory", "Auto Shield", true, "When you equip a one-handed weapon with nothing in your left hand, a shield from your inventory is equipped with it.");
			_choice = cfg.Bind<ShieldChoice>("Inventory", "Auto Shield Choice", ShieldChoice.LastUsed, "Which shield Auto Shield equips: Last Used (the one you last had equipped this session, else the best blocker), Best Block (highest block power at its quality), Best Parry (block power times parry bonus) or Least Slowdown (smallest movement penalty).");
			_pause = cfg.Bind<float>("Inventory", "Auto Shield Pause Seconds", 10f, new ConfigDescription("After you take a shield off yourself, Auto Shield leaves your left hand empty for this many seconds.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 120f), Array.Empty<object>()));
			_pairs = cfg.Bind<bool>("Inventory", "Shield Pairs", true, "Each one-handed weapon can be paired with a shield, or with no shield: taking that weapon up brings its shield, swaps to it, or puts the shield away. A weapon without a pair follows the Shield With switches and Auto Shield Choice.");
			_learn = cfg.Bind<bool>("Inventory", "Learn Shield Pairs", true, "Putting a shield on or taking it off by hand while holding a one-handed weapon pairs that weapon with that shield, or with no shield. Off = pairs change only with Shield Pair Key.");
			_pairKey = cfg.Bind<KeyboardShortcut>("Inventory", "Shield Pair Key", new KeyboardShortcut((KeyCode)278, Array.Empty<KeyCode>()), "Pairs the one-handed weapon in your hand with the shield you wear, or with no shield when you wear none; pressed again on the same pair, it clears it.");
			_swords = cfg.Bind<bool>("Inventory", "Shield With Swords", true, "Unpaired swords get a shield from Auto Shield. Off = a sword puts the shield away.");
			_maces = cfg.Bind<bool>("Inventory", "Shield With Maces", true, "Unpaired maces and clubs get a shield from Auto Shield. Off = they put the shield away.");
			_axes = cfg.Bind<bool>("Inventory", "Shield With Axes", false, "Unpaired one-handed axes get a shield from Auto Shield. Off by default since axes are also the woodcutting tool; off = an axe puts the shield away.");
			_knives = cfg.Bind<bool>("Inventory", "Shield With Knives", true, "Unpaired knives get a shield from Auto Shield. Off = a knife puts the shield away.");
			_spears = cfg.Bind<bool>("Inventory", "Shield With Spears", true, "Unpaired spears get a shield from Auto Shield. Off = a spear puts the shield away.");
			_others = cfg.Bind<bool>("Inventory", "Shield With Other Weapons", true, "Unpaired one-handed weapons of any other kind (magic and modded weapons) get a shield from Auto Shield. Off = they put the shield away.");
		}

		public static void Tick()
		{
			//IL_0115: Unknown result type (might be due to invalid IL or missing references)
			//IL_011b: Invalid comparison between Unknown and I4
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer != (Object)(object)_owner)
			{
				_owner = localPlayer;
				_last = null;
				_lastIdentity = null;
				_pending = null;
				_queued = null;
				_removedAt = float.NegativeInfinity;
			}
			if ((Object)(object)localPlayer == (Object)null)
			{
				return;
			}
			_hiddenRight = ((Humanoid)localPlayer).m_hiddenRightItem;
			if (_queued != null && localPlayer.IsEquipActionQueued(_queued) && !HandsWant(localPlayer))
			{
				((Humanoid)localPlayer).RemoveEquipAction(_queued);
				Log("cancelled the queued " + _queued.m_shared.m_name + ": the hands changed");
				_queued = null;
			}
			HandlePairKey(localPlayer);
			if (_pending == null)
			{
				return;
			}
			string text = Pair(_pending) ?? (KindWantsShield(_pending) ? null : "none");
			if (!ServerRules.On(_enabled, "AutoShield") || ((Humanoid)localPlayer).GetRightItem() != _pending || ((Humanoid)localPlayer).m_hiddenLeftItem != null || ShieldQueued(localPlayer) || (((Humanoid)localPlayer).GetLeftItem() != null && (text == null || (int)((Humanoid)localPlayer).GetLeftItem().m_shared.m_itemType != 5)))
			{
				_pending = null;
			}
			else if (text != null)
			{
				if (!((Character)localPlayer).IsDead() && !((Character)localPlayer).InAttack() && !((Character)localPlayer).InDodge() && !((Character)localPlayer).IsSwimming() && !((Character)localPlayer).InCutscene() && !((Character)localPlayer).IsTeleporting() && !localPlayer.IsSleeping() && !((Character)localPlayer).IsAttached())
				{
					_pending = null;
					Paired(localPlayer, text);
				}
			}
			else if (!HandsWant(localPlayer))
			{
				_pending = null;
			}
			else if (Time.time - _removedAt < _pause.Value)
			{
				Log("skipped: a shield was taken off by hand moments ago");
				_pending = null;
			}
			else if (!((Character)localPlayer).IsDead() && !((Character)localPlayer).InAttack() && !((Character)localPlayer).InDodge() && !((Character)localPlayer).IsSwimming() && !((Character)localPlayer).InCutscene() && !((Character)localPlayer).IsTeleporting() && !localPlayer.IsSleeping() && !((Character)localPlayer).IsAttached())
			{
				_pending = null;
				ItemData val = Pick(localPlayer);
				if (val != null)
				{
					_ours = val;
					((Humanoid)localPlayer).ToggleEquipped(val);
					_queued = (localPlayer.IsEquipActionQueued(val) ? val : null);
					Log(string.Format("{0} q{1} {2} with {3} ({4})", val.m_shared.m_name, val.m_quality, (_queued == null) ? "equipped" : "queued", ((Humanoid)localPlayer).GetRightItem().m_shared.m_name, _choice.Value));
				}
			}
		}

		private static string Pair(ItemData weapon)
		{
			if (!_pairs.Value || !weapon.m_customData.TryGetValue("alkeari_shield_pair", out var value) || value.Length <= 0)
			{
				return null;
			}
			return value;
		}

		private static bool KindWantsShield(ItemData weapon)
		{
			//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_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Expected I4, but got Unknown
			SkillType skillType = weapon.m_shared.m_skillType;
			return (skillType - 1) switch
			{
				0 => _swords.Value, 
				2 => _maces.Value, 
				6 => _axes.Value, 
				1 => _knives.Value, 
				4 => _spears.Value, 
				_ => _others.Value, 
			};
		}

		private static void HandlePairKey(Player player)
		{
			//IL_0018: 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_004c: Invalid comparison between Unknown and I4
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Invalid comparison between Unknown and I4
			if (!_pairs.Value || InventoryFeatures.Typing() || !KeyInput.Down(_pairKey.Value) || !ServerRules.On(_enabled, "AutoShield"))
			{
				return;
			}
			ItemData rightItem = ((Humanoid)player).GetRightItem();
			if (rightItem == null || (int)rightItem.m_shared.m_itemType != 3)
			{
				((Character)player).Message((MessageType)2, Lang.T("AutoShield.HoldAOneHandedWeapon", "Hold a one-handed weapon to pair it with a shield"), 0, (Sprite)null, false);
				return;
			}
			ItemData leftItem = ((Humanoid)player).GetLeftItem();
			string text = ((leftItem != null && (int)leftItem.m_shared.m_itemType == 5) ? Identity(leftItem) : "none");
			string text2 = Localization.instance.Localize(rightItem.m_shared.m_name);
			if (rightItem.m_customData.TryGetValue("alkeari_shield_pair", out var value) && value == text)
			{
				rightItem.m_customData.Remove("alkeari_shield_pair");
				((Character)player).Message((MessageType)1, Lang.F("AutoShield.UnpairedItFollowsTheShield", "{0} unpaired: it follows the Shield With settings", text2), 0, (Sprite)null, false);
				Log(rightItem.m_shared.m_name + " unpaired by key");
			}
			else
			{
				rightItem.m_customData["alkeari_shield_pair"] = text;
				((Character)player).Message((MessageType)1, (text == "none") ? Lang.F("AutoShield.PairedWithNoShield", "{0} paired with no shield", text2) : Lang.F("AutoShield.PairedWith", "{0} paired with {1}", text2, Localization.instance.Localize(leftItem.m_shared.m_name)), 0, (Sprite)null, false);
				Log(rightItem.m_shared.m_name + " paired with " + ((text == "none") ? "no shield" : text) + " by key");
			}
		}

		private static void Paired(Player player, string pair)
		{
			ItemData leftItem = ((Humanoid)player).GetLeftItem();
			string name = ((Humanoid)player).GetRightItem().m_shared.m_name;
			if (pair == "none")
			{
				if (leftItem != null)
				{
					((Humanoid)player).UnequipItem(leftItem, true);
					Log(leftItem.m_shared.m_name + " put away: " + name + " is paired with no shield");
				}
			}
			else
			{
				if (leftItem != null && Identity(leftItem) == pair)
				{
					return;
				}
				ItemData val = (from item in ((Humanoid)player).GetInventory().GetAllItems()
					where Usable(item) && Identity(item) == pair
					orderby item.m_durability descending
					select item).FirstOrDefault();
				if (val == null)
				{
					val = ((leftItem == null) ? Pick(player) : null);
					if (val == null)
					{
						return;
					}
				}
				_ours = val;
				((Humanoid)player).ToggleEquipped(val);
				_queued = (player.IsEquipActionQueued(val) ? val : null);
				Log(string.Format("{0} q{1} {2} with {3} (pair {4})", val.m_shared.m_name, val.m_quality, (_queued == null) ? "equipped" : "queued", name, pair));
			}
		}

		private static void Remember(Player player, string pair)
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			ItemData rightItem = ((Humanoid)player).GetRightItem();
			if (_pairs.Value && _learn.Value && rightItem != null && (int)rightItem.m_shared.m_itemType == 3 && (!rightItem.m_customData.TryGetValue("alkeari_shield_pair", out var value) || value != pair))
			{
				rightItem.m_customData["alkeari_shield_pair"] = pair;
				Log(rightItem.m_shared.m_name + " paired with " + ((pair == "none") ? "no shield" : pair));
			}
		}

		private static bool HandsWant(Player player)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Invalid comparison between Unknown and I4
			ItemData rightItem = ((Humanoid)player).GetRightItem();
			if (rightItem != null && (int)rightItem.m_shared.m_itemType == 3 && ((Humanoid)player).GetLeftItem() == null)
			{
				return ((Humanoid)player).m_hiddenLeftItem == null;
			}
			return false;
		}

		private static bool ShieldQueued(Player player)
		{
			return player.m_actionQueue.Any((MinorActionData action) => (int)action.m_type == 0 && action.m_item != null && (int)action.m_item.m_shared.m_itemType == 5);
		}

		private static ItemData Pick(Player player)
		{
			List<ItemData> list = ((Humanoid)player).GetInventory().GetAllItems().Where(Usable)
				.ToList();
			if (list.Count == 0)
			{
				return null;
			}
			switch (_choice.Value)
			{
			case ShieldChoice.LastUsed:
				if (_last != null && list.Contains(_last))
				{
					return _last;
				}
				return (from item in list
					where Identity(item) == _lastIdentity
					orderby item.m_durability descending
					select item).FirstOrDefault() ?? list.OrderByDescending(Block).ThenByDescending((ItemData item) => item.m_durability).First();
			case ShieldChoice.BestParry:
				return list.OrderByDescending((ItemData item) => Block(item) * item.m_shared.m_timedBlockBonus).ThenByDescending(Block).First();
			case ShieldChoice.LeastSlowdown:
				return list.OrderByDescending((ItemData item) => item.m_shared.m_movementModifier).ThenByDescending(Block).First();
			default:
				return list.OrderByDescending(Block).ThenByDescending((ItemData item) => item.m_durability).First();
			}
		}

		private static bool Usable(ItemData item)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Invalid comparison between Unknown and I4
			if ((int)item.m_shared.m_itemType == 5 && item.IsEquipable() && (!item.m_shared.m_useDurability || !(item.m_durability <= 0f)))
			{
				if (item.m_shared.m_dlc.Length != 0)
				{
					if ((Object)(object)DLCMan.instance != (Object)null)
					{
						return DLCMan.instance.IsDLCInstalled(item.m_shared.m_dlc);
					}
					return false;
				}
				return true;
			}
			return false;
		}

		private static float Block(ItemData item)
		{
			return item.GetBaseBlockPower(item.m_quality);
		}

		private static string Identity(ItemData item)
		{
			return $"{item.m_shared.m_name}|{item.m_quality}|{item.m_variant}";
		}

		private static void Log(string message)
		{
			if (DebugLog.On)
			{
				DebugLog.Write("auto shield", message);
			}
		}
	}
	internal static class BadgersShadingCompat
	{
		internal const string BadgersShadingGuid = "Badgers.ShadingOverhaul";

		private static ConfigEntry<bool> _enabled;

		public static void Resolve(ConfigFile cfg, Harmony harmony, ManualLogSource log)
		{
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Expected O, but got Unknown
			if (Chainloader.PluginInfos.TryGetValue("Badgers.ShadingOverhaul", out var value) && !((Object)(object)value.Instance == (Object)null))
			{
				MethodInfo methodInfo = AccessTools.Method(((object)value.Instance).GetType(), "Update", (Type[])null, (Type[])null);
				if (methodInfo == null)
				{
					log.LogWarning((object)"Badgers Shading Overhaul has an unknown shape; Chest Keys Skip Badgers Shading Menu is off.");
					return;
				}
				_enabled = cfg.Bind<bool>("Compatibility", "Chest Keys Skip Badgers Shading Menu", true, "With Badgers Shading Overhaul, Next Chest Key and Previous Chest Key with a chest open do not also open its shading menu when it uses the same key.");
				harmony.Patch((MethodBase)methodInfo, new HarmonyMethod(AccessTools.Method(typeof(BadgersShadingCompat), "BeforeUpdate", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			}
		}

		private static bool BeforeUpdate()
		{
			if (_enabled.Value)
			{
				return !CycleChests.ChestKeyDown;
			}
			return true;
		}
	}
	internal sealed class BedAndHotbar
	{
		private readonly ConfigEntry<bool> _bedPins;

		private readonly ConfigEntry<PinType> _bedIcon;

		private readonly ConfigEntry<bool> _swap;

		private readonly ConfigEntry<KeyboardShortcut> _swapKey;

		private readonly ConfigEntry<int> _swapRow;

		private Vector3? _bed;

		private float _next;

		public BedAndHotbar(ConfigFile cfg)
		{
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Expected O, but got Unknown
			_bedPins = cfg.Bind<bool>("Map", "Keep Old Bed Pins", true, "When you set your spawn point at a new bed, a saved pin named Old Bed stays where the previous bed was.");
			_bedIcon = cfg.Bind<PinType>("Map", "Old Bed Pin Icon", (PinType)1, "The map icon of the pin Keep Old Bed Pins leaves at an old bed.");
			_swap = cfg.Bind<bool>("Inventory", "Hotbar Swap", true, "Hotbar Swap Key trades the items of the hotbar with those of Hotbar Swap Row, keeping what you wear equipped.");
			_swapKey = cfg.Bind<KeyboardShortcut>("Inventory", "Hotbar Swap Key", new KeyboardShortcut((KeyCode)106, Array.Empty<KeyCode>()), "Trades the hotbar with Hotbar Swap Row, while Hotbar Swap is on.");
			_swapRow = cfg.Bind<int>("Inventory", "Hotbar Swap Row", 2, new ConfigDescription("The inventory row, counted from the hotbar as row 1, that Hotbar Swap Key trades with the hotbar.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(2, 8), Array.Empty<object>()));
		}

		public void Tick(float now)
		{
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0157: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: 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_011c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_013c: 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)
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null)
			{
				_bed = null;
				return;
			}
			Swap(localPlayer);
			if (now < _next)
			{
				return;
			}
			_next = now + 2f;
			PlayerProfile val = (((Object)(object)Game.instance == (Object)null) ? null : Game.instance.GetPlayerProfile());
			if (val == null || !val.HaveCustomSpawnPoint())
			{
				return;
			}
			Vector3 customSpawnPoint = val.GetCustomSpawnPoint();
			Vector3? bed = _bed;
			if (bed.HasValue)
			{
				Vector3 old = bed.GetValueOrDefault();
				if (Vector3.Distance(old, customSpawnPoint) > 5f && _bedPins.Value && ServerRules.Allows("OldBedPins") && (Object)(object)Minimap.instance != (Object)null && Minimap.instance.m_pins.TrueForAll((PinData pin) => (pin.m_name != "Old Bed" && pin.m_name != Lang.T("BedAndHotbar.OldBed", "Old Bed")) || Vector3.Distance(pin.m_pos, old) > 5f))
				{
					Minimap.instance.AddPin(old, _bedIcon.Value, Lang.T("BedAndHotbar.OldBed", "Old Bed"), true, false, 0L, default(PlatformUserID));
					if (DebugLog.On)
					{
						DebugLog.Write("pins", $"old bed pin at {old}, new bed at {customSpawnPoint}");
					}
				}
			}
			_bed = customSpawnPoint;
		}

		private void Swap(Player player)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: 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)
			if (!_swap.Value || InventoryFeatures.Typing() || !KeyInput.Down(_swapKey.Value) || !ServerRules.Allows("HotbarSwap"))
			{
				return;
			}
			Inventory inventory = ((Humanoid)player).GetInventory();
			int num = _swapRow.Value - 1;
			if (num >= (SeneaLCalls.CanSort ? SeneaLCalls.MainRows(inventory) : inventory.GetHeight()))
			{
				((Character)player).Message((MessageType)2, Lang.F("BedAndHotbar.YourInventoryHasNoRow", "Your inventory has no row {0}", _swapRow.Value), 0, (Sprite)null, false);
				return;
			}
			for (int i = 0; i < inventory.GetWidth(); i++)
			{
				ItemData itemAt = inventory.GetItemAt(i, 0);
				ItemData itemAt2 = inventory.GetItemAt(i, num);
				if (itemAt != null)
				{
					itemAt.m_gridPos = new Vector2i(i, num);
				}
				if (itemAt2 != null)
				{
					itemAt2.m_gridPos = new Vector2i(i, 0);
				}
			}
			inventory.Changed(false, false);
			if (DebugLog.On)
			{
				DebugLog.Write("hotbar", $"swapped the hotbar with row {_swapRow.Value}");
			}
		}
	}
	internal sealed class BeyondMaximums
	{
		private sealed record Lift(float Max, ConfigEntry<float> Cap, Func<float> Reach);

		private const string Section = "Cheats: Beyond Maximums";

		private const string PatchId = "alkeari.valheim.senealuiunlocker.beyond";

		private const string GuardId = "alkeari.valheim.senealuiunlocker.beyond.guard";

		private const string PolicyType = "SeneaLUI.Net.Policy";

		private const string PovType = "SeneaLUI.Mods.Pov";

		private const string BlipsType = "SeneaLUI.Radar.Blips";

		private const string PolicyRpcName = "SeneaLUI_Policy";

		private static readonly int PolicyRpc = StringExtensionMethods.GetStableHashCode("SeneaLUI_Policy");

		private static BeyondMaximums _current;

		private readonly ManualLogSource _log;

		private readonly PolicyUnlock _unlock;

		private readonly ConfigEntry<bool> _on;

		private readonly Harmony _patches = new Harmony("alkeari.valheim.senealuiunlocker.beyond");

		private readonly Harmony _guard = new Harmony("alkeari.valheim.senealuiunlocker.beyond.guard");

		private readonly Lift[] _lifts;

		private readonly (MethodInfo Getter, string Postfix)[] _targets;

		private bool _eligible;

		private bool _applied;

		private bool _guardApplied;

		private bool _broken;

		private bool Live
		{
			get
			{
				if (_applied)
				{
					if (!_unlock.IsUnlocked)
					{
						return _unlock.OwnWorld;
					}
					return true;
				}
				return false;
			}
		}

		private BeyondMaximums(ManualLogSource log, PolicyUnlock unlock, ConfigEntry<bool> on, Lift[] lifts, (MethodInfo, string)[] targets)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Expected O, but got Unknown
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Expected O, but got Unknown
			_log = log;
			_unlock = unlock;
			_on = on;
			_lifts = lifts;
			_targets = targets;
		}

		public static BeyondMaximums Resolve(ConfigFile cfg, ManualLogSource log, PolicyUnlock unlock)
		{
			ConfigEntry<bool> val = cfg.Bind<bool>("Cheats: Beyond Maximums", "Go Beyond SeneaL UI Maximums (Cheat)", false, "Cheat, off by default: in your own world and on servers without SeneaL UI, raise the ranges below past SeneaL UI's own maximums. It patches SeneaL UI's code there; the patches are removed before a SeneaL UI server could see them.");
			ConfigEntry<float> cap = Cap(cfg, "Max Chest Range Beyond", 200f, 100f, 500f, "Chest range, meters, for crafting, building, quick stack and restock wherever SeneaL UI's own range is at its 100 m maximum. Chests farther away than the game has loaded are not found.");
			ConfigEntry<float> cap2 = Cap(cfg, "Max Area Pickup Beyond", 20f, 10f, 50f, "Area pickup radius, meters, used when SeneaL UI's own radius is at its 10 m maximum.");
			ConfigEntry<float> cap3 = Cap(cfg, "Max Ore Radius Beyond", 120f, 60f, 300f, "Ore detection radius, meters, used when SeneaL UI's own radius is at its 60 m maximum.");
			ConfigEntry<float> cap4 = Cap(cfg, "Max Radar Range Beyond", 300f, 200f, 500f, "SeneaL Radar range, meters, used when the radar's own range is at its 200 m maximum.");
			Type type = TypeLookup.Find("SeneaLUI.Net.Policy");
			if (unlock == null || type == null)
			{
				return null;
			}
			Type pov = TypeLookup.Find("SeneaLUI.Mods.Pov");
			Func<float> reach = Reach(pov, "ChestReach");
			Func<float> reach2 = Reach(pov, "PickupReach");
			float max = Constant(type, "MaxRange");
			float max2 = Constant(type, "MaxArea");
			float max3 = Constant(type, "MaxOre");
			float max4 = Constant(type, "MaxRadar");
			Lift[] lifts = new Lift[6]
			{
				new Lift(max, cap, reach),
				new Lift(max, cap, reach),
				new Lift(max, cap, null),
				new Lift(max2, cap2, reach2),
				new Lift(max3, cap3, null),
				new Lift(max4, cap4, null)
			};
			Type type2 = Quiet.Type("SeneaLUI.Radar.Blips");
			(MethodInfo, string)[] array = new(MethodInfo, string)[6]
			{
				(Getter(type, "ChestRange", max), "ChestRange"),
				(Getter(type, "BuildRange", max), "BuildRange"),
				(Getter(type, "StackRange", max), "StackRange"),
				(Getter(type, "AreaRange", max2), "AreaRange"),
				(Getter(type, "OreRadius", max3), "OreRadius"),
				((type2 == null) ? null : Getter(type2, "Range", max4), "RadarRange")
			};
			if (Array.TrueForAll(array, ((MethodInfo, string) t) => t.Item1 == null))
			{
				log.LogWarning((object)"This SeneaL UI build has none of the ranges Go Beyond SeneaL UI Maximums (Cheat) raises, so it does nothing.");
				return null;
			}
			BeyondMaximums beyond = new BeyondMaximums(log, unlock, val, lifts, array);
			_current = beyond;
			unlock.Granted += delegate
			{
				beyond.Granted();
			};
			return beyond;
		}

		private static ConfigEntry<float> Cap(ConfigFile cfg, string key, float value, float min, float max, string desc)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Expected O, but got Unknown
			return cfg.Bind<float>("Cheats: Beyond Maximums", key, value, new ConfigDescription(desc, (AcceptableValueBase)(object)new AcceptableValueRange<float>(min, max), Array.Empty<object>()));
		}

		private static Func<float> Reach(Type pov, string name)
		{
			MethodInfo methodInfo = ((pov == null) ? null : AccessTools.PropertyGetter(pov, name));
			if (!(methodInfo == null))
			{
				return AccessTools.MethodDelegate<Func<float>>(methodInfo, (object)null, true);
			}
			return null;
		}

		private static float Constant(Type type, string name)
		{
			object obj = AccessTools.Field(type, name)?.GetValue(null);
			if (obj is float)
			{
				return (float)obj;
			}
			return float.NaN;
		}

		private static MethodInfo Getter(Type type, string name, float max)
		{
			if (!float.IsNaN(max))
			{
				return AccessTools.PropertyGetter(type, name);
			}
			return null;
		}

		private void Granted()
		{
			_eligible = true;
			Tick();
		}

		public void Tick()
		{
			if (_guardApplied && !_applied)
			{
				_guard.UnpatchSelf();
				_guardApplied = false;
			}
			if (_unlock.OwnWorld)
			{
				_eligible = true;
			}
			else if (!_unlock.IsUnlocked)
			{
				_eligible = false;
			}
			bool flag = _on.Value && ServerRules.Allows("BeyondMaximums") && _eligible && !_broken && ServerDirectory.Option("beyond", fallback: true);
			if (flag && !_applied)
			{
				Apply();
			}
			else if (!flag && _applied)
			{
				Remove("the unlock or the setting ended");
			}
		}

		public void Shutdown()
		{
			_patches.UnpatchSelf();
			_guard.UnpatchSelf();
			_applied = false;
			_guardApplied = false;
		}

		private void Apply()
		{
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f1: Expected O, but got Unknown
			try
			{
				if (!_guardApplied)
				{
					_guard.Patch((MethodBase)AccessTools.Method(typeof(ZRpc), "HandlePackage", (Type[])null, (Type[])null), Guard("BeforePackage"), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
					_guard.Patch((MethodBase)AccessTools.Method(typeof(ZNet), "StopAll", (Type[])null, (Type[])null), Guard("BeforeConnectionChange"), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
					_guard.Patch((MethodBase)AccessTools.Method(typeof(ZNet), "OnNewConnection", (Type[])null, (Type[])null), Guard("BeforeConnectionChange"), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
					_guardApplied = true;
				}
				(MethodInfo, string)[] targets = _targets;
				for (int i = 0; i < targets.Length; i++)
				{
					var (methodInfo, text) = targets[i];
					if (methodInfo != null)
					{
						_patches.Patch((MethodBase)methodInfo, (HarmonyMethod)null, new HarmonyMethod(AccessTools.Method(typeof(BeyondMaximums), text, (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
					}
				}
				_applied = true;
				_log.LogInfo((object)"SeneaL UI's range maximums are raised on this server.");
			}
			catch (Exception ex)
			{
				_broken = true;
				_patches.UnpatchSelf();
				_applied = false;
				_log.LogWarning((object)("Could not raise SeneaL UI's maximums (" + ex.GetBaseException().Message + "); Go Beyond SeneaL UI Maximums (Cheat) stays off until the game restarts."));
			}
		}

		private static HarmonyMethod Guard(string name)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Expected O, but got Unknown
			return new HarmonyMethod(AccessTools.Method(typeof(BeyondMaximums), name, (Type[])null, (Type[])null))
			{
				priority = 800
			};
		}

		private void Remove(string why)
		{
			_patches.UnpatchSelf();
			_applied = false;
			_log.LogInfo((object)("SeneaL UI's range maximums are back (" + why + ")."));
		}

		private static void BeforePackage(ZPackage package)
		{
			BeyondMaximums current = _current;
			if (current == null || !current._applied)
			{
				return;
			}
			int pos = package.GetPos();
			if (package.Size() - pos >= 4)
			{
				int num = package.ReadInt();
				package.SetPos(pos);
				if (num == PolicyRpc)
				{
					current._eligible = false;
					current.Remove("the server runs SeneaL UI");
				}
			}
		}

		private static void BeforeConnectionChange()
		{
			BeyondMaximums current = _current;
			if (current != null)
			{
				current._eligible = false;
				if (current._applied)
				{
					current.Remove("the connection changed");
				}
			}
		}

		private static void ChestRange(ref float __result)
		{
			__result = _current.Raise(0, __result);
		}

		private static void BuildRange(ref float __result)
		{
			__result = _current.Raise(1, __result);
		}

		private static void StackRange(ref float __result)
		{
			__result = _current.Raise(2, __result);
		}

		private static void AreaRange(ref float __result)
		{
			__result = _current.Raise(3, __result);
		}

		private static void OreRadius(ref float __result)
		{
			__result = _current.Raise(4, __result);
		}

		private static void RadarRange(ref float __result)
		{
			__result = _current.Raise(5, __result);
		}

		private float Raise(int index, float value)
		{
			Lift lift = _lifts[index];
			if (!Live || value < lift.Max - 0.01f)
			{
				return value;
			}
			float value2 = lift.Cap.Value;
			if (lift.Reach != null)
			{
				return Mathf.Min(value2, lift.Reach());
			}
			return value2;
		}
	}
	internal static class BuildCamera
	{
		[HarmonyPatch(typeof(GameCamera), "UpdateCamera")]
		internal static class CameraPatch
		{
			private static bool Prefix(GameCamera __instance, float dt)
			{
				//IL_0067: 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_0076: Unknown result type (might be due to invalid IL or missing references)
				//IL_007c: Unknown result type (might be due to invalid IL or missing references)
				//IL_008d: 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_00ba: Unknown result type (might be due to invalid IL or missing references)
				//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
				//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
				//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f0: 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_0122: 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_0126: 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_012c: 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_0103: Unknown result type (might be due to invalid IL or missing references)
				//IL_0108: Unknown result type (might be due to invalid IL or missing references)
				//IL_010d: Unknown result type (might be due to invalid IL or missing references)
				//IL_013a: Unknown result type (might be due to invalid IL or missing references)
				//IL_013c: 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_0154: Unknown result type (might be due to invalid IL or missing references)
				//IL_0156: Unknown result type (might be due to invalid IL or missing references)
				//IL_015b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0160: Unknown result type (might be due to invalid IL or missing references)
				//IL_0188: Unknown result type (might be due to invalid IL or missing references)
				//IL_018d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0194: Unknown result type (might be due to invalid IL or missing references)
				//IL_019b: Unknown result type (might be due to invalid IL or missing references)
				//IL_01a1: Unknown result type (might be due to invalid IL or missing references)
				//IL_01a6: Unknown result type (might be due to invalid IL or missing references)
				//IL_01ab: Unknown result type (might be due to invalid IL or missing references)
				//IL_01b3: 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_01ba: Unknown result type (might be due to invalid IL or missing references)
				//IL_01bc: Unknown result type (might be due to invalid IL or missing references)
				//IL_01fa: Unknown result type (might be due to invalid IL or missing references)
				//IL_0202: Unknown result type (might be due to invalid IL or missing references)
				//IL_01cf: 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_01d3: 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_01da: Unknown result type (might be due to invalid IL or missing references)
				//IL_01de: Unknown result type (might be due to invalid IL or missing references)
				//IL_01ed: Unknown result type (might be due to invalid IL or missing references)
				//IL_01f2: Unknown result type (might be due to invalid IL or missing references)
				//IL_01f7: Unknown result type (might be due to invalid IL or missing references)
				Player localPlayer = Player.m_localPlayer;
				if (!_active || (Object)(object)localPlayer == (Object)null)
				{
					return true;
				}
				bool num = !Hud.IsPieceSelectionVisible() && !InventoryGui.IsVisible() && !Menu.IsVisible() && !Minimap.IsOpen() && !Console.IsVisible() && ((Object)(object)Chat.instance == (Object)null || !Chat.instance.HasFocus());
				Transform transform = ((Component)__instance).transform;
				if (num)
				{
					Vector2 val = ZInput.GetMouseDelta() * PlayerController.m_mouseSens;
					_yaw += val.x;
					_pitch = Mathf.Clamp(_pitch - val.y, -89f, 89f);
					Vector3 val2 = Vector3.zero;
					if (ZInput.GetButton("Forward"))
					{
						val2 += Vector3.forward;
					}
					if (ZInput.GetButton("Backward"))
					{
						val2 -= Vector3.forward;
					}
					if (ZInput.GetButton("Right"))
					{
						val2 += Vector3.right;
					}
					if (ZInput.GetButton("Left"))
					{
						val2 -= Vector3.right;
					}
					Quaternion val3 = Quaternion.Euler(_pitch, _yaw, 0f);
					Vector3 val4 = val3 * val2;
					if (ZInput.GetButton("Jump"))
					{
						val4 += Vector3.up;
					}
					if (ZInput.GetButton("Crouch"))
					{
						val4 -= Vector3.up;
					}
					float num2 = _speed.Value * (ZInput.GetButton("Run") ? 3f : 1f);
					Vector3 val5 = transform.position + Vector3.ClampMagnitude(val4, 1f) * num2 * dt;
					Vector3 position = ((Character)localPlayer).m_eye.position;
					if (Vector3.Distance(val5, position) > _range.Value)
					{
						Vector3 val6 = val5 - position;
						val5 = position + ((Vector3)(ref val6)).normalized * _range.Value;
					}
					transform.position = val5;
					transform.rotation = val3;
				}
				__instance.m_camera.fieldOfView = __instance.m_fov;
				__instance.m_skyCamera.fieldOfView = __instance.m_fov;
				return false;
			}
		}

		[HarmonyPatch(typeof(Player), "SetControls")]
		internal static class ControlsPatch
		{
			private static void Prefix(Player __instance, ref Vector3 movedir, ref bool jump, ref bool crouch, ref bool run, ref bool autoRun, ref bool dodge)
			{
				//IL_0016: Unknown result type (might be due to invalid IL or missing references)
				//IL_001b: Unknown result type (might be due to invalid IL or missing references)
				if (_active && !((Object)(object)__instance != (Object)(object)Player.m_localPlayer))
				{
					movedir = Vector3.zero;
					jump = false;
					crouch = false;
					run = false;
					autoRun = false;
					dodge = false;
				}
			}
		}

		private const string Section = "Building";

		private static ConfigEntry<bool> _on;

		private static ConfigEntry<KeyboardShortcut> _key;

		private static ConfigEntry<float> _range;

		private static ConfigEntry<float> _speed;

		private static bool _active;

		private static float _yaw;

		private static float _pitch;

		private static float _health;

		private static float _savedReach = -1f;

		internal static bool Active => _active;

		public static void Bind(ConfigFile cfg)
		{
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Expected O, but got Unknown
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Expected O, but got Unknown
			_on = cfg.Bind<bool>("Building", "Build Camera", true, "Build Camera Key lets the camera fly free around your build while a building tool is in hand; placing works from where it looks.");
			_key = cfg.Bind<KeyboardShortcut>("Building", "Build Camera Key", new KeyboardShortcut((KeyCode)111, Array.Empty<KeyCode>()), "Starts and stops the build camera while Build Camera is on and a hammer, hoe or cultivator is in hand.");
			_range = cfg.Bind<float>("Building", "Build Camera Range", 30f, new ConfigDescription("How far from your character, in meters, the build camera may fly, and so how far away you can place pieces with it.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(8f, 60f), Array.Empty<object>()));
			_speed = cfg.Bind<float>("Building", "Build Camera Speed", 8f, new ConfigDescription("How fast the build camera flies, meters per second; hold Run for three times as fast.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(1f, 30f), Array.Empty<object>()));
		}

		public static void Tick()
		{
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			Player localPlayer = Player.m_localPlayer;
			if (_active && ((Object)(object)localPlayer == (Object)null || ((Character)localPlayer).IsDead() || !((Character)localPlayer).InPlaceMode() || ((Character)localPlayer).GetHealth() < _health - 0.01f || !_on.Value || !ServerRules.Allows("BuildCamera")))
			{
				Stop(localPlayer);
			}
			else if (!((Object)(object)localPlayer == (Object)null) && _on.Value && !InventoryFeatures.Typing() && KeyInput.Down(_key.Value) && ServerRules.Allows("BuildCamera"))
			{
				if (_active)
				{
					Stop(localPlayer);
				}
				else if (((Character)localPlayer).InPlaceMode() && (Object)(object)GameCamera.instance != (Object)null)
				{
					Start(localPlayer);
				}
			}
		}

		private static void Start(Player player)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			Quaternion rotation = ((Component)GameCamera.instance).transform.rotation;
			Vector3 eulerAngles = ((Quaternion)(ref rotation)).eulerAngles;
			_yaw = eulerAngles.y;
			_pitch = ((eulerAngles.x > 180f) ? (eulerAngles.x - 360f) : eulerAngles.x);
			_health = ((Character)player).GetHealth();
			_savedReach = player.m_maxPlaceDistance;
			player.m_maxPlaceDistance = Mathf.Max(_savedReach, _range.Value + 10f);
			_active = true;
			((Character)player).Message((MessageType)1, Lang.T("BuildCamera.BuildCameraOn", "Build camera on"), 0, (Sprite)null, false);
			Log("on");
		}

		private static void Stop(Player player)
		{
			_active = false;
			if ((Object)(object)player != (Object)null && _savedReach >= 0f)
			{
				player.m_maxPlaceDistance = _savedReach;
			}
			_savedReach = -1f;
			if ((Object)(object)player != (Object)null)
			{
				((Character)player).Message((MessageType)1, Lang.T("BuildCamera.BuildCameraOff", "Build camera off"), 0, (Sprite)null, false);
			}
			Log("off");
		}

		private static void Log(string what)
		{
			if (DebugLog.On)
			{
				DebugLog.Write("build camera", what);
			}
		}
	}
	internal static class BuildRestrictions
	{
		[HarmonyPatch(typeof(StationExtension), "OtherExtensionInRange")]
		internal static class SpacingPatch
		{
			private static void Postfix(ref bool __result)
			{
				if ((Object)(object)_placing != (Object)null && Mode() != "Vanilla")
				{
					__result = false;
				}
			}
		}

		[HarmonyPatch(typeof(Player), "UpdatePlacementGhost")]
		internal static class GhostPatch
		{
			private static void Prefix(Player __instance)
			{
				_placing = (((Object)(object)__instance == (Object)(object)Player.m_localPlayer) ? __instance : null);
			}

			private static void Postfix(Player __instance)
			{
				//IL_003e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0043: Unknown result type (might be due to invalid IL or missing references)
				//IL_0044: Unknown result type (might be due to invalid IL or missing references)
				//IL_0047: Unknown result type (might be due to invalid IL or missing references)
				//IL_004a: Invalid comparison between Unknown and I4
				//IL_004c: Unknown result type (might be due to invalid IL or missing references)
				//IL_004e: Invalid comparison between Unknown and I4
				//IL_0050: Unknown result type (might be due to invalid IL or missing references)
				//IL_0052: Invalid comparison between Unknown and I4
				//IL_008c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0060: Unknown result type (might be due to invalid IL or missing references)
				//IL_0062: Invalid comparison between Unknown and I4
				//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
				//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
				_placing = null;
				GameObject placementGhost = __instance.m_placementGhost;
				if (!((Object)(object)__instance != (Object)(object)Player.m_localPlayer) && !((Object)(object)placementGhost == (Object)null) && placementGhost.activeSelf && !(Mode() != "Unrestricted (Cheat)"))
				{
					PlacementStatus placementStatus = __instance.m_placementStatus;
					if ((int)placementStatus != 0 && (int)placementStatus != 12 && (int)placementStatus != 2 && ((int)placementStatus != 4 || _wards.Value) && ((int)placementStatus != 3 || _noBuild.Value) && (_noBuild.Value || !Location.IsInsideNoBuildLocation(placementGhost.transform.position)) && (_wards.Value || PrivateArea.CheckAccess(placementGhost.transform.position, 0f, false, false)))
					{
						__instance.m_placementStatus = (PlacementStatus)0;
						__instance.SetPlacementGhostValid(true);
					}
				}
			}
		}

		[HarmonyPatch(typeof(Player), "HaveRequirements", new Type[]
		{
			typeof(Piece),
			typeof(RequirementMode)
		})]
		internal static class StationPatch
		{
			[HarmonyPriority(800)]
			private static void Prefix(Player __instance, Piece piece, RequirementMode mode, out CraftingStation __state)
			{
				//IL_0003: 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)
				__state = null;
				if ((int)mode == 0 && !((Object)(object)piece == (Object)null) && !((Object)(object)piece.m_craftingStation == (Object)null) && !((Object)(object)__instance != (Object)(object)Player.m_localPlayer) && _station.Value && !(Mode() != "Unrestricted (Cheat)") && !((Object)(object)CraftingStation.HaveBuildStationInRange(piece.m_craftingStation.m_name, ((Component)__instance).transform.position) != (Object)null))
				{
					__state = piece.m_craftingStation;
					piece.m_craftingStation = null;
				}
			}

			private static void Finalizer(Piece piece, CraftingStation __state)
			{
				if ((Object)(object)__state != (Object)null)
				{
					piece.m_craftingStation = __state;
				}
			}
		}

		private const string Section = "Building";

		private const string CheatSection = "Cheats: Building";

		internal const string Vanilla = "Vanilla";

		internal const string Accurate = "Accurate";

		internal const string Unrestricted = "Unrestricted (Cheat)";

		private static ConfigEntry<string> _mode;

		private static ConfigEntry<bool> _wards;

		private static ConfigEntry<bool> _noBuild;

		private static ConfigEntry<bool> _station;

		private static Player _placing;

		public static void Bind(ConfigFile cfg)
		{
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Expected O, but got Unknown
			_mode = cfg.Bind<string>("Building", "Build Restrictions", "Accurate", new ConfigDescription("Vanilla = every placement rule of the game. Accurate = station extensions (Chopping Block, Tanning Rack, Anvils and the like) may stand as close together as their own shapes allow, instead of 2 m apart; every other rule stays. Unrestricted (Cheat) = any spot where the piece shows is valid, except inside another player, with the choices in Cheats, Building.", (AcceptableValueBase)(object)new AcceptableValueList<string>(new string[3] { "Vanilla", "Accurate", "Unrestricted (Cheat)" }), Array.Empty<object>()));
			_wards = cfg.Bind<bool>("Cheats: Building", "Unrestricted Ignores Wards (Cheat)", false, "Cheat, off by default: with Build Restrictions on Unrestricted (Cheat), pieces may also be placed inside other players' wards.");
			_noBuild = cfg.Bind<bool>("Cheats: Building", "Unrestricted Ignores No-Build Zones (Cheat)", false, "Cheat, off by default: with Build Restrictions on Unrestricted (Cheat), pieces may be placed in the places the game keeps free of building (around traders, boss altars and the like).");
			_station = cfg.Bind<bool>("Cheats: Building", "Unrestricted Ignores Station Range (Cheat)", false, "Cheat, off by default: with Build Restrictions on Unrestricted (Cheat), pieces that need a crafting station nearby (a workbench for most) may be placed without one.");
		}

		internal static string Mode()
		{
			string text = _mode?.Value ?? "Vanilla";
			if (text == "Unrestricted (Cheat)" && !ServerRules.Allows("UnrestrictedBuilding"))
			{
				text = "Accurate";
			}
			if (text == "Accurate" && !ServerRules.Allows("AccuratePlacement"))
			{
				text = "Vanilla";
			}
			return text;
		}
	}
	internal static class BuildSections
	{
		[HarmonyPatch(typeof(TabHandler), "Update")]
		internal static class TabPatch
		{
			private static void Prefix(TabHandler __instance)
			{
				if (_on == null || !_on.Value || !Available)
				{
					return;
				}
				bool buttonDown = ZInput.GetButtonDown("TabLeft");
				bool buttonDown2 = ZInput.GetButtonDown("TabRight");
				if ((!buttonDown && !buttonDown2) || (Object)(object)((Component)__instance).GetComponentInParent<BuildUi>() == (Object)null || InventoryFeatures.Typing())
				{
					return;
				}
				object obj = TypingField?.GetValue(null);
				if (obj is bool && (bool)obj)
				{
					return;
				}
				object value = InstanceField.GetValue(null);
				if (value != null)
				{
					obj = ShownField.GetValue(value);
					if (obj is bool && (bool)obj)
					{
						StepMethod.Invoke(value, new object[1] { (!buttonDown) ? 1 : (-1) });
						ZInput.ResetButtonStatus(buttonDown ? "TabLeft" : "TabRight");
					}
				}
			}
		}

		private static readonly Type MenuType = TypeLookup.Find("SeneaLUI.Hud.BuildMenuView");

		private static readonly FieldInfo InstanceField = ((MenuType == null) ? null : AccessTools.Field(MenuType, "_instance"));

		private static readonly FieldInfo ShownField = ((MenuType == null) ? null : AccessTools.Field(MenuType, "_shown"));

		private static readonly FieldInfo TypingField = ((MenuType == null) ? null : AccessTools.Field(MenuType, "Typing"));

		private static readonly MethodInfo StepMethod = ((MenuType == null) ? null : AccessTools.Method(MenuType, "PadChip", new Type[1] { typeof(int) }, (Type[])null));

		private static ConfigEntry<bool> _on;

		public static bool Available
		{
			get
			{
				if (InstanceField != null && ShownField != null)
				{
					return StepMethod != null;
				}
				return false;
			}
		}

		public static void Bind(ConfigFile cfg)
		{
			_on = cfg.Bind<bool>("Building", "Q And E Change Section", false, "In the build menu, Q and E step through the sections beside the pieces (the category chips) instead of the four sorting tabs. Off, they change the tab as the game does.");
		}
	}
	internal static class CarryCheats
	{
		[HarmonyPatch(typeof(Player), "GetMaxCarryWeight")]
		internal static class WeightPatch
		{
			private static void Postfix(Player __instance, ref float __result)
			{
				if (_infinite != null && Local(__instance) && ServerRules.On(_infinite, "InfiniteCarry") && __result < 100000f)
				{
					__result = 100000f;
				}
			}
		}

		[HarmonyPatch(typeof(Player), "IsEncumbered")]
		internal static class EncumberedPatch
		{
			private static void Postfix(Player __instance, ref bool __result)
			{
				if (__result && _noEncumbrance != null && Local(__instance) && ServerRules.On(_noEncumbrance, "NoEncumbrance"))
				{
					__result = false;
				}
			}
		}

		private const string Section = "Cheats: Carrying";

		private const float Unlimited = 100000f;

		private static ConfigEntry<bool> _infinite;

		private static ConfigEntry<bool> _noEncumbrance;

		public static void Bind(ConfigFile cfg)
		{
			_infinite = cfg.Bind<bool>("Cheats: Carrying", "Infinite Carry Weight (Cheat)", false, "Cheat, off by default: your carry weight limit is 100000, so you are never encumbered and auto-pickup never stops for weight.");
			_noEncumbrance = cfg.Bind<bool>("Cheats: Carrying", "No Encumbrance (Cheat)", false, "Cheat, off by default: going over your carry weight never encumbers you (no slowdown, no stamina drain, running allowed), while the limit itself and auto-pickup stopping at it stay as the game has them.");
		}

		private static bool Local(Player player)
		{
			if ((Object)(object)player != (Object)null)
			{
				return (Object)(object)player == (Object)(object)Player.m_localPlayer;
			}
			return false;
		}
	}
	internal static class Cartography
	{
		[HarmonyPatch(typeof(Minimap), "AddSharedMapData")]
		internal static class ReadPatch
		{
			private static void Postfix(Minimap __instance)
			{
				//IL_0051: Unknown result type (might be due to invalid IL or missing references)
				//IL_0056: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ac: