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.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Cryptography;
using System.Security.Permissions;
using System.Text;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using HarmonyLib;
using JetBrains.Annotations;
using Jotunn.GUI;
using Jotunn.Managers;
using Jotunn.Utils;
using LocalizationManager;
using Microsoft.CodeAnalysis;
using ProtectiveWards;
using ProtectiveWards.Compatibility;
using SoftReferenceableAssets;
using Splatform;
using UnityEngine;
using UnityEngine.Events;
using UnityEngine.UI;
using YamlDotNet.Serialization;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: AssemblyTitle("Protective Wards")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("Protective Wards")]
[assembly: AssemblyCopyright("Copyright ©  2023")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("f71912b8-9b1c-4181-911a-1550f4ec2889")]
[assembly: AssemblyFileVersion("2.0.6")]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("2.0.6.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 LocalizationManager
{
	[PublicAPI]
	public class Localizer
	{
		private const string defaultLanguage = "English";

		private static readonly Dictionary<string, Dictionary<string, Func<string>>> PlaceholderProcessors;

		private static readonly Dictionary<string, Dictionary<string, string>> loadedTexts;

		private static readonly ConditionalWeakTable<Localization, string> localizationLanguage;

		private static readonly List<WeakReference<Localization>> localizationObjects;

		private static BaseUnityPlugin? _plugin;

		private static readonly List<string> fileExtensions;

		private static BaseUnityPlugin Plugin
		{
			get
			{
				//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b2: Expected O, but got Unknown
				if (_plugin == null)
				{
					IEnumerable<TypeInfo> source;
					try
					{
						source = Assembly.GetExecutingAssembly().DefinedTypes.ToList();
					}
					catch (ReflectionTypeLoadException ex)
					{
						source = from t in ex.Types
							where t != null
							select t.GetTypeInfo();
					}
					_plugin = (BaseUnityPlugin)Chainloader.ManagerObject.GetComponent((Type)source.First((TypeInfo t) => t.IsClass && typeof(BaseUnityPlugin).IsAssignableFrom(t)));
				}
				return _plugin;
			}
		}

		private static void UpdatePlaceholderText(Localization localization, string key)
		{
			localizationLanguage.TryGetValue(localization, out string value);
			string text = loadedTexts[value][key];
			if (PlaceholderProcessors.TryGetValue(key, out Dictionary<string, Func<string>> value2))
			{
				text = value2.Aggregate(text, (string current, KeyValuePair<string, Func<string>> kv) => current.Replace("{" + kv.Key + "}", kv.Value()));
			}
			localization.AddWord(key, text);
		}

		public static void AddPlaceholder<T>(string key, string placeholder, ConfigEntry<T> config, Func<T, string>? convertConfigValue = null) where T : notnull
		{
			if (convertConfigValue == null)
			{
				convertConfigValue = (T val) => val.ToString();
			}
			if (!PlaceholderProcessors.ContainsKey(key))
			{
				PlaceholderProcessors[key] = new Dictionary<string, Func<string>>();
			}
			config.SettingChanged += delegate
			{
				UpdatePlaceholder();
			};
			if (loadedTexts.ContainsKey(Localization.instance.GetSelectedLanguage()))
			{
				UpdatePlaceholder();
			}
			void UpdatePlaceholder()
			{
				PlaceholderProcessors[key][placeholder] = () => convertConfigValue(config.Value);
				UpdatePlaceholderText(Localization.instance, key);
			}
		}

		public static void AddText(string key, string text)
		{
			List<WeakReference<Localization>> list = new List<WeakReference<Localization>>();
			foreach (WeakReference<Localization> localizationObject in localizationObjects)
			{
				if (localizationObject.TryGetTarget(out var target))
				{
					Dictionary<string, string> dictionary = loadedTexts[localizationLanguage.GetOrCreateValue(target)];
					if (!target.m_translations.ContainsKey(key))
					{
						dictionary[key] = text;
						target.AddWord(key, text);
					}
				}
				else
				{
					list.Add(localizationObject);
				}
			}
			foreach (WeakReference<Localization> item in list)
			{
				localizationObjects.Remove(item);
			}
		}

		public static IEnumerator Load()
		{
			yield return (object)new WaitUntil((Func<bool>)(() => PlatformManager.DistributionPlatform != null && PlatformInitializer.PreferencesInitialized));
			if (string.IsNullOrEmpty(PlatformPrefs.GetString("language", "")))
			{
				PlatformPrefs.SetString("language", "English");
			}
			LoadLocalization(Localization.instance, Localization.instance.GetSelectedLanguage());
		}

		private static void LoadLocalization(Localization __instance, string language)
		{
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: Expected O, but got Unknown
			//IL_01da: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e4: Expected O, but got Unknown
			if (!localizationLanguage.Remove(__instance))
			{
				localizationObjects.Add(new WeakReference<Localization>(__instance));
			}
			localizationLanguage.Add(__instance, language);
			Dictionary<string, string> localizationFiles = new Dictionary<string, string>();
			string[] prefixes = new string[2]
			{
				Plugin.Info.Metadata.Name + ".",
				Plugin.Info.Metadata.Name.Replace(" ", "") + "."
			};
			Scan(Paths.ConfigPath, warn: true);
			byte[] array = LoadTranslationFromAssembly("English");
			if (array == null)
			{
				throw new Exception("Found no English localizations in mod " + Plugin.Info.Metadata.Name + ". Expected an embedded resource Translations/English.json or Translations/English.yml.");
			}
			Dictionary<string, string> dictionary = ((BuilderSkeleton<DeserializerBuilder>)new DeserializerBuilder()).IgnoreFields().Build().Deserialize<Dictionary<string, string>>(Encoding.UTF8.GetString(array));
			if (dictionary == null)
			{
				throw new Exception("Localization for mod " + Plugin.Info.Metadata.Name + " failed: Localization file was empty.");
			}
			string text = null;
			if (language != "English")
			{
				if (localizationFiles.ContainsKey(language))
				{
					text = File.ReadAllText(localizationFiles[language]);
				}
				else
				{
					byte[] array2 = LoadTranslationFromAssembly(language);
					if (array2 != null)
					{
						text = Encoding.UTF8.GetString(array2);
					}
				}
			}
			if (text == null && localizationFiles.ContainsKey("English"))
			{
				text = File.ReadAllText(localizationFiles["English"]);
			}
			if (text != null)
			{
				Dictionary<string, string> dictionary2;
				try
				{
					dictionary2 = ((BuilderSkeleton<DeserializerBuilder>)new DeserializerBuilder()).IgnoreFields().Build().Deserialize<Dictionary<string, string>>(text) ?? new Dictionary<string, string>();
				}
				catch (Exception arg)
				{
					global::ProtectiveWards.ProtectiveWards.LogInfo($"Failed to deserialize localization for language '{language}'. Using base localization only.\n{arg}");
					dictionary2 = new Dictionary<string, string>();
				}
				foreach (KeyValuePair<string, string> item in dictionary2)
				{
					dictionary[item.Key] = item.Value;
				}
			}
			loadedTexts[language] = dictionary;
			foreach (KeyValuePair<string, string> item2 in dictionary)
			{
				UpdatePlaceholderText(__instance, item2.Key);
			}
			void Scan(string root, bool warn)
			{
				foreach (string item3 in from f in Directory.GetFiles(root, "*.*", SearchOption.AllDirectories)
					where fileExtensions.Contains(Path.GetExtension(f))
					select f)
				{
					string fileNameWithoutExtension = Path.GetFileNameWithoutExtension(item3);
					string[] array3 = prefixes;
					foreach (string text2 in array3)
					{
						if (fileNameWithoutExtension.StartsWith(text2))
						{
							string text3 = fileNameWithoutExtension.Substring(text2.Length);
							if (!string.IsNullOrWhiteSpace(text3))
							{
								if (localizationFiles.ContainsKey(text3))
								{
									if (warn)
									{
										global::ProtectiveWards.ProtectiveWards.LogInfo("Duplicate localization '" + text3 + "' for " + Plugin.Info.Metadata.Name + ". Skipping " + item3);
									}
								}
								else
								{
									localizationFiles[text3] = item3;
								}
							}
							break;
						}
					}
				}
			}
		}

		static Localizer()
		{
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Expected O, but got Unknown
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Expected O, but got Unknown
			PlaceholderProcessors = new Dictionary<string, Dictionary<string, Func<string>>>();
			loadedTexts = new Dictionary<string, Dictionary<string, string>>();
			localizationLanguage = new ConditionalWeakTable<Localization, string>();
			localizationObjects = new List<WeakReference<Localization>>();
			fileExtensions = new List<string> { ".json", ".yml" };
			Harmony val = new Harmony("org.bepinex.helpers.LocalizationManager");
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(Localization), "LoadCSV", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(Localizer), "LoadLocalization", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		}

		private static byte[]? LoadTranslationFromAssembly(string language)
		{
			foreach (string fileExtension in fileExtensions)
			{
				byte[] array = ReadEmbeddedFileBytes("translations." + language + fileExtension);
				if (array != null)
				{
					return array;
				}
			}
			return null;
		}

		public static byte[]? ReadEmbeddedFileBytes(string resourceFileName, Assembly? containingAssembly = null)
		{
			using MemoryStream memoryStream = new MemoryStream();
			if ((object)containingAssembly == null)
			{
				containingAssembly = Assembly.GetCallingAssembly();
			}
			string text = containingAssembly.GetManifestResourceNames().FirstOrDefault((string str) => str.EndsWith(resourceFileName, StringComparison.Ordinal));
			if (text != null)
			{
				containingAssembly.GetManifestResourceStream(text)?.CopyTo(memoryStream);
			}
			return (memoryStream.Length == 0L) ? null : memoryStream.ToArray();
		}
	}
}
namespace ProtectiveWards
{
	internal static class AdminServerFeatures
	{
		[HarmonyPatch(typeof(Terminal), "InitTerminal")]
		private static class Terminal_InitTerminal_RegisterCommands
		{
			private static void Postfix()
			{
				RegisterCommands();
			}
		}

		[HarmonyPatch(typeof(ZoneSystem), "Start")]
		private static class ZoneSystem_Start_RegisterAdminRPCs
		{
			private static void Postfix()
			{
				RegisterRPCs();
			}
		}

		[HarmonyPatch(typeof(ZoneSystem), "OnDestroy")]
		private static class ZoneSystem_OnDestroy_ResetAdminRPCs
		{
			private static void Postfix()
			{
				ResetRPCRegistration();
			}
		}

		[HarmonyPatch(typeof(Piece), "SetCreator")]
		private static class Piece_SetCreator_CheckWardBuildLimit
		{
			private static void Postfix(Piece __instance, long uid)
			{
				//IL_008b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0090: Unknown result type (might be due to invalid IL or missing references)
				//IL_0096: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
				if (ProtectiveWards.wardBuildLimitPerPlayer.Value <= 0 || (Object)(object)__instance == (Object)null || uid == 0L || (Object)(object)((Component)__instance).GetComponent<PrivateArea>() == (Object)null || !WardZdoUtils.IsWardPrefab(((Component)__instance).gameObject))
				{
					return;
				}
				ZNetView componentZNetView = ((Component)(object)__instance).GetComponentZNetView();
				if ((Object)(object)componentZNetView == (Object)null || !componentZNetView.IsValid())
				{
					return;
				}
				ZDO zDO = componentZNetView.GetZDO();
				if (zDO != null)
				{
					ZDOID uid2 = zDO.m_uid;
					if (!s_requestedWardLimitChecks.Contains(uid2))
					{
						s_requestedWardLimitChecks.Add(uid2);
						RequestWardBuildLimitCheck(uid, uid2);
					}
				}
			}
		}

		private const string RPC_PermitPlayer = "PW_PermitPlayer";

		private const string RPC_UnpermitPlayer = "PW_UnpermitPlayer";

		private const string RPC_SetWardEnabled = "PW_SetWardEnabled";

		private const string RPC_SetWardExpired = "PW_SetWardExpired";

		private const string RPC_CheckWardBuildLimit = "PW_CheckWardBuildLimit";

		private const string RPC_DestroyWardForBuildLimit = "PW_DestroyWardForBuildLimit";

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

		private static bool s_rpcRegistered;

		private static bool s_commandRegistered;

		internal static void RegisterRPCs()
		{
			if (!s_rpcRegistered && ZRoutedRpc.instance != null)
			{
				ZRoutedRpc.instance.Register<ZPackage>("PW_DestroyWardForBuildLimit", (Action<long, ZPackage>)RPC_DestroyWardForBuildLimitClient);
				ZNet instance = ZNet.instance;
				if (instance != null && instance.IsServer())
				{
					ZRoutedRpc.instance.Register<ZPackage>("PW_PermitPlayer", (Action<long, ZPackage>)RPC_PermitPlayerServer);
					ZRoutedRpc.instance.Register<ZPackage>("PW_UnpermitPlayer", (Action<long, ZPackage>)RPC_UnpermitPlayerServer);
					ZRoutedRpc.instance.Register<ZPackage>("PW_SetWardEnabled", (Action<long, ZPackage>)RPC_SetWardEnabledServer);
					ZRoutedRpc.instance.Register<ZPackage>("PW_SetWardExpired", (Action<long, ZPackage>)RPC_SetWardExpiredServer);
					ZRoutedRpc.instance.Register<ZPackage>("PW_CheckWardBuildLimit", (Action<long, ZPackage>)RPC_CheckWardBuildLimitServer);
				}
				s_rpcRegistered = true;
			}
		}

		internal static void ResetRPCRegistration()
		{
			s_rpcRegistered = false;
			s_requestedWardLimitChecks.Clear();
		}

		private static void RegisterCommands()
		{
			if (!s_commandRegistered)
			{
				RegisterPlayerListCommand("pw_permit", "<player name> - add an online player to the nearest ward within configured range", RequestPermit);
				RegisterPlayerListCommand("ward_permit", "<player name> - add an online player to the nearest ward within configured range", RequestPermit);
				RegisterPlayerListCommand("pw_unpermit", "<player name> - remove a player from the nearest ward permitted list", RequestUnpermit);
				RegisterPlayerListCommand("ward_unpermit", "<player name> - remove a player from the nearest ward permitted list", RequestUnpermit);
				RegisterWardStateCommand("pw_enable", "enable the nearest ward within configured range", enabled: true);
				RegisterWardStateCommand("ward_enable", "enable the nearest ward within configured range", enabled: true);
				RegisterWardStateCommand("pw_disable", "disable the nearest ward within configured range", enabled: false);
				RegisterWardStateCommand("ward_disable", "disable the nearest ward within configured range", enabled: false);
				RegisterWardExpirationStateCommand("pw_set_expired", "mark the nearest ward as expired", expired: true);
				RegisterWardExpirationStateCommand("ward_set_expired", "mark the nearest ward as expired", expired: true);
				RegisterWardExpirationStateCommand("pw_set_unexpired", "clear expired state from the nearest ward", expired: false);
				RegisterWardExpirationStateCommand("ward_set_unexpired", "clear expired state from the nearest ward", expired: false);
				s_commandRegistered = true;
			}
		}

		private static void RegisterPlayerListCommand(string command, string description, Action<string, Terminal> action)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Expected O, but got Unknown
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			new ConsoleCommand(command, description, (ConsoleEvent)delegate(ConsoleEventArgs args)
			{
				if (ValidateWardControlCommand(args.Context))
				{
					if (args.Length < 2)
					{
						args.Context.AddString("Usage: <player name>");
					}
					else
					{
						action(GetCommandQuery(args), args.Context);
					}
				}
			}, false, false, false, false, false, (ConsoleOptionsFetcher)null, false, false, false);
		}

		private static void RegisterWardStateCommand(string command, string description, bool enabled)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Expected O, but got Unknown
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			new ConsoleCommand(command, description, (ConsoleEvent)delegate(ConsoleEventArgs args)
			{
				if (ValidateWardControlCommand(args.Context))
				{
					RequestSetWardEnabled(enabled, args.Context);
				}
			}, false, false, false, false, false, (ConsoleOptionsFetcher)null, false, false, false);
		}

		private static void RegisterWardExpirationStateCommand(string command, string description, bool expired)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Expected O, but got Unknown
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			new ConsoleCommand(command, description, (ConsoleEvent)delegate(ConsoleEventArgs args)
			{
				if (ValidateWardControlCommand(args.Context))
				{
					RequestSetWardExpired(expired, args.Context);
				}
			}, false, false, false, false, false, (ConsoleOptionsFetcher)null, false, false, false);
		}

		private static string GetCommandQuery(ConsoleEventArgs args)
		{
			return string.Join(" ", args.Args.Skip(1).ToArray()).Trim();
		}

		private static bool ValidateWardControlCommand(Terminal context)
		{
			if (AreWardControlCommandsEnabled())
			{
				return true;
			}
			context.AddString("Ward control commands are disabled.");
			return false;
		}

		private static bool AreWardControlCommandsEnabled()
		{
			return ProtectiveWards.wardExternalControlCommandsEnabled.Value;
		}

		private static float GetWardControlCommandRange()
		{
			return Math.Max(ProtectiveWards.wardExternalControlCommandRange.Value, 0f);
		}

		private static void RequestPermit(string query, Terminal context)
		{
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0173: Unknown result type (might be due to invalid IL or missing references)
			//IL_017a: Expected O, but got Unknown
			//IL_0187: Unknown result type (might be due to invalid IL or missing references)
			//IL_01dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e6: Expected O, but got Unknown
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null)
			{
				context.AddString("Player is not available.");
				return;
			}
			PrivateArea val = FindNearestWard(((Component)localPlayer).transform.position, GetWardControlCommandRange());
			if ((Object)(object)val == (Object)null || (Object)(object)val.m_nview == (Object)null || !val.m_nview.IsValid())
			{
				context.AddString("$pw_permit_no_ward".Localize());
				return;
			}
			if (!ProtectiveWards.HasAccessToWardOrConnectedWard(val, localPlayer))
			{
				context.AddString("$pw_permit_no_access".Localize());
				return;
			}
			List<Player> list = FindOnlinePlayers(query);
			if (list.Count == 0)
			{
				context.AddString("$pw_permit_no_match".Localize(query));
				return;
			}
			if (list.Count > 1)
			{
				context.AddString("$pw_permit_multiple".Localize(string.Join(", ", list.Select((Player p) => p.GetPlayerName()).ToArray())));
				return;
			}
			Player val2 = list[0];
			if (IsPlayerInPermittedList(val, val2.GetPlayerID()))
			{
				context.AddString("$pw_permit_already".Localize());
				return;
			}
			ZPackage val3 = new ZPackage();
			val3.Write(val.m_nview.GetZDO().m_uid);
			val3.Write(localPlayer.GetPlayerID());
			val3.Write(val2.GetPlayerID());
			val3.Write(val2.GetPlayerName());
			ZNet instance = ZNet.instance;
			if (instance != null && instance.IsServer())
			{
				RPC_PermitPlayerServer(0L, new ZPackage(val3.GetArray()));
			}
			else
			{
				ZRoutedRpc.instance.InvokeRoutedRPC("PW_PermitPlayer", new object[1] { val3 });
			}
			context.AddString("$pw_permit_added".Localize(val2.GetPlayerName()));
		}

		private static void RequestUnpermit(string query, Terminal context)
		{
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0139: Unknown result type (might be due to invalid IL or missing references)
			//IL_0140: Expected O, but got Unknown
			//IL_014d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0195: Unknown result type (might be due to invalid IL or missing references)
			//IL_019f: Expected O, but got Unknown
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null)
			{
				context.AddString("Player is not available.");
				return;
			}
			PrivateArea val = FindNearestWard(((Component)localPlayer).transform.position, GetWardControlCommandRange());
			if ((Object)(object)val == (Object)null || (Object)(object)val.m_nview == (Object)null || !val.m_nview.IsValid())
			{
				context.AddString("$pw_permit_no_ward".Localize());
				return;
			}
			if (!ProtectiveWards.HasAccessToWardOrConnectedWard(val, localPlayer))
			{
				context.AddString("$pw_permit_no_access".Localize());
				return;
			}
			List<KeyValuePair<long, string>> list = FindPermittedPlayers(val, query);
			if (list.Count == 0)
			{
				context.AddString("No permitted player matched: " + query);
				return;
			}
			if (list.Count > 1)
			{
				context.AddString("Multiple permitted players matched: " + string.Join(", ", list.Select((KeyValuePair<long, string> p) => p.Value).ToArray()));
				return;
			}
			KeyValuePair<long, string> keyValuePair = list[0];
			ZPackage val2 = new ZPackage();
			val2.Write(val.m_nview.GetZDO().m_uid);
			val2.Write(localPlayer.GetPlayerID());
			val2.Write(keyValuePair.Key);
			ZNet instance = ZNet.instance;
			if (instance != null && instance.IsServer())
			{
				RPC_UnpermitPlayerServer(0L, new ZPackage(val2.GetArray()));
			}
			else
			{
				ZRoutedRpc.instance.InvokeRoutedRPC("PW_UnpermitPlayer", new object[1] { val2 });
			}
			context.AddString("Removed " + keyValuePair.Value + " from ward permitted list.");
		}

		private static void RequestSetWardEnabled(bool enabled, Terminal context)
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Expected O, but got Unknown
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Expected O, but got Unknown
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null)
			{
				context.AddString("Player is not available.");
				return;
			}
			PrivateArea val = FindNearestWard(((Component)localPlayer).transform.position, GetWardControlCommandRange());
			if ((Object)(object)val == (Object)null || (Object)(object)val.m_nview == (Object)null || !val.m_nview.IsValid())
			{
				context.AddString("$pw_permit_no_ward".Localize());
				return;
			}
			if (!CanLocalToggleWard(val))
			{
				context.AddString("$pw_permit_no_access".Localize());
				return;
			}
			ZPackage val2 = new ZPackage();
			val2.Write(val.m_nview.GetZDO().m_uid);
			val2.Write(localPlayer.GetPlayerID());
			val2.Write(enabled);
			ZNet instance = ZNet.instance;
			if (instance != null && instance.IsServer())
			{
				RPC_SetWardEnabledServer(0L, new ZPackage(val2.GetArray()));
			}
			else
			{
				ZRoutedRpc.instance.InvokeRoutedRPC("PW_SetWardEnabled", new object[1] { val2 });
			}
			context.AddString(enabled ? "Ward enable requested." : "Ward disable requested.");
		}

		private static void RequestSetWardExpired(bool expired, Terminal context)
		{
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Expected O, but got Unknown
			//IL_00b6: 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_010c: Expected O, but got Unknown
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null)
			{
				context.AddString("Player is not available.");
				return;
			}
			if (!ProtectiveWards.HasLocalWardAdminAccess())
			{
				context.AddString("$pw_permit_no_access".Localize());
				return;
			}
			PrivateArea val = FindNearestWard(((Component)localPlayer).transform.position, GetWardControlCommandRange());
			if ((Object)(object)val == (Object)null || (Object)(object)val.m_nview == (Object)null || !val.m_nview.IsValid())
			{
				context.AddString("$pw_permit_no_ward".Localize());
				return;
			}
			ZPackage val2 = new ZPackage();
			val2.Write(val.m_nview.GetZDO().m_uid);
			val2.Write(localPlayer.GetPlayerID());
			val2.Write(localPlayer.GetPlayerName());
			val2.Write(expired);
			ZNet instance = ZNet.instance;
			if (instance != null && instance.IsServer())
			{
				RPC_SetWardExpiredServer(0L, new ZPackage(val2.GetArray()));
			}
			else
			{
				ZRoutedRpc.instance.InvokeRoutedRPC("PW_SetWardExpired", new object[1] { val2 });
			}
			context.AddString(expired ? "Ward expired state requested." : "Ward unexpired state requested.");
		}

		private static void RPC_PermitPlayerServer(long sender, ZPackage package)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			ZDOID val = package.ReadZDOID();
			long claimedPlayerID = package.ReadLong();
			long num = package.ReadLong();
			string text = package.ReadString();
			if (!AreWardControlCommandsEnabled() || !ProtectiveWards.TryGetRoutedPlayer(sender, claimedPlayerID, out var player))
			{
				return;
			}
			ZDO ward = WardZdoUtils.GetWard(val);
			if (ward != null && CanRequesterPermit(ward, player.PlayerID))
			{
				Player player2 = Player.GetPlayer(num);
				if (!((Object)(object)player2 == (Object)null) && !(player2.GetPlayerName() != text) && !WardZdoUtils.IsExplicitlyPermitted(ward, num))
				{
					WardZdoUtils.AddPermitted(ward, num, text);
					ProtectiveWards.LogInfo($"Added {text} to ward {val} permitted list by command");
				}
			}
		}

		private static void RPC_UnpermitPlayerServer(long sender, ZPackage package)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			ZDOID val = package.ReadZDOID();
			long claimedPlayerID = package.ReadLong();
			long playerID = package.ReadLong();
			if (AreWardControlCommandsEnabled() && ProtectiveWards.TryGetRoutedPlayer(sender, claimedPlayerID, out var player))
			{
				ZDO ward = WardZdoUtils.GetWard(val);
				if (ward != null && CanRequesterPermit(ward, player.PlayerID) && WardZdoUtils.RemovePermitted(ward, playerID, out var playerName))
				{
					ProtectiveWards.LogInfo($"Removed {playerName} from ward {val} permitted list by command");
				}
			}
		}

		private static void RPC_SetWardEnabledServer(long sender, ZPackage package)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			ZDOID val = package.ReadZDOID();
			long claimedPlayerID = package.ReadLong();
			bool flag = package.ReadBool();
			if (!AreWardControlCommandsEnabled() || !ProtectiveWards.TryGetRoutedPlayer(sender, claimedPlayerID, out var player))
			{
				return;
			}
			ZDO ward = WardZdoUtils.GetWard(val);
			if (ward != null && CanRequesterToggleWard(ward, player.PlayerID) && ward.GetBool(ZDOVars.s_enabled, false) != flag)
			{
				ward.Set(ZDOVars.s_enabled, flag);
				if (flag)
				{
					ProtectiveWards.ActivateConnectedWardZdos(ward, player.PlayerID, player.PlayerName);
				}
				ProtectiveWards.LogInfo(string.Format("{0} ward {1} by command", flag ? "Enabled" : "Disabled", val));
			}
		}

		private static void RPC_SetWardExpiredServer(long sender, ZPackage package)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			ZDOID val = package.ReadZDOID();
			long claimedPlayerID = package.ReadLong();
			package.ReadString();
			bool flag = package.ReadBool();
			if (AreWardControlCommandsEnabled() && ProtectiveWards.TryGetRoutedPlayer(sender, claimedPlayerID, out var player))
			{
				ZDO ward = WardZdoUtils.GetWard(val);
				if (ward != null && ProtectiveWards.HasWardManagementAccess(ward, player.PlayerID))
				{
					WardExpiration.SetExpired(ward, flag, player.PlayerID, player.PlayerName);
					ProtectiveWards.LogInfo(string.Format("{0} ward {1} expired state by admin command", flag ? "Marked" : "Cleared", val));
				}
			}
		}

		private static bool CanRequesterPermit(ZDO zdo, long requesterID)
		{
			if (!WardZdoUtils.IsWard(zdo) || requesterID == 0)
			{
				return false;
			}
			if (WardZdoUtils.HasDirectAccessToWardZdo(zdo, requesterID))
			{
				return true;
			}
			if (!IsActiveWardZdoForCommandAccess(zdo))
			{
				return false;
			}
			ProtectiveWards.WardConnectedAccessMode mode = ProtectiveWards.wardAccessConnectedAccessMode?.Value ?? ProtectiveWards.WardConnectedAccessMode.Off;
			return zdo.HasConnectedWardAccess(requesterID, mode, IsActiveWardZdoForCommandAccess);
		}

		private static bool CanLocalToggleWard(PrivateArea ward)
		{
			int result;
			if ((Object)(object)ward != (Object)null)
			{
				if (!((Object)(object)ward.m_piece != (Object)null) || !ward.m_piece.IsCreator())
				{
					Player localPlayer = Player.m_localPlayer;
					result = (ProtectiveWards.HasWardManagementAccess(ward, (localPlayer != null) ? localPlayer.GetPlayerID() : 0) ? 1 : 0);
				}
				else
				{
					result = 1;
				}
			}
			else
			{
				result = 0;
			}
			return (byte)result != 0;
		}

		private static bool CanRequesterToggleWard(ZDO zdo, long requesterID)
		{
			if (!WardZdoUtils.IsWard(zdo) || requesterID == 0)
			{
				return false;
			}
			return ProtectiveWards.HasWardManagementAccess(zdo, requesterID) || zdo.IsCreator(requesterID);
		}

		private static bool IsActiveWardZdoForCommandAccess(ZDO zdo)
		{
			return WardZdoUtils.IsWard(zdo) && zdo.GetBool(ZDOVars.s_enabled, false) && !WardExpiration.IsExpired(zdo);
		}

		private static bool IsPlayerInPermittedList(PrivateArea ward, long playerID)
		{
			return (Object)(object)ward != (Object)null && ward.GetPermittedPlayers().Any((KeyValuePair<long, string> player) => player.Key == playerID);
		}

		private static List<KeyValuePair<long, string>> FindPermittedPlayers(PrivateArea ward, string query)
		{
			string normalized = query.Trim();
			if (normalized.Length == 0)
			{
				return new List<KeyValuePair<long, string>>();
			}
			List<KeyValuePair<long, string>> permittedPlayers = ward.GetPermittedPlayers();
			List<KeyValuePair<long, string>> list = permittedPlayers.Where((KeyValuePair<long, string> player) => string.Equals(player.Value, normalized, StringComparison.OrdinalIgnoreCase)).ToList();
			if (list.Count > 0)
			{
				return list;
			}
			return permittedPlayers.Where((KeyValuePair<long, string> player) => player.Value.IndexOf(normalized, StringComparison.OrdinalIgnoreCase) >= 0).ToList();
		}

		private static PrivateArea FindNearestWard(Vector3 point, float range)
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Invalid comparison between Unknown and I4
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			PrivateArea result = null;
			float num = Math.Max(range, 0f);
			foreach (PrivateArea allArea in PrivateArea.m_allAreas)
			{
				if (!((Object)(object)allArea == (Object)null) && (int)allArea.m_ownerFaction <= 0)
				{
					float num2 = Utils.DistanceXZ(((Component)allArea).transform.position, point);
					if (num2 <= num)
					{
						num = num2;
						result = allArea;
					}
				}
			}
			return result;
		}

		private static List<Player> FindOnlinePlayers(string query)
		{
			string normalized = query.Trim();
			if (normalized.Length == 0)
			{
				return new List<Player>();
			}
			List<Player> allPlayers = Player.GetAllPlayers();
			List<Player> list = allPlayers.Where((Player player) => string.Equals(player.GetPlayerName(), normalized, StringComparison.OrdinalIgnoreCase)).ToList();
			if (list.Count > 0)
			{
				return list;
			}
			return allPlayers.Where((Player player) => player.GetPlayerName().IndexOf(normalized, StringComparison.OrdinalIgnoreCase) >= 0).ToList();
		}

		private static void RequestWardBuildLimitCheck(long creatorID, ZDOID newWardID)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Expected O, but got Unknown
			ZPackage val = new ZPackage();
			val.Write(creatorID);
			val.Write(newWardID);
			ZNet instance = ZNet.instance;
			if (instance != null && instance.IsServer())
			{
				RPC_CheckWardBuildLimitServer(0L, new ZPackage(val.GetArray()));
				return;
			}
			ZRoutedRpc instance2 = ZRoutedRpc.instance;
			if (instance2 != null)
			{
				instance2.InvokeRoutedRPC("PW_CheckWardBuildLimit", new object[1] { val });
			}
		}

		private static void RPC_CheckWardBuildLimitServer(long sender, ZPackage package)
		{
			//IL_0009: 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_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			long num = package.ReadLong();
			ZDOID val = package.ReadZDOID();
			try
			{
				if (ProtectiveWards.wardBuildLimitPerPlayer.Value <= 0 || num == 0L || ((ZDOID)(ref val)).Equals(ZDOID.None) || !ProtectiveWards.TryGetRoutedPlayer(sender, num, out var player))
				{
					return;
				}
				ZDOMan instance = ZDOMan.instance;
				ZDO val2 = ((instance != null) ? instance.GetZDO(val) : null);
				if (val2.IsWard() && val2.IsCreator(player.PlayerID) && (sender == 0L || val2.GetOwner() == sender))
				{
					int value = ProtectiveWards.wardBuildLimitPerPlayer.Value;
					int num2 = WardZdoUtils.CountWardsByCreator(player.PlayerID);
					if (num2 > value)
					{
						int current = Math.Max(num2 - 1, 0);
						SendDestroyWardForBuildLimit(val2, current, value);
					}
				}
			}
			finally
			{
				s_requestedWardLimitChecks.Remove(val);
			}
		}

		private static void SendDestroyWardForBuildLimit(ZDO zdo, int current, int limit)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Expected O, but got Unknown
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Expected O, but got Unknown
			if (zdo != null)
			{
				ZDOID uid = zdo.m_uid;
				long owner = zdo.GetOwner();
				DestroyWardForBuildLimitServer(zdo);
				ZPackage val = new ZPackage();
				val.Write(uid);
				val.Write(current);
				val.Write(limit);
				if (owner != 0L && ZRoutedRpc.instance != null)
				{
					ZRoutedRpc.instance.InvokeRoutedRPC(owner, "PW_DestroyWardForBuildLimit", new object[1] { val });
				}
				else if ((Object)(object)Player.m_localPlayer != (Object)null)
				{
					RPC_DestroyWardForBuildLimitClient(0L, new ZPackage(val.GetArray()));
				}
			}
		}

		private static void DestroyWardForBuildLimitServer(ZDO zdo)
		{
			if (zdo != null && ZDOMan.instance != null)
			{
				zdo.SetOwner(ZDOMan.instance.m_sessionID);
				ZDOMan.instance.DestroyZDO(zdo);
			}
		}

		private static void RPC_DestroyWardForBuildLimitClient(long sender, ZPackage package)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			ZDOID wardID = package.ReadZDOID();
			int num = package.ReadInt();
			int num2 = package.ReadInt();
			DestroyLocalWard(wardID);
			Player localPlayer = Player.m_localPlayer;
			if (localPlayer != null)
			{
				((Character)localPlayer).Message((MessageType)2, "$pw_ward_limit_reached".Localize(num.ToString(), num2.ToString()), 0, (Sprite)null);
			}
		}

		private static void DestroyLocalWard(ZDOID wardID)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)ZNetScene.instance == (Object)null))
			{
				GameObject val = ZNetScene.instance.FindInstance(wardID);
				if ((Object)(object)val != (Object)null)
				{
					ZNetScene.instance.Destroy(val);
				}
			}
		}
	}
	internal static class ItemNameTokens
	{
		[HarmonyPatch(typeof(ObjectDB), "Awake")]
		private static class ObjectDB_Awake_UpdateItemNameTokens
		{
			private static void Postfix()
			{
				UpdateRegisters();
			}
		}

		[HarmonyPatch(typeof(ObjectDB), "CopyOtherDB")]
		private static class ObjectDB_CopyOtherDB_UpdateItemNameTokens
		{
			private static void Postfix()
			{
				UpdateRegisters();
			}
		}

		[HarmonyPatch(typeof(Player), "Load")]
		private static class Player_Load_UpdateItemNameTokens
		{
			private static void Prefix()
			{
				UpdateRegisters();
			}
		}

		private static readonly Dictionary<string, string> s_itemNames = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);

		internal static void UpdateRegisters()
		{
			if (!Object.op_Implicit((Object)(object)ObjectDB.instance))
			{
				return;
			}
			s_itemNames.Clear();
			foreach (GameObject item in ObjectDB.instance.m_items)
			{
				if ((Object)(object)item == (Object)null)
				{
					continue;
				}
				ItemDrop component = item.GetComponent<ItemDrop>();
				if (component != null)
				{
					SharedData val = component.m_itemData?.m_shared;
					if (val != null && !string.IsNullOrWhiteSpace(val.m_name) && val.m_name.StartsWith("$"))
					{
						Register(((Object)item).name, val.m_name);
						Register(val.m_name, val.m_name);
						Localization instance = Localization.instance;
						Register((instance != null) ? instance.Localize(val.m_name) : null, val.m_name);
					}
				}
			}
		}

		internal static string GetItemName(this string input)
		{
			if (string.IsNullOrWhiteSpace(input))
			{
				return "";
			}
			string text = input.Trim();
			string value;
			return s_itemNames.TryGetValue(text, out value) ? value : text;
		}

		private static void Register(string key, string token)
		{
			if (!string.IsNullOrWhiteSpace(key))
			{
				s_itemNames[key.Trim()] = token;
			}
		}
	}
	public static class StringExtensions
	{
		public static string Localize(this string text)
		{
			return (Localization.instance != null) ? Localization.instance.Localize(text) : text;
		}

		public static string Localize(this string text, params string[] words)
		{
			return (Localization.instance != null) ? Localization.instance.Localize(text, words) : text;
		}
	}
	internal static class ComponentExtensions
	{
		internal static ZNetView GetComponentZNetView(this Component component)
		{
			if ((Object)(object)component == (Object)null)
			{
				return null;
			}
			PrivateArea val = (PrivateArea)(object)((component is PrivateArea) ? component : null);
			if (val != null)
			{
				return val.m_nview;
			}
			Ship val2 = (Ship)(object)((component is Ship) ? component : null);
			if (val2 != null)
			{
				return val2.m_nview;
			}
			ShipControlls val3 = (ShipControlls)(object)((component is ShipControlls) ? component : null);
			if (val3 != null)
			{
				return val3.m_nview;
			}
			Vagon val4 = (Vagon)(object)((component is Vagon) ? component : null);
			if (val4 != null)
			{
				return val4.m_nview;
			}
			Catapult val5 = (Catapult)(object)((component is Catapult) ? component : null);
			if (val5 != null)
			{
				return val5.m_nview;
			}
			MapTable val6 = (MapTable)(object)((component is MapTable) ? component : null);
			if (val6 != null)
			{
				return val6.m_nview;
			}
			Turret val7 = (Turret)(object)((component is Turret) ? component : null);
			if (val7 != null)
			{
				return val7.m_nview;
			}
			Fireplace val8 = (Fireplace)(object)((component is Fireplace) ? component : null);
			if (val8 != null)
			{
				return val8.m_nview;
			}
			Tameable val9 = (Tameable)(object)((component is Tameable) ? component : null);
			if (val9 != null)
			{
				return val9.m_nview;
			}
			Sadle val10 = (Sadle)(object)((component is Sadle) ? component : null);
			if (val10 != null)
			{
				return val10.m_nview;
			}
			TeleportWorld val11 = (TeleportWorld)(object)((component is TeleportWorld) ? component : null);
			if (val11 != null)
			{
				return val11.m_nview;
			}
			return component.GetComponent<ZNetView>() ?? component.GetComponentInParent<ZNetView>();
		}

		internal static ZDO GetWardZDO(this Component component)
		{
			ZNetView componentZNetView = component.GetComponentZNetView();
			return ((Object)(object)componentZNetView != (Object)null && componentZNetView.IsValid()) ? componentZNetView.GetZDO() : null;
		}
	}
	internal static class PrivateAreaExtensions
	{
		internal static ZDO GetWardZDO(this PrivateArea ward)
		{
			ZNetView componentZNetView = ((Component)(object)ward).GetComponentZNetView();
			return ((Object)(object)componentZNetView != (Object)null && componentZNetView.IsValid()) ? componentZNetView.GetZDO() : null;
		}

		internal static bool HasDirectWardAccess(this PrivateArea ward, long playerID)
		{
			return ProtectiveWards.HasDirectAccessToWard(ward, playerID);
		}

		internal static bool HasConnectedWardAccess(this PrivateArea ward, long playerID, ProtectiveWards.WardConnectedAccessMode mode)
		{
			return ProtectiveWards.HasAccessToWardOrConnectedWard(ward, playerID, mode);
		}
	}
	internal static class WardZdoExtensions
	{
		internal static bool IsWard(this ZDO zdo)
		{
			return WardZdoUtils.IsWard(zdo);
		}

		internal static long GetCreatorId(this ZDO zdo)
		{
			return (zdo != null) ? zdo.GetLong(ZDOVars.s_creator, 0L) : 0;
		}

		internal static bool IsCreator(this ZDO zdo, long creatorID)
		{
			return zdo.GetCreatorId() == creatorID;
		}

		internal static bool HasDirectWardAccess(this ZDO zdo, long playerID)
		{
			return WardZdoUtils.HasDirectAccessToWardZdo(zdo, playerID);
		}

		internal static bool HasConnectedWardAccess(this ZDO zdo, long playerID, ProtectiveWards.WardConnectedAccessMode mode, Func<ZDO, bool> isActiveCandidate)
		{
			return WardZdoUtils.HasAccessToWardOrConnectedWardZdo(zdo, playerID, mode, isActiveCandidate);
		}

		internal static float GetWardRadius(this ZDO zdo)
		{
			return WardZdoUtils.GetWardRadius(zdo);
		}

		internal static bool IsWardPermitted(this ZDO zdo, long playerID)
		{
			return WardZdoUtils.IsPermitted(zdo, playerID);
		}
	}
	internal static class WardZdoUtils
	{
		[HarmonyPatch(typeof(ZDOMan), "Load")]
		private static class ZDOMan_Load_WardListInit
		{
			private static void Postfix(ZDOMan __instance)
			{
				RebuildWardObjects(__instance);
			}
		}

		[HarmonyPatch(typeof(ZoneSystem), "Start")]
		private static class ZoneSystem_Start_WardListInit
		{
			private static void Postfix()
			{
				EnsureWardObjectsInitialized();
			}
		}

		[HarmonyPatch(typeof(ZDOMan), "CreateNewZDO", new Type[]
		{
			typeof(ZDOID),
			typeof(Vector3),
			typeof(int)
		})]
		private static class ZDOMan_CreateNewZDO_WardListAddNew
		{
			private static void Postfix(int prefabHashIn, ZDO __result)
			{
				if (ShouldTrackServerWards() && (prefabHashIn == 0 || prefabHashIn == s_wardPrefabHash))
				{
					AddIfWard(__result);
				}
			}
		}

		[HarmonyPatch(typeof(ZDOMan), "HandleDestroyedZDO")]
		private static class ZDOMan_HandleDestroyedZDO_WardListRemove
		{
			private static void Prefix(ZDOMan __instance, ZDOID uid)
			{
				//IL_000c: Unknown result type (might be due to invalid IL or missing references)
				if (__instance != null)
				{
					RemoveIfWard(__instance.GetZDO(uid));
				}
			}
		}

		[HarmonyPatch(typeof(ZDO), "Deserialize")]
		private static class ZDO_Deserialize_WardListAdd
		{
			private static void Postfix(ZDO __instance)
			{
				AddIfWard(__instance);
			}
		}

		[HarmonyPatch(typeof(ZoneSystem), "OnDestroy")]
		private static class ZoneSystem_OnDestroy_WardListClear
		{
			private static void Postfix()
			{
				s_wardObjects.Clear();
				s_wardObjectsInitialized = false;
			}
		}

		internal const string WardPrefabName = "guard_stone";

		internal static readonly int s_wardPrefabHash = StringExtensionMethods.GetStableHashCode("guard_stone");

		private static readonly HashSet<ZDO> s_wardObjects = new HashSet<ZDO>();

		private static bool s_wardObjectsInitialized;

		private static bool s_wardDefaultRadiusCached;

		private static float s_wardDefaultRadius = 32f;

		internal static bool IsWardPrefab(GameObject gameObject)
		{
			return (Object)(object)gameObject != (Object)null && Utils.GetPrefabName(gameObject) == "guard_stone";
		}

		internal static bool IsWard(ZDO zdo)
		{
			return zdo != null && zdo.GetPrefab() == s_wardPrefabHash;
		}

		internal static IEnumerable<ZDO> GetAllWards()
		{
			if (ShouldTrackServerWards())
			{
				EnsureWardObjectsInitialized();
				PruneWardObjects();
				foreach (ZDO s_wardObject in s_wardObjects)
				{
					yield return s_wardObject;
				}
				yield break;
			}
			HashSet<ZDOID> visited = new HashSet<ZDOID>();
			foreach (PrivateArea area in PrivateArea.m_allAreas)
			{
				int num;
				if (area == null)
				{
					num = 0;
				}
				else
				{
					ZNetView nview = area.m_nview;
					num = ((((nview != null) ? new bool?(nview.IsValid()) : ((bool?)null)) == true) ? 1 : 0);
				}
				ZDO zdo = ((num != 0) ? area.m_nview.GetZDO() : null);
				if (IsWard(zdo) && visited.Add(zdo.m_uid))
				{
					yield return zdo;
				}
			}
		}

		internal static int CountWardsByCreator(long creatorID)
		{
			if (creatorID == 0)
			{
				return 0;
			}
			int num = 0;
			foreach (ZDO allWard in GetAllWards())
			{
				if (allWard.IsCreator(creatorID))
				{
					num++;
				}
			}
			return num;
		}

		internal static PrivateArea FindLoadedWard(ZDOID zdoID)
		{
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			foreach (PrivateArea allArea in PrivateArea.m_allAreas)
			{
				if (!((Object)(object)allArea == (Object)null) && !((Object)(object)allArea.m_nview == (Object)null) && allArea.m_nview.IsValid())
				{
					ZDO zDO = allArea.m_nview.GetZDO();
					if (zDO != null && ((ZDOID)(ref zDO.m_uid)).Equals(zdoID))
					{
						return allArea;
					}
				}
			}
			return null;
		}

		internal static ZDO GetWard(ZDOID zdoID)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			ZDOMan instance = ZDOMan.instance;
			ZDO val = ((instance != null) ? instance.GetZDO(zdoID) : null);
			return IsWard(val) ? val : null;
		}

		internal static bool TryGetWard(ZDOID zdoID, out ZDO zdo)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			zdo = GetWard(zdoID);
			return zdo != null;
		}

		internal static List<KeyValuePair<long, string>> GetPermittedPlayers(ZDO zdo)
		{
			List<KeyValuePair<long, string>> list = new List<KeyValuePair<long, string>>();
			if (!IsWard(zdo))
			{
				return list;
			}
			int num = Math.Max(zdo.GetInt(ZDOVars.s_permitted, 0), 0);
			for (int i = 0; i < num; i++)
			{
				long num2 = zdo.GetLong("pu_id" + i, 0L);
				if (num2 != 0)
				{
					list.Add(new KeyValuePair<long, string>(num2, zdo.GetString("pu_name" + i, "")));
				}
			}
			return list;
		}

		internal static bool IsExplicitlyPermitted(ZDO zdo, long playerID)
		{
			return playerID != 0L && GetPermittedPlayers(zdo).Any((KeyValuePair<long, string> player) => player.Key == playerID);
		}

		internal static bool AddPermitted(ZDO zdo, long playerID, string playerName)
		{
			if (!IsWard(zdo) || playerID == 0)
			{
				return false;
			}
			List<KeyValuePair<long, string>> permittedPlayers = GetPermittedPlayers(zdo);
			if (permittedPlayers.Any((KeyValuePair<long, string> player) => player.Key == playerID))
			{
				return false;
			}
			permittedPlayers.Add(new KeyValuePair<long, string>(playerID, playerName ?? ""));
			SetPermittedPlayers(zdo, permittedPlayers);
			return true;
		}

		internal static bool RemovePermitted(ZDO zdo, long playerID, out string playerName)
		{
			playerName = "";
			if (!IsWard(zdo) || playerID == 0)
			{
				return false;
			}
			List<KeyValuePair<long, string>> permittedPlayers = GetPermittedPlayers(zdo);
			KeyValuePair<long, string> keyValuePair = permittedPlayers.FirstOrDefault((KeyValuePair<long, string> player) => player.Key == playerID);
			if (keyValuePair.Key == 0)
			{
				return false;
			}
			playerName = keyValuePair.Value ?? "";
			permittedPlayers.RemoveAll((KeyValuePair<long, string> player) => player.Key == playerID);
			SetPermittedPlayers(zdo, permittedPlayers);
			return true;
		}

		internal static void SetPermittedPlayers(ZDO zdo, List<KeyValuePair<long, string>> permitted)
		{
			if (IsWard(zdo))
			{
				if (permitted == null)
				{
					permitted = new List<KeyValuePair<long, string>>();
				}
				zdo.Set(ZDOVars.s_permitted, permitted.Count, false);
				for (int i = 0; i < permitted.Count; i++)
				{
					zdo.Set("pu_id" + i, permitted[i].Key);
					zdo.Set("pu_name" + i, permitted[i].Value ?? "");
				}
			}
		}

		internal static bool IsPermitted(ZDO zdo, long playerID)
		{
			if (zdo == null || playerID == 0)
			{
				return false;
			}
			if (ProtectiveWards.HasWardManagementAccess(zdo, playerID))
			{
				return true;
			}
			if (IsExplicitlyPermitted(zdo, playerID))
			{
				return true;
			}
			return GuildsCompat.HasWardGuildAccess(zdo, playerID);
		}

		internal static bool HasDirectAccessToWardZdo(ZDO zdo, long playerID)
		{
			if (zdo == null)
			{
				return true;
			}
			if (playerID == 0)
			{
				return false;
			}
			if (!IsWard(zdo))
			{
				return false;
			}
			if (zdo.IsCreator(playerID))
			{
				return true;
			}
			return IsPermitted(zdo, playerID);
		}

		internal static bool UseCustomWardRange(ZDO zdo)
		{
			if (!ProtectiveWards.ArePerWardSettingsEnabled())
			{
				return ProtectiveWards.setWardRange.Value;
			}
			if (zdo == null)
			{
				return false;
			}
			bool flag = ProtectiveWards.wardSettingsUseDefaultsForAllWards.Value && ProtectiveWards.setWardRange.Value;
			if (ProtectiveWards.HasZdoFloat(zdo, ProtectiveWards.s_range))
			{
				flag = true;
			}
			return zdo.GetBool(ProtectiveWards.s_customRange, flag);
		}

		internal static float GetConfiguredWardRange(ZDO zdo)
		{
			if (!ProtectiveWards.ArePerWardSettingsEnabled())
			{
				return ProtectiveWards.wardRange.Value;
			}
			return (zdo != null) ? zdo.GetFloat(ProtectiveWards.s_range, ProtectiveWards.wardSettingsUseDefaultsForAllWards.Value ? ProtectiveWards.wardRange.Value : GetWardDefaultRadius()) : ProtectiveWards.wardRange.Value;
		}

		internal static float GetWardDefaultRadius()
		{
			if (s_wardDefaultRadiusCached)
			{
				return s_wardDefaultRadius;
			}
			if ((Object)(object)ZNetScene.instance != (Object)null)
			{
				ZNetScene instance = ZNetScene.instance;
				object obj;
				if (instance == null)
				{
					obj = null;
				}
				else
				{
					GameObject prefab = instance.GetPrefab("guard_stone");
					obj = ((prefab != null) ? prefab.GetComponent<PrivateArea>() : null);
				}
				PrivateArea val = (PrivateArea)obj;
				if ((Object)(object)val != (Object)null)
				{
					s_wardDefaultRadius = val.m_radius;
				}
			}
			s_wardDefaultRadiusCached = true;
			return s_wardDefaultRadius;
		}

		internal static float GetWardRadius(ZDO zdo)
		{
			if (zdo == null)
			{
				return GetWardDefaultRadius();
			}
			return UseCustomWardRange(zdo) ? GetConfiguredWardRange(zdo) : GetWardDefaultRadius();
		}

		internal static bool AreWardZdosOverlapping(ZDO protectedWard, ZDO candidateWard)
		{
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			if (!IsWard(protectedWard) || !IsWard(candidateWard))
			{
				return false;
			}
			float wardRadius = GetWardRadius(protectedWard);
			float wardRadius2 = GetWardRadius(candidateWard);
			return ProtectiveWards.GetConfiguredWardDistance(protectedWard.GetPosition(), candidateWard.GetPosition()) <= wardRadius + wardRadius2;
		}

		internal static bool CanShareConnectedWardAccess(ZDO protectedWard, ZDO candidateWard, ProtectiveWards.WardConnectedAccessMode mode)
		{
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			if (mode == ProtectiveWards.WardConnectedAccessMode.Off)
			{
				return false;
			}
			if (!IsWard(protectedWard) || !IsWard(candidateWard))
			{
				return false;
			}
			if (protectedWard == candidateWard || ((ZDOID)(ref protectedWard.m_uid)).Equals(candidateWard.m_uid))
			{
				return true;
			}
			switch (mode)
			{
			case ProtectiveWards.WardConnectedAccessMode.SameCreatorOnly:
			{
				long creatorId = protectedWard.GetCreatorId();
				long creatorId2 = candidateWard.GetCreatorId();
				return creatorId != 0L && creatorId == creatorId2;
			}
			case ProtectiveWards.WardConnectedAccessMode.MutualTrust:
			{
				long creatorId = protectedWard.GetCreatorId();
				long creatorId2 = candidateWard.GetCreatorId();
				return creatorId != 0L && creatorId2 != 0L && HasDirectAccessToWardZdo(protectedWard, creatorId2) && HasDirectAccessToWardZdo(candidateWard, creatorId);
			}
			case ProtectiveWards.WardConnectedAccessMode.AnyConnected:
				return true;
			default:
				return false;
			}
		}

		internal static IEnumerable<ZDO> ConnectedAccessWardZdos(ZDO rootWard, ProtectiveWards.WardConnectedAccessMode mode, Func<ZDO, bool> isActiveCandidate)
		{
			if (!IsWard(rootWard))
			{
				yield break;
			}
			HashSet<ZDOID> visited = new HashSet<ZDOID>();
			List<ZDO> queue = new List<ZDO>();
			int queueIndex = 0;
			visited.Add(rootWard.m_uid);
			queue.Add(rootWard);
			while (queueIndex < queue.Count)
			{
				ZDO current = queue[queueIndex++];
				yield return current;
				if (mode == ProtectiveWards.WardConnectedAccessMode.Off)
				{
					continue;
				}
				foreach (ZDO candidate in GetAllWards())
				{
					if (candidate != null && !visited.Contains(candidate.m_uid) && (isActiveCandidate == null || isActiveCandidate(candidate)) && AreWardZdosOverlapping(current, candidate) && CanShareConnectedWardAccess(rootWard, candidate, mode))
					{
						visited.Add(candidate.m_uid);
						queue.Add(candidate);
					}
				}
			}
		}

		internal static bool HasAccessToWardOrConnectedWardZdo(ZDO rootWard, long playerID, ProtectiveWards.WardConnectedAccessMode mode, Func<ZDO, bool> isActiveCandidate)
		{
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			if (HasDirectAccessToWardZdo(rootWard, playerID))
			{
				return true;
			}
			if (mode == ProtectiveWards.WardConnectedAccessMode.Off)
			{
				return false;
			}
			foreach (ZDO item in ConnectedAccessWardZdos(rootWard, mode, isActiveCandidate))
			{
				if (item == null || ((ZDOID)(ref item.m_uid)).Equals(rootWard.m_uid) || !HasDirectAccessToWardZdo(item, playerID))
				{
					continue;
				}
				return true;
			}
			return false;
		}

		private static bool ShouldTrackServerWards()
		{
			return (Object)(object)ZNet.instance != (Object)null && ZNet.instance.IsServer();
		}

		private static void AddIfWard(ZDO zdo)
		{
			if (ShouldTrackServerWards() && IsWard(zdo))
			{
				s_wardObjects.Add(zdo);
			}
		}

		private static void RemoveIfWard(ZDO zdo)
		{
			if (zdo != null && IsWard(zdo))
			{
				s_wardObjects.Remove(zdo);
			}
		}

		private static void PruneWardObjects()
		{
			s_wardObjects.RemoveWhere((ZDO zdo) => zdo == null || !IsWard(zdo));
		}

		private static void EnsureWardObjectsInitialized()
		{
			if (!ShouldTrackServerWards())
			{
				return;
			}
			ZDOMan instance = ZDOMan.instance;
			if (instance != null)
			{
				if (!s_wardObjectsInitialized)
				{
					RebuildWardObjects(instance);
				}
				else if (s_wardObjects.Count == 0 && instance.m_objectsByID.Count > 0)
				{
					RebuildWardObjects(instance);
				}
			}
		}

		private static void RebuildWardObjects(ZDOMan zdoMan)
		{
			s_wardObjects.Clear();
			if (!ShouldTrackServerWards() || zdoMan == null)
			{
				s_wardObjectsInitialized = false;
				return;
			}
			s_wardObjectsInitialized = true;
			foreach (KeyValuePair<ZDOID, ZDO> item in zdoMan.m_objectsByID)
			{
				AddIfWard(item.Value);
			}
		}
	}
	internal static class BackgroundProtection
	{
		private struct CachedBool
		{
			public float Time;

			public bool Value;
		}

		[HarmonyPatch(typeof(ZoneSystem), "Start")]
		private static class ZoneSystem_Start_ResetBackgroundProtectionCache
		{
			private static void Postfix()
			{
				ResetCache();
			}
		}

		[HarmonyPatch(typeof(ZoneSystem), "OnDestroy")]
		private static class ZoneSystem_OnDestroy_ResetBackgroundProtectionCache
		{
			private static void Postfix()
			{
				ResetCache();
			}
		}

		[HarmonyPatch(typeof(Player), "TryPlacePiece")]
		private static class Player_TryPlacePiece_PreventBuildingWithoutPermittedPlayersNearby
		{
			[HarmonyPriority(800)]
			private static bool Prefix(Player __instance, Piece piece, ref bool __result)
			{
				//IL_0036: Unknown result type (might be due to invalid IL or missing references)
				if ((Object)(object)__instance == (Object)null || (Object)(object)piece == (Object)null || (Object)(object)__instance.m_placementGhost == (Object)null)
				{
					return true;
				}
				if (!IsBuildingRestricted(__instance, __instance.m_placementGhost.transform.position))
				{
					return true;
				}
				((Character)__instance).Message((MessageType)2, "$msg_privatezone", 0, (Sprite)null);
				__result = false;
				return false;
			}
		}

		[HarmonyPatch(typeof(Player), "CheckCanRemovePiece")]
		private static class Player_CheckCanRemovePiece_PreventDemolishingWithoutPermittedPlayersNearby
		{
			[HarmonyPriority(800)]
			private static bool Prefix(Player __instance, Piece piece, ref bool __result)
			{
				//IL_0031: Unknown result type (might be due to invalid IL or missing references)
				if ((Object)(object)__instance == (Object)null || (Object)(object)piece == (Object)null)
				{
					return true;
				}
				if (piece.IsCreator())
				{
					return true;
				}
				if (!IsBuildingRestricted(__instance, ((Component)piece).transform.position))
				{
					return true;
				}
				((Character)__instance).Message((MessageType)2, "$msg_privatezone", 0, (Sprite)null);
				__result = false;
				return false;
			}
		}

		[HarmonyPatch(typeof(WearNTear), "Damage")]
		private static class WearNTear_Damage_BackgroundProtection
		{
			private static void Prefix(WearNTear __instance, HitData hit)
			{
				if (ShouldSuppressWearNTearDamage(__instance, hit) || ShouldSuppressTameDamageToStructure(__instance, hit))
				{
					((DamageTypes)(ref hit.m_damage)).Modify(0f);
				}
			}
		}

		[HarmonyPatch(typeof(Character), "Damage")]
		private static class Character_Damage_BackgroundTameProtection
		{
			private static void Prefix(Character __instance, HitData hit)
			{
				if (ShouldSuppressTameCharacterDamage(__instance))
				{
					((DamageTypes)(ref hit.m_damage)).Modify(0f);
				}
			}
		}

		[HarmonyPatch(typeof(BaseAI), "FindEnemy")]
		private static class BaseAI_FindEnemy_PacifyTames
		{
			private static bool Prefix(BaseAI __instance, ref Character __result)
			{
				if (!ShouldPacifyTame(__instance))
				{
					return true;
				}
				__result = null;
				return false;
			}
		}

		[HarmonyPatch(typeof(BaseAI), "FindRandomStaticTarget")]
		private static class BaseAI_FindRandomStaticTarget_PacifyTames
		{
			private static bool Prefix(BaseAI __instance, ref StaticTarget __result)
			{
				if (!ShouldPacifyTame(__instance))
				{
					return true;
				}
				__result = null;
				return false;
			}
		}

		[HarmonyPatch(typeof(BaseAI), "FindClosestStaticPriorityTarget")]
		private static class BaseAI_FindClosestStaticPriorityTarget_PacifyTames
		{
			private static bool Prefix(BaseAI __instance, ref StaticTarget __result)
			{
				if (!ShouldPacifyTame(__instance))
				{
					return true;
				}
				__result = null;
				return false;
			}
		}

		[HarmonyPatch(typeof(MonsterAI), "UpdateAI")]
		private static class MonsterAI_UpdateAI_PacifyTames
		{
			private static void Prefix(MonsterAI __instance)
			{
				if (ShouldPacifyTame((BaseAI)(object)__instance))
				{
					PacifyMonster(__instance);
				}
			}
		}

		[HarmonyPatch(typeof(AnimalAI), "UpdateAI")]
		private static class AnimalAI_UpdateAI_PacifyTames
		{
			private static void Prefix(AnimalAI __instance)
			{
				if (ShouldPacifyTame((BaseAI)(object)__instance))
				{
					PacifyAnimal(__instance);
				}
			}
		}

		private static readonly Dictionary<ZDOID, CachedBool> s_qualifiedBaseCache = new Dictionary<ZDOID, CachedBool>();

		private const float QualifiedBaseCacheSeconds = 10f;

		private static void ResetCache()
		{
			s_qualifiedBaseCache.Clear();
		}

		internal static bool IsBackgroundProtectionActiveAt(Vector3 point, out ZDO ward)
		{
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			ward = null;
			if (!TryFindBackgroundWard(point, point, out ward))
			{
				return false;
			}
			if (!IsQualifiedProtectedBase(ward))
			{
				return false;
			}
			return !HasEffectiveAccessPresence(ward, point);
		}

		internal static bool TryFindBackgroundWard(Vector3 sourcePoint, Vector3 targetPoint, out ZDO ward)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			ward = null;
			if (!ProtectiveWards.TryResolveWardCheckPoint(sourcePoint, out sourcePoint) || !ProtectiveWards.TryResolveWardCheckPoint(targetPoint, out targetPoint))
			{
				return false;
			}
			ProtectiveWards.WardConnectedAccessMode mode = ((ProtectiveWards.wardBackgroundConnectedAccessMode != null) ? ProtectiveWards.wardBackgroundConnectedAccessMode.Value : ProtectiveWards.WardConnectedAccessMode.Off);
			foreach (ZDO allWard in WardZdoUtils.GetAllWards())
			{
				if (!IsActiveBackgroundWard(allWard) || !ProtectiveWards.IsInsideWardXZ(allWard, sourcePoint) || !WardZdoUtils.ConnectedAccessWardZdos(allWard, mode, IsActiveBackgroundWard).AnySafe((ZDO candidate) => ProtectiveWards.IsInsideWardXZ(candidate, targetPoint)))
				{
					continue;
				}
				ward = allWard;
				return true;
			}
			return false;
		}

		internal static bool HasEffectiveAccessPresence(ZDO ward, Vector3 point)
		{
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0160: Unknown result type (might be due to invalid IL or missing references)
			//IL_0165: Unknown result type (might be due to invalid IL or missing references)
			if (!WardZdoUtils.IsWard(ward))
			{
				return false;
			}
			ProtectiveWards.WardConnectedAccessMode mode = ((ProtectiveWards.wardBackgroundConnectedAccessMode != null) ? ProtectiveWards.wardBackgroundConnectedAccessMode.Value : ProtectiveWards.WardConnectedAccessMode.Off);
			float num = Mathf.Max(ProtectiveWards.wardBackgroundPresenceRadius.Value, 0f);
			if (!ProtectiveWards.TryResolveWardCheckPoint(point, out var resolvedPoint))
			{
				return false;
			}
			foreach (Player allPlayer in Player.GetAllPlayers())
			{
				if ((Object)(object)allPlayer == (Object)null)
				{
					continue;
				}
				long playerID = allPlayer.GetPlayerID();
				if (!ward.HasConnectedWardAccess(playerID, mode, IsActiveBackgroundWard) || !ProtectiveWards.TryResolveWardCheckPoint(((Component)allPlayer).transform.position, out var resolvedPlayerPoint))
				{
					continue;
				}
				switch (ProtectiveWards.wardBackgroundPresenceMode.Value)
				{
				case ProtectiveWards.WardBackgroundPresenceMode.PermittedOnline:
					return true;
				case ProtectiveWards.WardBackgroundPresenceMode.PermittedInsideConnectedArea:
					if (WardZdoUtils.ConnectedAccessWardZdos(ward, mode, IsActiveBackgroundWard).AnySafe((ZDO area) => ProtectiveWards.IsInsideWardXZ(area, resolvedPlayerPoint)))
					{
						return true;
					}
					break;
				default:
					if (Utils.DistanceXZ(resolvedPlayerPoint, resolvedPoint) <= num)
					{
						return true;
					}
					break;
				}
			}
			return false;
		}

		internal static bool IsQualifiedProtectedBase(ZDO ward)
		{
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			if (!WardZdoUtils.IsWard(ward))
			{
				return false;
			}
			int num = Math.Max(ProtectiveWards.wardBackgroundProtectedBaseMinPieces.Value, 0);
			if (num == 0)
			{
				return true;
			}
			if (s_qualifiedBaseCache.TryGetValue(ward.m_uid, out var value) && Time.time - value.Time < 10f)
			{
				return value.Value;
			}
			bool flag = CountPlayerBuiltPiecesInNetwork(ward, num) >= num;
			s_qualifiedBaseCache[ward.m_uid] = new CachedBool
			{
				Time = Time.time,
				Value = flag
			};
			return flag;
		}

		private static int CountPlayerBuiltPiecesInNetwork(ZDO ward, int stopAt)
		{
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			ProtectiveWards.WardConnectedAccessMode mode = ((ProtectiveWards.wardBackgroundConnectedAccessMode != null) ? ProtectiveWards.wardBackgroundConnectedAccessMode.Value : ProtectiveWards.WardConnectedAccessMode.Off);
			HashSet<Piece> hashSet = new HashSet<Piece>();
			List<Piece> list = new List<Piece>();
			foreach (ZDO item in WardZdoUtils.ConnectedAccessWardZdos(ward, mode, IsActiveBackgroundWard))
			{
				list.Clear();
				Piece.GetAllPiecesInRadius(item.GetPosition(), item.GetWardRadius(), list);
				foreach (Piece item2 in list)
				{
					if (!((Object)(object)item2 == (Object)null) && item2.IsPlacedByPlayer())
					{
						hashSet.Add(item2);
						if (hashSet.Count >= stopAt)
						{
							return hashSet.Count;
						}
					}
				}
			}
			return hashSet.Count;
		}

		private static bool IsActiveBackgroundWard(ZDO zdo)
		{
			return WardZdoUtils.IsWard(zdo) && zdo.GetBool(ZDOVars.s_enabled, false) && !WardExpiration.IsExpired(zdo);
		}

		internal static bool ShouldSuppressWearNTearDamage(WearNTear wearNTear, HitData hit)
		{
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_0168: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)wearNTear == (Object)null || hit == null)
			{
				return false;
			}
			Piece val = wearNTear.m_piece ?? ((Component)wearNTear).GetComponent<Piece>();
			bool flag = (Object)(object)val != (Object)null && val.IsPlacedByPlayer();
			bool flag2 = (Object)(object)((Component)wearNTear).GetComponent<Ship>() != (Object)null || (Object)(object)((Component)wearNTear).GetComponentInParent<Ship>() != (Object)null;
			bool flag3 = (Object)(object)((Component)wearNTear).GetComponent<Vagon>() != (Object)null || (Object)(object)((Component)wearNTear).GetComponentInParent<Vagon>() != (Object)null;
			if (!flag && !flag2 && !flag3)
			{
				return false;
			}
			if (!TryFindBackgroundWard(((Component)wearNTear).transform.position, ((Component)wearNTear).transform.position, out var ward))
			{
				return false;
			}
			if (!IsQualifiedProtectedBase(ward))
			{
				return false;
			}
			Character attacker = hit.GetAttacker();
			if (ProtectiveWards.wardBackgroundStructureProtection.Value == ProtectiveWards.WardBackgroundStructureProtectionMode.BlockNonPermittedPlayerDamage && flag && (Object)(object)attacker != (Object)null && attacker.IsPlayer())
			{
				ZDO zdo = ward;
				Character obj = ((attacker is Player) ? attacker : null);
				if (!zdo.HasConnectedWardAccess((obj != null) ? ((Player)obj).GetPlayerID() : 0, ProtectiveWards.wardBackgroundConnectedAccessMode.Value, IsActiveBackgroundWard))
				{
					return true;
				}
			}
			if (HasEffectiveAccessPresence(ward, ((Component)wearNTear).transform.position))
			{
				return false;
			}
			if (ProtectiveWards.wardBackgroundProtectBoats.Value && flag2)
			{
				return true;
			}
			if (ProtectiveWards.wardBackgroundProtectCarts.Value && flag3)
			{
				return true;
			}
			if (flag)
			{
				if (ProtectiveWards.wardBackgroundStructureProtection.Value == ProtectiveWards.WardBackgroundStructureProtectionMode.BlockAllDamageWhenNoPermittedNearby)
				{
					return true;
				}
				if (ProtectiveWards.wardBackgroundProtectFire.Value && IsFireDamage(hit))
				{
					return true;
				}
			}
			return false;
		}

		internal static bool ShouldSuppressTameDamageToStructure(WearNTear wearNTear, HitData hit)
		{
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			if (!ProtectiveWards.wardBackgroundTamesPreventDamageToStructures.Value)
			{
				return false;
			}
			if ((Object)(object)wearNTear == (Object)null || hit == null || !hit.HaveAttacker())
			{
				return false;
			}
			Piece val = wearNTear.m_piece ?? ((Component)wearNTear).GetComponent<Piece>();
			if ((Object)(object)val == (Object)null || !val.IsPlacedByPlayer())
			{
				return false;
			}
			Character attacker = hit.GetAttacker();
			if ((Object)(object)attacker == (Object)null || attacker.IsPlayer() || !attacker.IsTamed())
			{
				return false;
			}
			if (!TryFindBackgroundWard(((Component)attacker).transform.position, ((Component)wearNTear).transform.position, out var ward))
			{
				return false;
			}
			if (!IsQualifiedProtectedBase(ward))
			{
				return false;
			}
			return !HasEffectiveAccessPresence(ward, ((Component)attacker).transform.position) && !HasEffectiveAccessPresence(ward, ((Component)wearNTear).transform.position);
		}

		internal static bool ShouldSuppressTameCharacterDamage(Character character)
		{
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			if (!ProtectiveWards.wardBackgroundProtectTames.Value)
			{
				return false;
			}
			if ((Object)(object)character == (Object)null || !character.IsTamed())
			{
				return false;
			}
			ZDO ward;
			return IsBackgroundProtectionActiveAt(((Component)character).transform.position, out ward);
		}

		internal static bool ShouldPacifyTame(BaseAI ai)
		{
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			if (ProtectiveWards.wardBackgroundTamePacify.Value == ProtectiveWards.WardBackgroundTamePacifyMode.Off)
			{
				return false;
			}
			if ((Object)(object)ai == (Object)null || (Object)(object)ai.m_character == (Object)null || !ai.m_character.IsTamed())
			{
				return false;
			}
			ZDO ward;
			return IsBackgroundProtectionActiveAt(((Component)ai).transform.position, out ward);
		}

		internal static void PacifyMonster(MonsterAI ai)
		{
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)ai == (Object)null))
			{
				((BaseAI)ai).SetAlerted(false);
				ai.m_targetCreature = null;
				ai.m_targetStatic = null;
				ai.m_timeSinceAttacking = 0f;
				ai.m_timeSinceSensedTargetCreature = 99999f;
				((BaseAI)ai).SetTargetInfo(ZDOID.None);
			}
		}

		internal static void PacifyAnimal(AnimalAI ai)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)ai == (Object)null))
			{
				((BaseAI)ai).SetAlerted(false);
				ai.m_target = null;
				((BaseAI)ai).SetTargetInfo(ZDOID.None);
			}
		}

		internal static bool IsBuildingRestricted(Player player, Vector3 point)
		{
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			if (!ProtectiveWards.wardBackgroundPreventBuildingAndDemolishing.Value)
			{
				return false;
			}
			if ((Object)(object)player == (Object)null)
			{
				return false;
			}
			long playerID = player.GetPlayerID();
			if (ProtectiveWards.HasWardAdminAccess(playerID))
			{
				return false;
			}
			if (!TryFindBackgroundWard(point, point, out var ward))
			{
				return false;
			}
			if (!IsQualifiedProtectedBase(ward))
			{
				return false;
			}
			if (ward.HasConnectedWardAccess(player.GetPlayerID(), ProtectiveWards.wardBackgroundConnectedAccessMode.Value, IsActiveBackgroundWard))
			{
				return false;
			}
			return !HasEffectiveAccessPresence(ward, point);
		}

		private static bool IsFireDamage(HitData hit)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Invalid comparison between Unknown and I4
			return hit != null && (hit.m_damage.m_fire > 0f || (int)hit.m_hitType == 5);
		}
	}
	internal static class EnumerableExtensions
	{
		public static bool AnySafe<T>(this IEnumerable<T> source, Func<T, bool> predicate)
		{
			if (source == null)
			{
				return false;
			}
			foreach (T item in source)
			{
				if (predicate(item))
				{
					return true;
				}
			}
			return false;
		}
	}
	internal class FullProtection
	{
		[HarmonyPatch(typeof(PrivateArea), "CheckAccess")]
		public static class PrivateArea_CheckAccess_ScopedWardAccessBypass
		{
			private static bool Prefix(ref bool __result)
			{
				if (s_privateAreaCheckBypassDepth <= 0)
				{
					return true;
				}
				__result = true;
				return false;
			}
		}

		[HarmonyPatch(typeof(Character), "AddFireDamage")]
		public static class Character_AddFireDamage_IndirectFireDamageProtection
		{
			private static void Prefix(Character __instance, ref float damage)
			{
				//IL_0032: Unknown result type (might be due to invalid IL or missing references)
				if (ProtectiveWards.boarsHensProtection.Value && __instance.IsTamed() && ProtectiveWards._boarsHensProtectionGroupList.Contains(__instance.m_group.ToLower()) && ProtectiveWards.InsideEnabledPlayersArea(((Component)__instance).transform.position))
				{
					damage = 0f;
				}
			}
		}

		[HarmonyPatch(typeof(Character), "UpdateSmoke")]
		public static class Character_UpdateSmoke_IndirectSmokeDamageProtection
		{
			private static void Prefix(Character __instance, ref float dt)
			{
				//IL_0032: Unknown result type (might be due to invalid IL or missing references)
				if (ProtectiveWards.boarsHensProtection.Value && __instance.IsTamed() && ProtectiveWards._boarsHensProtectionGroupList.Contains(__instance.m_group.ToLower()) && ProtectiveWards.InsideEnabledPlayersArea(((Component)__instance).transform.position))
				{
					dt = 0f;
				}
			}
		}

		[HarmonyPatch(typeof(WearNTear), "UpdateWear")]
		public static class WearNTear_UpdateWear_RainProtection
		{
			private static void Prefix(WearNTear __instance, ref bool ___m_noRoofWear, ref bool __state)
			{
				//IL_0053: Unknown result type (might be due to invalid IL or missing references)
				if (!((Object)(object)__instance == (Object)null) && ProtectiveWards.wardRainProtection != null && ProtectiveWards.wardRainProtection.Value && ___m_noRoofWear && !((Object)(object)__instance.m_nview == (Object)null) && __instance.m_nview.IsValid() && ProtectiveWards.InsideEnabledPlayersArea(((Component)__instance).transform.position, checkCache: true))
				{
					__state = ___m_noRoofWear;
					___m_noRoofWear = false;
				}
			}

			private static void Postfix(ref bool ___m_noRoofWear, bool __state)
			{
				if (ProtectiveWards.wardRainProtection != null && ProtectiveWards.wardRainProtection.Value && __state)
				{
					___m_noRoofWear = __state;
				}
			}
		}

		[HarmonyPatch(typeof(Ship), "UpdateUpsideDmg")]
		public static class Ship_UpdateUpsideDmg_PreventShipDamage
		{
			private static bool Prefix(Ship __instance)
			{
				//IL_002f: Unknown result type (might be due to invalid IL or missing references)
				if ((Object)(object)__instance == (Object)null || ProtectiveWards.wardShipProtection == null || ProtectiveWards.wardShipProtection.Value == ProtectiveWards.ShipDamageType.Off)
				{
					return true;
				}
				return !ProtectiveWards.InsideEnabledPlayersArea(((Component)__instance).transform.position);
			}
		}

		[HarmonyPatch(typeof(Ship), "UpdateWaterForce")]
		public static class Ship_UpdateWaterForce_PreventShipDamage
		{
			private static void Prefix(Ship __instance, ref float __state)
			{
				//IL_002d: Unknown result type (might be due to invalid IL or missing references)
				if (!((Object)(object)__instance == (Object)null) && ProtectiveWards.wardShipProtection != null && ProtectiveWards.wardShipProtection.Value != ProtectiveWards.ShipDamageType.Off && ProtectiveWards.InsideEnabledPlayersArea(((Component)__instance).transform.position))
				{
					__state = __instance.m_waterImpactDamage;
					__instance.m_waterImpactDamage = 0f;
				}
			}

			private static void Postfix(Ship __instance, float __state)
			{
				if (__state != 0f)
				{
					__instance.m_waterImpactDamage = __state;
				}
			}
		}

		[HarmonyPatch(typeof(Container), "Interact")]
		public static class Container_Interact_PreventUnauthorizedAccess
		{
			[HarmonyPriority(800)]
			private static bool Prefix(Container __instance, Humanoid character, ref bool __result, ref bool __state)
			{
				if (!ProtectiveWards.wardAccessProtectChests.Value)
				{
					return true;
				}
				if (!ProtectiveWards.BlockUnauthorizedWardInteraction((Component)(object)__instance, character))
				{
					if (__instance.m_checkGuardStone)
					{
						StartPrivateAreaCheckBypass((Component)(object)__instance, character, ref __state);
					}
					return true;
				}
				__result = true;
				return false;
			}

			private static void Finalizer(bool __state)
			{
				StopPrivateAreaCheckBypass(__state);
			}
		}

		[HarmonyPatch(typeof(Door), "Interact")]
		public static class Door_Interact_PreventUnauthorizedAccess
		{
			private static bool Prefix(Door __instance, Humanoid character, ref bool __result, ref bool __state)
			{
				if (!ProtectiveWards.wardAccessProtectDoors.Value)
				{
					return true;
				}
				if (!ProtectiveWards.BlockUnauthorizedWardInteraction((Component)(object)__instance, character))
				{
					if (__instance.m_checkGuardStone)
					{
						StartPrivateAreaCheckBypass((Component)(object)__instance, character, ref __state);
					}
					return true;
				}
				__result = true;
				return false;
			}

			private static void Finalizer(bool __state)
			{
				StopPrivateAreaCheckBypass(__state);
			}
		}

		[HarmonyPatch(typeof(Pickable), "Interact")]
		public static class Pickable_Interact_PreventUnauthorizedAccess
		{
			private static bool Prefix(Pickable __instance, Humanoid character, ref bool __result)
			{
				if (!ProtectiveWards.wardAccessProtectPlants.Value)
				{
					return true;
				}
				if (!ProtectiveWards.BlockUnauthorizedWardInteraction((Component)(object)__instance, character))
				{
					return true;
				}
				__result = true;
				return false;
			}
		}

		[HarmonyPatch(typeof(ShipControlls), "Interact")]
		public static class ShipControlls_Interact_PreventUnauthorizedAccess
		{
			private static bool Prefix(ShipControlls __instance, Humanoid character, ref bool __result)
			{
				if (!ProtectiveWards.wardAccessProtectBoats.Value)
				{
					return true;
				}
				if (!ProtectiveWards.BlockUnauthorizedWardInteraction((Component)(object)__instance, character))
				{
					return true;
				}
				__result = true;
				return false;
			}
		}

		[HarmonyPatch(typeof(Sadle), "Interact")]
		public static class Sadle_Interact_PreventUnauthorizedAccess
		{
			private static bool Prefix(Sadle __instance, Humanoid character, ref bool __result)
			{
				if (!ProtectiveWards.wardAccessProtectTames.Value)
				{
					return true;
				}
				if (!ProtectiveWards.BlockUnauthorizedWardInteraction((Component)(object)__instance, character))
				{
					return true;
				}
				__result = true;
				return false;
			}
		}

		[HarmonyPatch(typeof(Tameable), "Interact")]
		public static class Tameable_Interact_PreventUnauthorizedAccess
		{
			private static bool Prefix(Tameable __instance, Humanoid user, bool hold, ref bool __result)
			{
				if (!ProtectiveWards.wardAccessProtectTames.Value)
				{
					return true;
				}
				if (hold)
				{
					return true;
				}
				if (!BlockProtectedInteraction((Component)(object)__instance, user, ref __result))
				{
					return true;
				}
				return false;
			}
		}

		[HarmonyPatch(typeof(Tameable), "UseItem")]
		public static class Tameable_UseItem_PreventUnauthorizedAccess
		{
			private static bool Prefix(Tameable __instance, Humanoid user, ItemData item, ref bool __result)
			{
				if (!ProtectiveWards.wardAccessProtectTames.Value)
				{
					return true;
				}
				if (!IsProtectedTameUseItem(__instance, item))
				{
					return true;
				}
				if (!BlockProtectedInteraction((Component)(object)__instance, user, ref __result))
				{
					return true;
				}
				return false;
			}

			private static bool IsProtectedTameUseItem(Tameable tameable, ItemData item)
			{
				if ((Object)(object)tameable == (Object)null || item == null || (Object)(object)tameable.m_saddleItem == (Object)null || tameable.m_saddleItem.m_itemData == null)
				{
					return false;
				}
				return tameable.IsTamed() && item.m_shared.m_name == tameable.m_saddleItem.m_itemData.m_shared.m_name;
			}
		}

		[HarmonyPatch(typeof(Petable), "Interact")]
		public static class Petable_Interact_PreventUnauthorizedAccess
		{
			private static bool Prefix(Petable __instance, Humanoid user, ref bool __result)
			{
				if (!ProtectiveWards.wardAccessProtectTames.Value)
				{
					return true;
				}
				if (!BlockProtectedInteraction((Component)(object)__instance, user, ref __result))
				{
					return true;
				}
				return false;
			}
		}

		[HarmonyPatch(typeof(Pet), "Interact")]
		public static class Pet_Interact_PreventUnauthorizedAccess
		{
			private static bool Prefix(Pet __instance, Humanoid user, bool hold, ref bool __result, ref bool __state)
			{
				if (!ProtectiveWards.wardAccessProtectTames.Value)
				{
					return true;
				}
				if (!BlockProtectedInteraction((Component)(object)__instance, user, ref __result))
				{
					if (IsProtectedPetItemStandInteraction(__instance, hold))
					{
						StartPrivateAreaCheckBypass((Component)(object)__instance.m_itemStand, user, ref __state);
					}
					return true;
				}
				return false;
			}

			private static void Finalizer(bool __state)
			{
				StopPrivateAreaCheckBypass(__state);
			}

			private static bool IsProtectedPetItemStandInteraction(Pet pet, bool hold)
			{
				return hold && (Object)(object)pet != (Object)null && (Object)(object)pet.m_itemStand != (Object)null && pet.m_itemStand.HaveAttachment();
			}
		}

		[HarmonyPatch(typeof(Pet), "UseItem")]
		public static class Pet_UseItem_PreventUnauthorizedAccess
		{
			private static bool Prefix(Pet __instance, Humanoid user, ItemData item, ref bool __result)
			{
				if (!ProtectiveWards.wardAccessProtectTames.Value)
				{
					return true;
				}
				if (!IsProtectedPetUseItem(__instance, item))
				{
					return true;
				}
				if (!BlockProtectedInteraction((Component)(object)__instance, user, ref __result))
				{
					return true;
				}
				return false;
			}

			private static bool IsProtectedPetUseItem(Pet pet, ItemData item)
			{
				if ((Object)(object)pet == (Object)null || item == null || (Object)(object)pet.m_FeedItem == (Object)null || pet.m_FeedItem.m_itemData == null)
				{
					return false;
				}
				return item.m_shared.m_name == pet.m_FeedItem.m_itemData.m_shared.m_name;
			}
		}

		[HarmonyPatch(typeof(Vagon), "Interact")]
		public static class Vagon_Interact_PreventUnauthorizedAccess
		{
			private static bool Prefix(Vagon __instance, Humanoid character, ref bool __result)
			{
				if (!ProtectiveWards.wardAccessProtectCarts.Value)
				{
					return true;
				}
				if (!BlockProtectedInteraction((Component)(object)__instance, character, ref __result))
				{
					return true;
				}
				return false;
			}
		}

		[HarmonyPatch(typeof(Feast), "Interact")]
		public static class Feast_Interact_PreventUnauthorizedAccess
		{
			private static bool Prefix(Feast __instance, Humanoid human, ref bool __result)
			{
				if (!ProtectiveWards.wardAccessProtectFood.Value)
				{
					return true;
				}
				if (!BlockProtectedInteraction((Component)(object)__instance, human, ref __result))
				{
					return true;
				}
				return false;
			}
		}

		[HarmonyPatch(typeof(ItemDrop), "Interact")]
		public static class ItemDrop_Interact_PreventUnauthorizedFoodAccess
		{
			private static bool Prefix(ItemDrop __instance, Humanoid character, bool alt, ref bool __result)
			{
				if (!ProtectiveWards.wardAccessProtectFood.Value)
				{
					return true;
				}
				if (alt || !IsPlacedConsumable(__instance))
				{
					return true;
				}
				if (!BlockProtectedInteraction((Component)(object)__instance, character, ref __result))
				{
					return true;
				}
				return false;
			}
		}

		[HarmonyPatch(typeof(ItemDrop), "Pickup")]
		public static class ItemDrop_Pickup_PreventUnauthorizedAccess
		{
			private static bool Prefix(ItemDrop __instance, Humanoid character)
			{
				return !ShouldBlockItemPickup(__instance, character);
			}
		}

		[HarmonyPatch(typeof(Humanoid), "Pickup", new Type[]
		{
			typeof(GameObject),
			typeof(bool),
			typeof(bool)
		})]
		public static class Humanoid_Pickup_PreventUnauthorizedAccess
		{
			private static bool Prefix(GameObject go, Humanoid __instance)
			{
				return !ShouldBlockItemPickup((go != null) ? go.GetComponent<ItemDrop>() : null, __instance);
			}
		}

		[HarmonyPatch(typeof(Player), "AutoPickup")]
		public static class Player_AutoPickup_PreventBlockedItemPull
		{
			private static void Prefix(Player __instance)
			{
				s_autoPickupPlayer = __instance;
			}

			private static void Finalizer(Player __instance)
			{
				if ((Object)(object)s_autoPickupPlayer == (Object)(object)__instance)
				{
					s_autoPickupPlayer = null;
				}
			}
		}

		[HarmonyPatch(typeof(ItemDrop), "InTar")]
		public static class ItemDrop_InTar_PreventBlockedAutoPickupPull
		{
			private static void Postfix(ItemDrop __instance, ref bool __result)
			{
				if (!__result && !((Object)(object)s_autoPickupPlayer == (Object)null) && ShouldBlockItemPickup(__instance, (Humanoid)(object)s_autoPickupPlayer, silent: true))
				{
					__result = true;
				}
			}
		}

		[HarmonyPatch(typeof(ShieldGenerator), "OnAddFuel")]
		public static class ShieldGenerator_OnAddFuel_PreventUnauthorizedAccess
		{
			private static bool Prefix(ShieldGenerator __instance, Humanoid user, ref bool __result)
			{
				if (!ProtectiveWards.wardAccessProtectShieldGenerators.Value)
				{
					return true;
				}
				if (!BlockProtectedInteraction((Component)(object)__instance, user, ref __result))
				{
					return true;
				}
				return false;
			}
		}

		[HarmonyPatch(typeof(Incinerator), "OnIncinerate")]
		public static class Incinerator_OnIncinerate_PreventUnauthorizedAccess
		{
			private static bool Prefix(Incinerator __instance, Humanoid user, ref bool __result, ref bool __state)
			{
				if (!ProtectiveWards.wardAccessProtectIncinerators.Value)
				{
					return true;
				}
				if (BlockProtectedInteraction((Component)(object)__instance, user, ref __result))
				{
					return false;
				}
				StartPrivateAreaCheckBypass((Component)(object)__instance, user, ref __state);
				return true;
			}

			private static void Finalizer(bool __state)
			{
				StopPrivateAreaCheckBypass(__state);
			}
		}

		[HarmonyPatch(typeof(TeleportWorld), "Interact")]
		public static class TeleportWorld_Interact_PreventUnauthorizedAccess
		{
			private static bool Prefix(TeleportWorld __instance, Humanoid human, bool hold, ref bool __result, ref bool __state)
			{
				if (ProtectiveWards.wardAccessProtectPortals.Value == ProtectiveWards.WardPortalAccessMode.AllowAll)
				{
					return true;
				}
				if (hold)
				{
					return true;
				}
				if (BlockProtectedInteraction((Component)(object)__instance, human, ref __result))
				{
					return false;
				}
				StartPrivateAreaCheckBypass((Component)(object)__instance, human, ref __state);
				return true;
			}

			private static void Finalizer(bool __state)
			{
				StopPrivateAreaCheckBypass(__state);
			}
		}

		[HarmonyPatch(typeof(TeleportWorld), "SetText")]
		public static class TeleportWorld_SetText_PreventUnauthorizedAccess
		{
			private static bool Prefix(TeleportWorld __instance)
			{
				if (ProtectiveWards.wardAccessProtectPortals.Value == ProtectiveWards.WardPortalAccessMode.AllowAll)
				{
					return true;
				}
				Player localPlayer = Player.m_localPlayer;
				if ((Object)(object)localPlayer == (Object)null)
				{
					return true;
				}
				return !ProtectiveWards.BlockUnauthorizedWardInteraction((Component)(object)__instance, (Humanoid)(object)localPlayer);
			}
		}

		[HarmonyPatch(typeof(TeleportWorldTrigger), "OnTriggerEnter")]
		public static class TeleportWorldTrigger_OnTriggerEnter_PreventUnauthorizedTargetAccess
		{
			private static bool Prefix(TeleportWorldTrigger __instance, Collider colliderIn)
			{
				if (ProtectiveWards.wardAccessProtectPortals.Value != ProtectiveWards.WardPortalAccessMode.BlockAll)
				{
					return true;
				}
				if ((Object)(object)__instance == (Object)null || (Object)(object)__instance.m_teleportWorld == (Object)null || (Object)(object)colliderIn == (Object)null)
				{
					return true;
				}
				Player component = ((Component)colliderIn).GetComponent<Player>();
				if ((Object)(object)component == (Object)null || (Object)(object)Player.m_localPlayer != (Object)(object)component)
				{
					return true;
				}
				if (ProtectiveWards.BlockUnauthorizedWardInteraction((Component)(object)__instance.m_teleportWorld, (Humanoid)(object)component))
				{
					return false;
				}
				if (TeleportTargetAccessCheckStarted(__instance.m_teleportWorld, component))
				{
					return false;
				}
				return true;
			}
		}

		[HarmonyPatch(typeof(CookingStation), "Interact")]
		public static class CookingStation_Interact_PreventUnauthorizedAccess
		{
			private static bool Prefix(CookingStation __instance, Humanoid user, ref bool __result)
			{
				if (!ProtectiveWards.wardAccessProtectProductionStations.Value)
				{
					return true;
				}
				if (!BlockProtectedInteraction((Component)(object)__instance, user, ref __result))
				{
					return true;
				}
				return false;
			}
		}

		[HarmonyPatch(typeof(CookingStation), "UseItem")]
		public static class CookingStation_UseItem_PreventUnauthorizedAccess
		{
			private static bool Prefix(CookingStation __instance, Humanoid user, ref bool __result)
			{
				if (!ProtectiveWards.wardAccessProtectProductionStations.Value)
				{
					return true;
				}
				if (!BlockProtectedInteraction((Component)(object)__instance, user, ref __result))
				{
					return true;
				}
				return false;
			}
		}

		[HarmonyPatch(typeof(CookingStation), "OnAddFuelSwitch")]
		public static class CookingStation_OnAddFuelSwitch_PreventUnauthorizedAccess
		{
			private static bool Prefix(CookingStation __instance, Humanoid user, ref bool __result)
			{
				if (!ProtectiveWards.wardAccessProtectProductionStations.Value)
				{
					return true;
				}
				if (!BlockProtectedInteraction((Component)(object)__instance, user, ref __result))
				{
					return true;
				}
				return false;
			}
		}

		[HarmonyPatch(typeof(CookingStation), "OnAddFoodSwitch")]
		public static class CookingStation_OnAddFoodSwitch_PreventUnauthorizedAccess
		{
			private static bool Prefix(CookingStation __instance, Humanoid user, ref bool __result)
			{
				if (!ProtectiveWards.wardAccessProtectProductionStations.Value)
				{
					return true;
				}
				if (!BlockProtectedInteraction((Component)(object)__instance, user, ref __result))
				{
					return true;
				}
				return false;
			}
		}

		[HarmonyPatch(typeof(Smelter), "OnAddOre")]
		public static class Smelter_OnAddOre_PreventUnauthorizedAccess
		{
			private static bool Prefix(Smelter __instance, Humanoid user, ref bool __result)
			{
				if (!ProtectiveWards.wardAccessProtectProductionStations.Value)
				{
					return true;
				}
				if (!BlockProtectedInteraction((Component)(object)__instance, user, ref __result))
				{
					return true;
				}
				return false;
			}
		}

		[HarmonyPatch(typeof(Smelter), "OnEmpty")]
		public static class Smelter_OnEmpty_PreventUnauthorizedAccess
		{
			private static bool Prefix(Smelter __instance, Humanoid user, ref bool __result)
			{
				if (!ProtectiveWards.wardAccessProtectProductionStations.Value)
				{
					return true;
				}
				if (!BlockProtectedInteraction((Component)(object)__instance, user, ref __result))
				{
					return true;
				}
				return false;
			}
		}

		[HarmonyPatch(typeof(Smelter), "OnAddFuel")]
		public static class Smelter_OnAddFuel_PreventUnauthorizedAccess
		{
			private static bool Prefix(Smelter __instance, Humanoid user, ref bool __result)
			{
				if (!ProtectiveWards.wardAccessProtectProductionStations.Value)
				{
					return true;
				}
				if (!BlockProtectedInteraction((Component)(object)__instance, user, ref __result))
				{
					return true;
				}
				return false;
			}
		}

		[HarmonyPatch(typeof(Fermenter), "Interact")]
		public static class Fermenter_Interact_PreventUnauthorizedAccess
		{
			private static bool Prefix(Fermenter __instance, Humanoid user, ref bool __result, ref bool __state)
			{
				if (!ProtectiveWards.wardAccessProtectProductionStations.Value)
				{
					return true;
				}
				if (BlockProtectedInteraction((Component)(object)__instance, user, ref __result))
				{
					return false;
				}
				StartPrivateAreaCheckBypass((Component)(object)__instance, user, ref __state);
				return true;
			}

			private static void Finalizer(bool __state)
			{
				StopPrivateAreaCheckBypass(__state);
			}
		}

		[HarmonyPatch(typeof(Fermenter), "UseItem")]
		public static class Fermenter_UseItem_PreventUnauthorizedAccess
		{
			private static bool Prefix(Fermenter __instance, Humanoid user, ref bool __result, ref bool __state)
			{
				if (!ProtectiveWards.wardAccessProtectProductionStations.Value)
				{
					return true;
				}
				if (BlockProtectedInteraction((Component)(object)__instance, user, ref __result))
				{
					return false;
				}
				StartPrivateAreaCheckBypass((Component)(object)__instance, user, ref __state);
				return true;
			}

			private static void Finalizer(bool __state)
			{
				StopPrivateAreaCheckBypass(__state);
			}
		}

		[HarmonyPatch(typeof(Beehive), "Interact")]
		public static class Beehive_Interact_PreventUnauthorizedAccess
		{
			private static bool Prefix(Beehive __instance, Humanoid character, ref bool __result, ref bool __state)
			{
				if (!ProtectiveWards.wardAccessProtectProductionStations.Value)
				{
					return true;
				}
				if (BlockProtectedInteraction((Component)(object)__instance, character, ref __result))
				{
					return false;
				}
				StartPrivateAreaCheckBypass((Component)(object)__instance, character, ref __state);
				return true;
			}

			private static void Finalizer(bool __state)
			{
				StopPrivateAreaCheckBypass(__state);
			}
		}

		[HarmonyPatch(typeof(SapCollector), "Interact")]
		public static class SapCollector_Interact_PreventUnauthorizedAccess
		{
			private static bool Prefix(SapCollector __instance, Humanoid character, ref bool __result, ref bool __state)
			{
				if (!ProtectiveWards.wardAccessProtectProductionStations.Value)
				{
					return true;
				}
				if (BlockProtectedInteraction((Component)(object)__instance, character, ref __result))
				{
					return false;
				}
				StartPrivateAreaCheckBypass((Component)(object)__instance, character, ref __state);
				return true;
			}

			private static void Finalizer(bool __state)
			{
				StopPrivateAreaCheckBypass(__state);
			}
		}

		[HarmonyPatch(typeof(ItemStand), "Interact")]
		public static class ItemStand_Interact_PreventUnauthorizedAccess
		{
			private static bool Prefix(ItemStand __instance, Humanoid user, bool hold, bool alt, ref bool __result, ref bool __state)
			{
				if (!ProtectiveWards.wardAccessProtectItemStands.Value)
				{
					return true;
				}
				if (!IsProtectedItemStandInteraction(__instance, hold, alt))
				{
					return true;
				}
				if (BlockProtectedInteraction((Component)(object)__instance, user, ref __result))
				{
					return false;
				}
				StartPrivateAreaCheckBypass((Component)(object)__instance, user, ref __state);
				return true;
			}

			private static void Finalizer(bool __state)
			{
				StopPrivateAreaCheckBypass(__state);
			}

			private static bool IsProtectedItemStandInteraction(ItemStand itemStand, bool hold, bool alt)
			{
				if ((Object)(object)itemStand == (Object)null)
				{
					return false;
				}
				if (!itemStand.HaveAttachment())
				{
					return itemStand.m_autoAttach && itemStand.m_supportedItems.Count == 1;
				}
				if (hold && itemStand.m_canBeRemoved)
				{
					return true;
				}
				return alt && (Object)(object)itemStand.m_visualItemDrop != (Object)null && itemStand.m_orientationSettings.Count > 1;
			}
		}

		[HarmonyPatch(typeof(ItemStand), "UseItem")]
		public static class ItemStand_UseItem_PreventUnauthorizedAccess
		{
			private static bool Prefix(ItemStand __instance, Humanoid user, ItemData item, ref bool __result)
			{
				if (!ProtectiveWards.wardAccessProtectItemStands.Value)
				{
					return true;
				}
				if (item == null || __instance.HaveAttachment() || !__instance.CanAttach(item))
				{
					return true;
				}
				if (!BlockProtectedInteraction((Component)(object)__instance, user, ref __result))
				{
					return true;
				}
				return false;
			}
		}

		[HarmonyPatch(typeof(Switch), "Interact")]
		public static class Switch_Interact_PreventUnauthorizedExplicitAccess
		{
			private static bool Prefix(Switch __instance, Humanoid character, ref bool __result, ref bool __state)
			{
				Component protectedSwitchTarget = GetProtectedSwitchTarget(__instance);
				if ((Object)(object)protectedSwitchTarget == (Object)null)
				{
					return true;
				}
				if (BlockProtectedInteraction(protectedSwitchTarget, character, ref __result))
				{
					return false;
				}
				StartPrivateAreaCheckBypass(protectedSwitchTarget, character, ref __state);
				return true;
			}

			private static void Finalizer(bool __state)
			{
				StopPrivateAreaCheckBypass(__state);
			}
		}

		[HarmonyPatch(typeof(Switch), "UseItem")]
		public static class Switch_UseItem_PreventUnauthorizedExplicitAccess
		{
			private static bool Prefix(Switch __instance, Humanoid user, ref bool __result, ref bool __state)
			{
				Component protectedSwitchTarget = GetProtectedSwitchTarget(__instance);
				if ((Object)(object)protectedSwitchTarget == (Object)null)
				{
					return true;
				}
				if (BlockProtectedInteraction(protectedSwitchTarget, user, ref __result))
				{
					return false;
				}
				StartPrivateAreaCheckBypass(protectedSwitchTarget, user, ref __state);
				return true;
			}

			private static void Finalizer(bool __state)
			{
				StopPrivateAreaCheckBypass(__state);
			}
		}

		[HarmonyPatch(typeof(ArmorStand), "UseItem")]
		public static class ArmorStand_UseItem_PreventUnauthorizedAccess
		{
			private static bool Prefix(ArmorStand __instance, Humanoid user, ref bool __result, ref bool __state)
			{
				if (!ProtectiveWards.wardAccessProtectItemStands.Value)
				{
					return true;
				}
				if (BlockProtectedInteraction((Component)(object)__instance, user, ref __result))
				{
					return false;
				}
				StartPrivateAreaCheckBypass((Component)(object)__instance, user, ref __state);
				return true;
			}

			private static void Finalizer(bool __state)
			{
				StopPrivateAreaCheckBypass(__state);
			}
		}

		[HarmonyPatch(typeof(MapTable), "OnRead", new Type[]
		{
			typeof(Switch),
			typeof(Humanoid),
			typeof(ItemData),
			typeof(bool)
		})]
		public static class MapTable_OnRead_PreventUnauthorizedAccess
		{
			private static bool Prefix(MapTable __instance, Humanoid user)
			{
				if (!ProtectiveWards.wardAccessProtectMapTables.Value)
				{
					return true;
				}
				return !ShouldBlockProtectedInteraction((Component)(object)__instance, user);
			}
		}

		[HarmonyPatch(typeof(MapTable), "OnWrite")]
		public static class MapTable_OnWrite_PreventUnauthorizedAccess
		{
			private static bool Prefix(MapTable __instance, Humanoid user)
			{
				if (!ProtectiveWards.wardAccessProtectMapTables.Value)
				{
					return true;
				}
				return !ShouldBlockProtectedInteraction((Component)(object)__instance, user);
			}
		}

		[HarmonyPatch(typeof(Fireplace), "Interact")]
		public static class Fireplace_Interact_PreventUnauthorizedAccess
		{
			private static bool Prefix(Fireplace __instance, Humanoid user, ref bool __result)
			{
				if (!ProtectiveWards.wardAccessProtectFireplaces.Value)
				{
					return true;
				}
				if (!BlockProtectedInteraction((Component)(object)__instance, user, ref __result))
				{
					return true;
				}
				return false;
			}
		}

		[HarmonyPatch(typeof(Fireplace), "UseItem")]
		public static class Fireplace_UseItem_PreventUnauthorizedAccess
		{
			private static bool Prefix(Fireplace __instance, Humanoid user, ref bool __result)
			{
				if (!ProtectiveWards.wardAccessProtectFireplaces.Value)
				{
					return true;
				}
				if (!BlockProtectedInteraction((Component)(object)__instance, user, ref __result))
				{
					return true;
				}
				return false;
			}
		}

		[HarmonyPatch(typeof(Turret), "Interact")]
		public static class Turret_Interact_PreventUnauthorizedAccess
		{
			private static bool Prefix(Turret __instance, Humanoid character, ref bool __result)
			{
				if (!ProtectiveWards.wardAccessProtectTurrets.Value)
				{
					return true;
				}
				if (!BlockProtectedInteraction((Component)(object)__instance, character, ref __result))
				{
					return true;
				}
				return false;
			}
		}

		[HarmonyPatch(typeof(Turret), "UseItem")]
		public static class Turret_UseItem_PreventUnauthorizedAccess
		{
			private static bool Prefix(Turret __instance, Humanoid user, ref bool __result)
			{
				if (!ProtectiveWards.wardAccessProtectTurrets.Value)
				{
					return true;
				}
				if (!BlockProtectedInteraction((Component)(object)__instance, user, ref __result))
				{
					return true;
				}
				return false;
			}
		}

		[HarmonyPatch(typeof(CraftingStation), "Interact")]
		public static class CraftingStation_Interact_PreventUnauthorizedAccess
		{
			private static bool Prefix(CraftingStation __instance, Humanoid user, ref bool __result)
			{
				if (!ProtectiveWards.wardAccessProtectCraftingStations.Value)
				{
					return true;
				}
				if (!BlockProtectedInteraction((Component)(object)__instance, user, ref __result))
				{
					return true;
				}
				return false;
			}
		}

		[HarmonyPatch(typeof(Player), "AddKnownStation")]
		public static class Player_AddKnownStation_PreventUnauthorizedStationDiscovery
		{
			[HarmonyPriority(800)]
			private static bool Prefix(Player __instance, CraftingStation station)
			{
				if (!ProtectiveWards.wardAccessProtectCraftingStations.Value)
				{
					return true;
				}
				if ((Object)(object)__instance == (Object)null || (Object)(object)station == (Object)null)
				{
					return true;
				}
				int level = station.GetLevel(true);
				if (__instance.m_knownStations.TryGetValue(station.m_name, out var value) && value >= level)
				{
					return true;
				}
				return !ShouldSilentlyBlockProtectedInteraction((Component)(object)station, (Humanoid)(object)__instance);
			}
		}

		[HarmonyPatch(typeof(Bed), "Interact")]
		public static class Bed_Interact_PreventUnauthorizedSleep
		{
			[HarmonyPriority(800)]
			private static bool Prefix(Bed __instance, Humanoid human, ref bool __result)
			{
				if (!ProtectiveWards.wardAccessProtectBeds.Value)
				{
					return true;
				}
				if (!BlockProtectedInteraction((Component)(object)__instance, human, ref __result))
				{
					return true;
				}
				return false;
			}
		}

		[HarmonyPatch(typeof(Catapult), "OnLegUse")]
		public static class Catapult_OnLegUse_PreventUnauthorizedAccess
		{
			private static bool Prefix(Catapult __instance, Humanoid user)
			{
				if (!ProtectiveWards.wardAccessProtectCatapults.Value)
				{
					return true;
				}
				return !ShouldBlockProtectedInteraction((Component)(object)__instance, user);
			}
		}

		[HarmonyPatch(typeof(Catapult), "OnLoadPointUse")]
		public static class Catapult_OnLoadPointUse_PreventUnauthorizedAccess
		{
			private static bool Prefix(Catapult __instance, Humanoid user)
			{
				if (!ProtectiveWards.wardAccessProtectCatapults.Value)
				{
					return true;
				}
				return !ShouldBlockProtectedInteraction((Component)(object)__instance, user);
			}
		}

		[HarmonyPatch(typeof(ArcheryTarget), "Interact")]
		public static class ArcheryTarget_Interact_PreventUnauthorizedAccess
		{
			private static bool Prefix(ArcheryTarget __instance, Humanoid user, ref bool __result)
			{
				if (!ProtectiveWards.wardAccessProtectArcheryTargets.Value)
				{
					return true;
				}
				if (!BlockProtectedInteraction((Component)(object)__instance, user, ref __result))
				{
					return true;
				}
				return false;
			}
		}

		[HarmonyPatch(typeof(Barber), "Interact")]
		public static class Barber_Interact_PreventUnauthorizedAccess
		{
			private static bool Prefix(Barber __instance, Humanoid human, ref bool __result)
			{
				if (!ProtectiveWards.wardAccessProtectBarbers.Value)
				{
					return true;
				}
				if (!BlockProtectedInteraction((Component)(object)__instance, human, ref __result))
				{
					return true;
				}
				return false;
			}
		}

		[HarmonyPatch(typeof(PrivateArea), "Interact")]
		public static class PrivateArea_Interact_PreventInactiveWardAccessInsideOtherWard
		{
			[HarmonyPriority(800)]
			private static bool Prefix(PrivateArea __instance, Humanoid human, ref bool __result)
			{
				if (!ProtectiveWards.wardAccessProtectInactiveWards.Value)
				{
					return true;
				}
				if ((Object)(object)__instance == (Object)null || __instance.IsEnabled())
				{
					return true;
				}
				if (!BlockProtectedInteraction((Component)(object)__instance, human, ref __result))
				{
					return true;
				}
				return false;
			}
		}

		[HarmonyPatch(typeof(ZoneSystem), "Start")]
		public static class ZoneSystem_Start_RegisterSaddleUserRPC
		{
			private static void Postfix()
			{
				RegisterSaddleUserRPC();
				RegisterTeleportAccessRPC();
			}
		}

		[HarmonyPatch(typeof(ZoneSystem), "OnDestroy")]
		public static class ZoneSystem_OnDestroy_ResetFullProtectionRPCs
		{
			private static void Postfix()
			{
				ResetRPCRegistration();
			}
		}

		[HarmonyPatch(typeof(Sadle), "RPC_RequestRespons")]
		public static class Sadle_RPC_RequestRespons_RecordLastUser
		{
			private static void Postfix(Sadle __instance, bool granted)
			{
				if (granted && !((Object)(object)Player.m_localPlayer == (Object)null))
				{
					long playerID = Player.m_localPlayer.GetPlayerID();
					if (playerID != 0)
					{
						SetLastSaddleUserLocal(__instance, playerID);
						RequestSetLastSaddleUser(__instance, playerID);
					}
				}
			}
		}

		[HarmonyPatch(typeof(ShipControlls), "RPC_RequestRespons")]
		public static class ShipControlls_RPC_RequestRespons_RecordLastController
		{
			private static void Postfix(ShipControlls __instance, bool granted)
			{
				if (granted && !((Object)(object)__instance?.m_ship == (Object)null) && !((Object)(object)Player.m_localPlayer == (Object)null))
				{
					long playerID = Player.m_localPlayer.GetPlayerID();
					if (playerID != 0)
					{
						ZNetView componentZNetView = ((Component)(object)__instance.m_ship).GetComponentZNetView();
						SetLastVehicleControllerLocal(componentZNetView, playerID);
						RequestSetLastVehicleController(componentZNetView, playerID);
					}
				}
			}
		}

		[HarmonyPatch(typeof(Vagon), "AttachTo")]
		public static class Vagon_AttachTo_RecordLastController
		{
			private static void Postfix(Vagon __instance)
			{
				//IL_002a: Unknown result type (might be due to invalid IL or missing references)
				if ((Object)(object)__instance == (Object)null)
				{
					return;
				}
				GameObject attachedObject = __instance.m_attachedObject;
				Player val = ((attachedObject != null) ? attachedObject.GetComponent<Player>() : null);
				if (val == null)
				{
					val = Player.GetClosestPlayer(((Component)__instance).transform.position, 10f);
				}
				if (!((Object)(object)val == (Object)null))
				{
					long playerID = val.GetPlayerID();
					if (playerID != 0)
					{
						ZNetView componentZNetView = ((Component)(object)__instance).GetComponentZNetView();
						SetLastVehicleControllerLocal(componentZNetView, playerID);
						RequestSetLastVehicleController(componentZNetView, playerID);
					}
				}
			}
		}

		public static class Interactable_PreventUnauthorizedAccess
		{
			private static readonly HashSet<Type> ExcludedInteractableTypes = new HashSet<Type>
			{
				typeof(Container),
				typeof(Door),
				typeof(Pickable),
				typeof(PrivateArea),
				typeof(Ladder),
				typeof(ShipControlls),
				typeof(Sadle),
				typeof(Switch),
				typeof(Chair),
				typeof(TombStone),
				typeof(TeleportWorld),
				typeof(Vagon),
				typeof(Feast),
				typeof(ShieldGenerator),
				typeof(Tameable),
				typeof(Pet),
				typeof(Petable),
				typeof(ItemStand),
				typeof(CookingStation),
				typeof(Fermenter),
				typeof(Beehive),
				typeof(SapCollector),
				typeof(ItemDrop),
				typeof(PickableItem),
				typeof(Fish),
				typeof(RopeAttachment),
				typeof(Teleport),
				typeof(MapTable),
				typeof(Fireplace),
				typeof(Turret),
				typeof(CraftingStation),
				typeof(Bed),
				typeof(Catapult),
				typeof(ArcheryTarget),
				typeof(Barber)
			};

			internal static void ExcludeType(Type type)
			{
				if (type != null)
				{
					ExcludedInteractableTypes.Add(type);
				}
			}

			internal static IEnumerable<MethodBase> TargetMethods()
			{
				HashSet<MethodBase> methods = new HashSet<MethodBase>();
				foreach (Type type in GetLoadedInteractableTypes())
				{
					MethodInfo interact = AccessTools.Method(type, "Interact", new Type[3]
					{
						typeof(Humanoid),
						typeof(bool),
						typeof(bool)
					}, (Type[])null);
					if (ShouldPatchInteractableMethod(interact) && methods.Add(interact))
					{
						yield return interact;
					}
					MethodInfo useItem = AccessTools.Method(type, "UseItem", new Type[2]
					{
						typeof(Humanoid),
						typeof(ItemData)
					}, (Type[])null);
					if (ShouldPatchInteractableMethod(useItem) && methods.Add(useItem))
					{
						yield return useItem;
					}
				}
			}

			private static IEnumerable<Type> GetLoadedInteractableTypes()
			{
				Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
				foreach (Assembly assembly in assemblies)
				{
					if (assembly == null || assembly.IsDynamic)
					{
						continue;
					}
					Type[] types;
					try
					{
						types = assembly.GetTypes();
					}
					catch (ReflectionTypeLoadException ex)
					{
						ReflectionTypeLoadException ex2 = ex;
						types = ex2.Types;
					}
					catch
					{
						continue;
					}
					Type[] array = types;
					foreach (Type type in array)
					{
						if (!(type == null) && !(type == typeof(Interactable)) && !type.IsAbstract && !type.ContainsGenericParameters && !ExcludedInteractableTypes.Contains(type) && SafeIsInteractableType(type))
						{
							yield return type;
						}
					}
				}
			}

			private static bool SafeIsInteractableType(Type type)
			{
				try
				{
					return typeof(Interactable).IsAssignableFrom(type);
				}
				catch (Exception ex)
				{
					ProtectiveWards.LogInfo("Skipping interactable type scan for " + (type?.FullName ?? "unknown") + ": " + ex.GetType().Name);
					return false;
				}
			}

			private static bool ShouldPatchInteractableMethod(MethodInfo method)
			{
				if (method == null || method.DeclaringType == null || method.DeclaringType == typeof(Interactable) || method.IsAbstract || method.IsVirtual || ExcludedInteractableTypes.Contains(method.DeclaringType))
				{
					return false;
				}
				try
				{
					return method.GetMethodBody() != null;
				}
				catch (Exception ex)
				{
					ProtectiveWards.LogInfo("Skipping interactable method patch for " + method.DeclaringType.FullName + "." + method.Name + ": " + ex.GetType().Name);
					return false;
				}
			}

			public static bool Prefix(object __instance, Humanoid __0, ref bool __result)
			{
				if (!ProtectiveWards.wardAccessProtectInteractables.Value)
				{
					return true;
				}
				if (!(__0 is Player))
				{
					return true;
				}
				Component val = (Component)((__instance is Component) ? __instance : null);
				if (val == null)
				{
					return true;
				}
				if (!ProtectiveWards.BlockUnauthorizedWardInteraction(val, __0))
				{
					return true;
				}
				__result = true;
				return false;
			}
		}

		[HarmonyPatch(typeof(Trap), "Interact")]
		public static class Trap_Interact_PreventUnauthorizedAccess
		{
			private static bool Prefix(Trap __instance, Humanoid character, ref bool __result)
			{
				if (!ProtectiveWards.wardTrapProtection.Value)
				{
					return true;
				}
				if (!BlockProtectedInteraction((Component)(object)__instance, character, ref __result))
				{
					return true;
				}
				return false;
			}
		}

		[HarmonyPatch(typeof(Trap), "OnTriggerEnter")]
		private static class Trap_OnTriggerEnter_TrapProtection
		{
			private static bool Prefix(Trap __instance, Collider collider)
			{
				//IL_0037: Unknown result type (might be due to invalid IL or missing references)
				//IL_0057: Unknown result type (might be due to invalid IL or missing references)
				if (!ProtectiveWards.wardTrapProtection.Value)
				{
					return true;
				}
				Player componentInParent = ((Component)collider).GetComponentInParent<Player>();
				if ((Object)(object)componentInParent == (Object)null)
				{
					return true;
				}
				if (!ProtectiveWards.InsideEnabledPlayersArea(((Component)__instance).transform.position, out var _, checkCache: true))
				{
					return true;
				}
				if (BackgroundProtection.IsBackgroundProtectionActiveAt(((Component)__instance).transform.position, out var ward) && ward != null && !ward.HasConnectedWardAccess(componentInParent.GetPlayerID(), ProtectiveWards.wardBackgroundConnectedAccessMode.Value, IsActiveWardZdo))
				{
					return true;
				}
				return false;
			}
		}

		[HarmonyPatch(typeof(Destructible), "Damage")]
		public static class Destructible_Damage_PlantProtection
		{
			private static void ModifyHitDamage(HitData hit, float value)
			{
				((DamageTypes)(ref hit.m_damage)).Modify(Math.Max(value, 0f));
			}

			private static void Prefix(Destructible __instance, HitData hit)
			{
				//IL_0052: Unknown result type (might be due to invalid IL or missing references)
				//IL_0058: Invalid comparison between Unknown and I4
				//IL_0096: Unknown result type (might be due to invalid IL or missing references)
				if (!ProtectiveWards.wardPlantProtection.Value || (Object)(object)__instance.m_nview == (Object)null || !__instance.m_nview.IsValid() || !__instance.m_nview.IsOwner() || __instance.m_destroyed || (int)__instance.GetDestructibleType() != 1 || __instance.m_health != 1f || hit == null || !hit.HaveAttacker() || !ProtectiveWards.InsideEnabledPlayersArea(((Component)__instance).transform.position, out var area, checkCache: true))
				{
					return;
				}
				Pickable val = default(Pickable);
				if ((Object)(object)((Component)__instance).GetComponent<Plant>() != (Object)null)
				{
					ModifyHitDamage(hit, 0f);
					area.FlashShield(false);
				}
				else if (((Component)__instance).TryGetComponent<Pickable>(ref val))
				{
					GameObject itemPrefab = val.m_itemPrefab;
					SharedData val2 = ((itemPrefab == null) ? null : itemPrefab.GetComponent<ItemDrop>()?.m_itemData.m_shared);
					string item = ((itemPrefab == null) ? null : ((Object)itemPrefab).name?.ToLower());
					if (val2 != null && (ProtectiveWards._wardPlantProtectionList.Contains(val2.m_name.ToLower()) || ProtectiveWards._wardPlantProtectionList.Contains(item)))
					{
						ModifyHitDamage(hit, 0f);
						area.FlashShield(false);
					}
				}
			}
		}

		private const string RPC_SetLastSaddleUser = "PW_SetLastSaddleUser";

		private const string RPC_SetLastVehicleController = "PW_SetLastVehicleController";

		private const string RPC_CheckTeleportTargetAccess = "PW_CheckTeleportTargetAccess";

		private const string RPC_TeleportTargetAccessResponse = "PW_TeleportTargetAccessResponse";

		private const float saddleUserRecordMaxDistance = 10f;

		private const float vehicleControllerRecordMaxDistance = 10f;

		private const float portalSourceValidationDistance = 8f;

		private static int s_privateAreaCheckBypassDepth;

		private static bool s_saddleRpcRegistered;

		private static bool s_teleportAccessRpcRegistered;

		private static bool s_interactablePatchesApplied;

		private static Player s_autoPickupPlayer;

		internal static bool BlockProtectedInteraction(Component component, Humanoid human, ref bool result)
		{
			if (!ProtectiveWards.BlockUnauthorizedWardInteraction(component, human))
			{
				return false;
			}
			result = true;
			return true;
		}

		private static bool ShouldBlockProtectedInteraction(Component component, Humanoid human)
		{
			return (Object)(object)human != (Object)null && ProtectiveWards.BlockUnauthorizedWardInteraction(component, human);
		}

		private static bool ShouldSilentlyBlockProtectedInteraction(Component component, Humanoid human)
		{
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)component == (Object)null))
			{
				Player val = (Player)(object)((human is Player) ? human : null);
				if (val != null)
				{
					foreach (PrivateArea allArea in PrivateArea.m_allAreas)
					{
						if (!ProtectiveWards.IsActivePlayerWard(allArea) || !ProtectiveWards.IsPointInsideWardArea(allArea, component.transform.position) || ProtectiveWards.HasAccessToWardOrConnectedWard(allArea, val) || ProtectiveWards.IsObjectOwnedByPlayerWithWardAccess(component, val))
						{
							continue;
						}
						return true;
					}
					return false;
				}
			}
			return false;
		}

		private static void StartPrivateAreaCheckBypass(Component component, Humanoid human, ref bool state)
		{
			if (ProtectiveWards.ShouldBypassVanillaPrivateAreaCheck(component, human))
			{
				s_privateAreaCheckBypassDepth++;
				state = true;
			}
		}

		private static void StopPrivateAreaCheckBypass(bool state)
		{
			if (state)
			{
				s_privateAreaCheckBypassDepth = Math.Max(0, s_privateAreaCheckBypassDepth - 1);
			}
		}

		private static void RegisterTeleportAccessRPC()
		{
			if (!s_teleportAccessRpcRegistered && ZRoutedRpc.instance != null)
			{
				if ((Object)(object)ZNet.instance != (Object)null && ZNet.instance.IsServer())
				{
					ZRoutedRpc.instance.Register<ZPackage>("PW_CheckTeleportTargetAccess", (Action<long, ZPackage>)RPC_CheckTeleportTargetAccessServer);
				}
				ZRoutedRpc.instance.Register<ZPackage>("PW_TeleportTargetAccessResponse", (Action<long, ZPackage>)RPC_TeleportTargetAccessResponseClient);
				s_teleportAccessRpcRegistered = true;
			}
		}

		private static void ResetRPCRegistration()
		{
			s_saddleRpcRegistered = false;
			s_teleportAccessRpcRegistered = false;
		}

		internal static void PatchLoadedInteractables(Harmony harmony)
		{
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Expected O, but got Unknown
			if (s_interactablePatchesApplied || harmony == null)
			{
				return;
			}
			MethodInfo methodInfo = AccessTools.Method(typeof(Interactable_PreventUnauthorizedAccess), "Prefix", (Type[])null, (Type[])null);
			if (methodInfo == null)
			{
				return;
			}
			foreach (MethodBase item in Interactable_PreventUnauthorizedAccess.TargetMethods())
			{
				harmony.Patch(item, new HarmonyMethod(methodInfo), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			}
			s_interactablePatchesApplied = true;
		}

		internal static void ResetDynamicPatchState()
		{
			s_interactablePatchesApplied = false;
		}

		internal static void ExcludeInteractableType(Type type)
		{
			Interactable_PreventUnauthorizedAccess.ExcludeType(type);
		}

		private static bool TeleportTargetAccessCheckStarted(TeleportWorld teleport, Player player)
		{
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Expected O, but got Unknown
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Expected O, but got Unknown
			if (!((Object)(object)player == (Object)null) && teleport != null && teleport.TargetFound())
			{
				ZNetView nview = teleport.m_nview;
				if (nview != null && nview.IsValid())
				{
					ZDO zDO = teleport.m_nview.GetZDO();
					if (zDO == null)
					{
						return false;
					}
					ZPackage val = new ZPackage();
					val.Write(zDO.m_uid);
					val.Write(player.GetPlayerID());
					if ((Object)(object)ZNet.instance != (Object)null && ZNet.instance.IsServer())
					{
						RPC_CheckTeleportTargetAccessServer(0L, new ZPackage(val.GetArray()));
					}
					else
					{
						if (ZRoutedRpc.instance == null)
						{
							return false;
						}
						ZRoutedRpc.instance.InvokeRoutedRPC("PW_CheckTeleportTargetAccess", new object[1] { val });
					}
					return true;
				}
			}
			return false;
		}

		private static void RPC_CheckTeleportTargetAccessServer(long sender, ZPackage package)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			ZDOID val = package.ReadZDOID();
			long claimedPlayerID = package.ReadLong();
			if (ZDOMan.instance == null || !ProtectiveWards.TryGetRoutedPlayer(sender, claimedPlayerID, out var player))
			{
				return;
			}
			ZDO zDO = ZDOMan.instance.GetZDO(val);
			if (zDO == null)
			{
				SendTeleportTargetAccessResponse(sender, val, granted: false, "");
				return;
			}
			if (!IsSourcePortalUsableByRequester(zDO, player, out var blockingOwnerName))
			{
				SendTeleportTargetAccessResponse(sender, val, granted: false, blockingOwnerName);
				return;
			}
			ZDOID connectionZDOID = zDO.GetConnectionZDOID((ConnectionType)1);
			ZDO zDO2 = ZDOMan.instance.GetZDO(connectionZDOID);
			if (zDO2 == null)
			{
				SendTeleportTargetAccessResponse(sender, val, granted: false, "");
				return;
			}
			bool granted = IsTeleportTargetAccessibleToPlayer(zDO2.GetPosition(), player.PlayerID, out blockingOwnerName);
			SendTeleportTargetAccessResponse(sender, val, granted, blockingOwnerName);
		}

		private static bool IsSourcePortalUsableByRequester(ZDO sourceZdo, ProtectiveWards.RoutedPlayerContext requester, out string blockingOwnerName)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: 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)
			blockingOwnerName = "";
			if (sourceZdo == null || sourceZdo.GetConnectionZDOID((ConnectionType)1) == ZDOID.None)
			{
				return false;
			}
			if (!requester.HasPosition)
			{
				return false;
			}
			float num = 8f;
			ZNetScene instance = ZNetScene.instance;
			object obj;
			if (instance == null)
			{
				obj = null;
			}
			else
			{
				GameObject obj2 = instance.FindInstance(sourceZdo.m_uid);
				obj = ((obj2 != null) ? obj2.GetComponent<TeleportWorld>() : null);
			}
			TeleportWorld val = (TeleportWorld)obj;
			if ((Object)(object)val != (Object)null)
			{
				num = Math.Max(num, val.m_activationRange + 2f);
			}
			if (Vector3.Distance(requester.Position, sourceZdo.GetPosition()) > num)
			{
				return false;
			}
			if (IsTeleportTargetAccessibleToPlayer(sourceZdo.GetPosition(), requester.PlayerID, out blockingOwnerName))
			{
				return true;
			}
			return sourceZdo.IsCreator(requester.PlayerID);
		}

		private static void SendTeleportTargetAccessResponse(long peerID, ZDOID sourceZdoID, bool granted, string blockingOwnerName)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Expected O, but got Unknown
			ZPackage val = new ZPackage();
			val.Write(sourceZdoID);
			val.Write(granted);
			val.Write(blockingOwnerName ?? "");
			if ((Object)(object)ZNet.instance != (Object)null && ZNet.instance.IsServer() && ZRoutedRpc.instance != null && peerID != 0)
			{
				ZRoutedRpc.instance.InvokeRoutedRPC(peerID, "PW_TeleportTargetAccessResponse", new object[1] { val });
			}
			else
			{
				RPC_TeleportTargetAccessResponseClient(0L, new ZPackage(val.GetArray()));
			}
		}

		private static void RPC_TeleportTargetAccessResponseClient(long sender, ZPackage package)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			ZDOID val = package.ReadZDOID();
			bool flag = package.ReadBool();
			string ownerName = package.ReadString();
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null || (Object)(object)ZNetScene.instance == (Object)null)
			{
				return;
			}
			GameObject val2 = ZNetScene.instance.FindInstance(val);
			TeleportWorld val3 = ((val2 != null) ? val2.GetComponent<TeleportWorld>() : null);
			if (!((Object)(object)val3 == (Object)null))
			{
				if (!flag)
				{
					((Character)localPlayer).Message((MessageType)2, ProtectiveWards.GetPrivateZoneDeniedMessage(ownerName), 0, (Sprite)null);
				}
				else
				{
					val3.Teleport(localPlayer);
				}
			}
		}

		private static bool IsTeleportTargetAccessibleToPlayer(Vector3 targetPoint, long playerID, out string blockingOwnerName)
		{
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			blockingOwnerName = "";
			if (playerID == 0)
			{
				return true;
			}
			ProtectiveWards.WardConnectedAccessMode mode = ProtectiveWards.wardAccessConnectedAccessMode?.Value ?? ProtectiveWards.WardConnectedAccessMode.Off;
			foreach (ZDO allWard in WardZdoUtils.GetAllWards())
			{
				if (!IsActiveWardZdo(allWard) || !ProtectiveWards.IsPointInsideWardArea(allWard, targetPoint) || allWard.HasConnectedWardAccess(playerID, mode, IsActiveWardZdo))
				{
					continue;
				}
				blockingOwnerName = ProtectiveWards.GetWardOwnerName(allWard);
				return false;
			}
			return true;
		}

		private static bool IsActiveWardZdo(ZDO zdo)
		{
			return zdo.IsWard() && zdo.GetBool(ZDOVars.s_enabled, false) && !zdo.GetBool(WardExpiration.s_expirationExpired, false);
		}

		private static void RegisterSaddleUserRPC()
		{
			if (!s_saddleRpcRegistered && ZRoutedRpc.instance != null)
			{
				if ((Object)(object)ZNet.instance != (Object)null && ZNet.instance.IsServer())
				{
					ZRoutedRpc.instance.Register<ZPackage>("PW_SetLastSaddleUser", (Action<long, ZPackage>)RPC_SetLastSaddleUserServer);
					ZRoutedRpc.instance.Register<ZPackage>("PW_SetLastVehicleController", (Action<long, ZPackage>)RPC_SetLastVehicleControllerServer);
				}
				s_saddleRpcRegistered = true;
			}
		}

		private static void RequestSetLastSaddleUser(Sadle sadle, long playerID)
		{
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Expected O, but got Unknown
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Expected O, but got Unknown
			ZNetView componentZNetView = ((Component)(object)sadle).GetComponentZNetView();
			ZDO val = (((Object)(object)componentZNetView != (Object)null && componentZNetView.IsValid()) ? componentZNetView.GetZDO() : null);
			if (val == null || playerID == 0)
			{
				return;
			}
			ZPackage val2 = new ZPackage();
			val2.Write(val.m_uid);
			val2.Write(playerID);
			if ((Object)(object)ZNet.instance != (Object)null && ZNet.instance.IsServer())
			{
				RPC_SetLastSaddleUserServer(0L, new ZPackage(val2.GetArray()));
				return;
			}
			ZRoutedRpc instance = ZRoutedRpc.instance;
			if (instance != null)
			{
				instance.InvokeRoutedRPC("PW_SetLastSaddleUser", new object[1] { val2 });
			}
		}

		private static void RPC_SetLastSaddleUserServer(long sender, ZPackage package)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			ZDOID val = package.ReadZDOID();
			long num = package.ReadLong();
			if (num == 0L || ZDOMan.instance == null || !ProtectiveWards.TryGetRoutedPlayer(sender, num, out var player))
			{
				return;
			}
			ZDO zDO = ZDOMan.instance.GetZDO(val);
			if (zDO != null)
			{
				long num2 = zDO.GetLong(ZDOVars.s_user, 0L);
				ZDOID characterID = player.CharacterID;
				if (num2 == ((ZDOID)(ref characterID)).UserID || (player.HasPosition && !(Vector3.Distance(player.Position, zDO.GetPosition()) > 10f)))
				{
					zDO.Set(ProtectiveWards.s_lastSaddleUser, player.PlayerID);
				}
			}
		}

		private static void SetLastSaddleUserLocal(Sadle sadle, long playerID)
		{
			if (!((Object)(object)sadle == (Object)null) && playerID != 0)
			{
				SetLastSaddleUserOnView(((Component)(object)sadle).GetComponentZNetView(), playerID);
				if ((Object)(object)sadle.m_character != (Object)null)
				{
					SetLastSaddleUserOnView(((Component)(object)sadle.m_character).GetComponentZNetView(), playerID);
				}
			}
		}

		private static void SetLastSaddleUserOnView(ZNetView nview, long playerID)
		{
			ZDO val = (((Object)(object)nview != (Object)null && nview.IsValid()) ? nview.GetZDO() : null);
			if (val != null && playerID != 0)
			{
				val.Set(ProtectiveWards.s_lastSaddleUser, playerID);
			}
		}

		private static void RequestSetLastVehicleController(ZNetView nview, long playerID)
		{
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Expected O, but got Unknown
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Expected O, but got Unknown
			ZDO val = (((Object)(object)nview != (Object)null && nview.IsValid()) ? nview.GetZDO() : null);
			if (val == null || playerID == 0)
			{
				return;
			}
			ZPackage val2 = new ZPackage();
			val2.Write(val.m_uid);
			val2.Write(playerID);
			if ((Object)(object)ZNet.instance != (Object)null && ZNet.instance.IsServer())
			{
				RPC_SetLastVehicleControllerServer(0L, new ZPackage(val2.GetArray()));
				return;
			}
			ZRoutedRpc instance = ZRoutedRpc.instance;
			if (instance != null)
			{
				instance.InvokeRoutedRPC("PW_SetLastVehicleController", new object[1] { val2 });
			}
		}

		private static void RPC_SetLastVehicleControllerServer(long sender, ZPackage package)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: 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_00fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			ZDOID val = package.ReadZDOID();
			long num = package.ReadLong();
			if (num == 0L || ZDOMan.instance == null || (Object)(object)ZNetScene.instance == (Object)null || !ProtectiveWards.TryGetRoutedPlayer(sender, num, out var player))
			{
				return;
			}
			ZDO zDO = ZDOMan.instance.GetZDO(val);
			if (zDO == null)
			{
				return;
			}
			GameObject val2 = ZNetScene.instance.FindInstance(val);
			if ((Object)(object)val2 == (Object)null)
			{
				return;
			}
			if ((Object)(object)val2.GetComponent<Ship>() != (Object)null)
			{
				if (zDO.GetLong(ZDOVars.s_user, 0L) != player.PlayerID && (!player.HasPosition || Vector3.Distance(player.Position, zDO.GetPosition()) > 10f))
				{
					return;
				}
			}
			else if (!((Object)(object)val2.GetComponent<Vagon>() != (Object)null) || !player.HasPosition || Vector3.Distance(player.Position, zDO.GetPosition()) > 10f)
			{
				return;
			}
			zDO.Set(ProtectiveWards.s_lastVehicleController, player.PlayerID);
		}

		private static void SetLastVehicleControllerLocal(ZNetView nview, long playerID)
		{
			ZDO val = (((Object)(object)nview != (Object)null && nview.IsValid()) ? nview.GetZDO() : null);
			if (val != null && playerID != 0)
			{
				val.Set(ProtectiveWards.s_lastVehicleController, playerID);
			}
		}

		private static Component GetProtectedSwitchTarget(Switch sw)
		{
			if ((Object)(object)sw == (Object)null)
			{
				return null;
			}
			ArmorStand componentInParent = ((Component)sw).GetComponentInParent<ArmorStand>();
			if ((Object)(object)componentInParent != (Object)null && ProtectiveWards.wardAccessProtectItemStands.Value)
			{
				return (Component)(object)componentInParent;
			}
			MapTable componentInParent2 = ((Component)sw).GetComponentInParent<MapTable>();
			if ((Object)(object)componentInParent2 != (Object)null && ProtectiveWards.wardAccessProtectMapTables.Value)
			{
				return (Component)(object)componentInParent2;
			}
			Catapult componentInParent3 = ((Component)sw).GetComponentInParent<Catapult>();
			if ((Object)(object)componentInParent3 != (Object)null && ProtectiveWards.wardAccessProtectCatapults.Value)
			{
				return (Component)(object)componentInParent3;
			}
			Barber componentInParent4 = ((Component)sw).GetComponentInParent<Barber>();
			if ((Object)(object)componentInParent4 != (Object)null && ProtectiveWards.wardAccessProtectBarbers.Value)
			{
				return (Component)(object)componentInParent4;
			}
			CraftingStation componentInParent5 = ((Component)sw).GetComponentInParent<CraftingStation>();
			if ((Object)(object)componentInParent5 != (Object)null && ProtectiveWards.wardAccessProtectCraftingStations.Value)
			{
				return (Component)(object)componentInParent5;
			}
			Fireplace componentInParent6 = ((Component)sw).GetComponentInParent<Fireplace>();
			if ((Object)(object)componentInParent6 != (Object)null && ProtectiveWards.wardAccessProtectFireplaces.Value)
			{
				return (Component)(object)componentInParent6;
			}
			Turret componentInParent7 = ((Component)sw).GetComponentInParent<Turret>();
			if ((Object)(object)componentInParent7 != (Object)null && ProtectiveWards.wardAccessProtectTurrets.Value)
			{
				return (Component)(object)componentInParent7;
			}
			if (ProtectiveWards.wardAccessProtectProductionStations.Value)
			{
				CookingStation componentInParent8 = ((Component)sw).GetComponentInParent<CookingStation>();
				if ((Object)(object)componentInParent8 != (Object)null)
				{
					return (Component)(object)componentInParent8;
				}
				Smelter componentInParent9 = ((Component)sw).GetComponentInParent<Smelter>();
				if ((Object)(object)componentInParent9 != (Object)null)
				{
					return (Component)(object)componentInParent9;
				}
				Fermenter componentInParent10 = ((Component)sw).GetComponentInParent<Fermenter>();
				if ((Object)(object)componentInParent10 != (Object)null)
				{
					return (Component)(object)componentInParent10;
				}
				Beehive componentInParent11 = ((Component)sw).GetComponentInParent<Beehive>();
				if ((Object)(object)componentInParent11 != (Object)null)
				{
					return (Component)(object)componentInParent11;
				}
				SapCollector componentInParent12 = ((Component)sw).GetComponentInParent<SapCollector>();
				if ((Object)(object)componentInParent12 != (Object)null)
				{
					return (Component)(object)componentInParent12;
				}
			}
			return null;
		}

		private static bool IsPlacedConsumable(ItemDrop itemDrop)
		{
			return IsConsumableItem(itemDrop) && itemDrop.IsPiece();
		}

		private static bool IsConsumableItem(ItemDrop itemDrop)
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Invalid comparison between Unknown and I4
			return (Object)(object)itemDrop != (Object)null && itemDrop.m_itemData != null && itemDrop.m_itemData.m_shared != null && (int)itemDrop.m_itemData.m_shared.m_itemType == 2;
		}

		private static bool ShouldBlockItemPickup(ItemDrop itemDrop, Humanoid character, bool silent = false)
		{
			if ((Object)(object)itemDrop == (Object)null || IsConsumableItem(itemDrop))
			{
				return false;
			}
			switch (ProtectiveWards.wardAccessProtectItemPickupMode.Value)
			{
			case ProtectiveWards.WardItemPickupMode.AllowAll:
				return false;
			case ProtectiveWards.WardItemPickupMode.AllowNonPlayerDropped:
				if (itemDrop.m_autoPickup)
				{
					return false;
				}
				break;
			default:
				return false;
			case ProtectiveWards.WardItemPickupMode.BlockAll:
				break;
			}
			return silent ? ShouldSilentlyBlockProtectedInteraction((Component)(object)itemDrop, character) : ProtectiveWards.BlockUnauthorizedWardInteraction((Component)(object)itemDrop, character);
		}
	}
	internal class Multipliers
	{
		[HarmonyPatch(typeof(SEMan), "ModifyFallDamage")]
		public static class SEMan_ModifyFallDamage_FallDamageMultiplier
		{
			private static void Postfix(Character ___m_character, ZNetView ___m_nview, ref float damage)
			{
				//IL_0010: Unknown result type (might be due to invalid IL or missing references)
				if (!((Object)(object)___m_nview == (Object)null) && ProtectiveWards.InsideEnabledPlayersArea(((Component)___m_character).transform.position))
				{
					damage *= Math.Max(ProtectiveWards.fallDamageTakenMultiplier.Value, 0f);
				}
			}
		}

		[HarmonyPatch(typeof(Character), "Damage")]
		public static class Character_Damage_DamageMultipliers
		{
			private static void Prefix(Character __instance, ref HitData hit, ZNetView ___m_nview)
			{
				//IL_0010: Unknown result type (might be due to invalid IL or missing references)
				if ((Object)(object)___m_nview == (Object)null || !ProtectiveWards.InsideEnabledPlayersArea(((Component)__instance).transform.position, out var area) || (hit.HaveAttacker() && hit.GetAttacker().IsBoss()))
				{
					return;
				}
				if (__instance.IsPlayer())
				{
					ModifyHitDamage(ref hit, ProtectiveWards.playerDamageTakenMultiplier.Value);
				}
				else if (__instance.IsTamed())
				{
					ModifyHitDamage(ref hit, ProtectiveWards.tamedDamageTakenMultiplier.Value);
					if (ProtectiveWards.boarsHensProtection.Value && ProtectiveWards._boarsHensProtectionGroupList.Contains(__instance.m_group.ToLower()) && (!hit.HaveAttacker() || !hit.GetAttacker().IsPlayer()))
					{
						if (hit.GetTotalDamage() != hit.m_damage.m_fire)
						{
							area.FlashShield(false);
						}
						ModifyHitDamage(ref hit, 0f);
					}
				}
				else
				{
					ModifyHitDamage(ref hit, ProtectiveWards.playerDamageDealtMultiplier.Value);
				}
			}
		}

		[HarmonyPatch(typeof(WearNTear), "Damage")]
		public static class WearNTear_Damage_DamageTakenMultiplier
		{
			private static void Prefix(WearNTear __instance, ref HitData hit, ZNetView ___m_nview)
			{
				//IL_0010: 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_003f: Invalid comparison between Unknown and I4
				//IL_0076: Unknown result type (might be due to invalid IL or missing references)
				//IL_007c: Invalid comparison between Unknown and I4
				if (!((Object)(object)___m_nview == (Object)null) && ProtectiveWards.InsideEnabledPlayersArea(((Component)__instance).transform.position, checkCache: true))
				{
					if (ProtectiveWards.fireplaceProtection.Value && (int)hit.m_hitType == 14 && (Object)(object)((Component)__instance).GetComponent<Fireplace>() != (Object)null)
					{
						ModifyHitDamage(ref hit, 0f);
					}
					else if (ProtectiveWards.wardShipProtection.Value == ProtectiveWards.ShipDamageType.AnyButPlayerDamage && (int)hit.m_hitType != 2 && (Object)(object)((Component)__instance).GetComponent<Ship>() != (Object)null)
					{
						ModifyHitDamage(ref hit, 0f);
					}
					else if (ProtectiveWards.wardShipProtection.Value == ProtectiveWards.ShipDamageType.AnyDamage && (Object)(object)((Component)__instance).GetComponent<Ship>() != (Object)null)
					{
						ModifyHitDamage(ref hit, 0f);
					}
					else if ((Object)(object)((Component)__instance).GetComponent<Piece>() != (Object)null && (!hit.HaveAttacker() || !hit.GetAttacker().IsBoss()))
					{
						ModifyHitDamage(ref hit, ProtectiveWards.structureDamageTakenMultiplier.Value);
					}
				}
			}
		}

		[HarmonyPatch(typeof(Player), "UpdateFood")]
		public static class Player_UpdateFood_FoodDrainMultiplier
		{
			private static void Prefix(Player __instance, float dt, bool forceUpdate)
			{
				//IL_004e: Unknown result type (might be due to invalid IL or missing references)
				if (ProtectiveWards.foodDrainMultiplier.Value == 1f || (Object)(object)__instance == (Object)null || !(dt + __instance.m_foodUpdateTimer >= 1f || forceUpdate) || !ProtectiveWards.InsideEnabledPlayersArea(((Component)__instance).transform.position))
				{
					return;
				}
				foreach (Food food in __instance.m_foods)
				{
					food.m_time += 1f - Math.Max(0f, ProtectiveWards.foodDrainMultiplier.Value);
				}
			}
		}

		[HarmonyPatch(typeof(Player), "UseStamina")]
		public static class Player_UseStamina_StaminaDrainMultiplier
		{
			private static void Prefix(Player __instance, ref float v)
			{
				//IL_002b: Unknown result type (might be due to invalid IL or missing references)
				if (ProtectiveWards.staminaDrainMultiplier.Value != 1f && !((Object)(object)__instance == (Object)null) && ProtectiveWards.InsideEnabledPlayersArea(((Component)__instance).transform.position))
				{
					v *= Math.Max(0f, ProtectiveWards.staminaDrainMultiplier.Value);
				}
			}
		}

		[HarmonyPatch(typeof(Player), "UpdatePlacement")]
		public static class Player_UseStamina_HammerDurabilityDrainMultiplier
		{
			private static void Prefix(Player __instance, ref float __state)
			{
				//IL_003a: Unknown result type (might be due to invalid IL or missing references)
				if (ProtectiveWards.hammerDurabilityDrainMultiplier.Value != 1f && !((Object)(object)__instance == (Object)null) && ((Character)__instance).InPlaceMode() && ProtectiveWards.InsideEnabledPlayersArea(((Component)__instance).transform.position))
				{
					ItemData rightItem = ((Humanoid)__instance).GetRightItem();
					__state = rightItem.m_shared.m_useDurabilityDrain;
					SharedData shared = rightItem.m_shared;
					shared.m_useDurabilityDrain *= Math.Max(0f, ProtectiveWards.hammerDurabilityDrainMultiplier.Value);
				}
			}

			private static void Postfix(Player __instance, float __state)
			{
				if (__state != 0f)
				{
					ItemData rightItem = ((Humanoid)__instance).GetRightItem();
					rightItem.m_shared.m_useDurabilityDrain = __state;
				}
			}
		}

		[HarmonyPatch(typeof(Player), "Repair")]
		public static class Player_Repair_HammerDurabilityDrainMultiplier
		{
			private static void Prefix(Player __instance, ItemData toolItem, ref float __state)
			{
				//IL_003a: Unknown result type (might be due to invalid IL or missing references)
				if (ProtectiveWards.hammerDurabilityDrainMultiplier.Value != 1f && !((Object)(object)__instance == (Object)null) && ((Character)__instance).InPlaceMode() && ProtectiveWards.InsideEnabledPlayersArea(((Component)__instance).transform.position))
				{
					__state = toolItem.m_shared.m_useDurabilityDrain;
					SharedData shared = toolItem.m_shared;
					shared.m_useDurabilityDrain *= Math.Max(0f, ProtectiveWards.hammerDurabilityDrainMultiplier.Value);
				}
			}

			private static void Postfix(Player __instance, ItemData toolItem, float __state)
			{
				if (__state != 0f)
				{
					toolItem.m_shared.m_useDurabilityDrain = __state;
				}
			}
		}

		[HarmonyPatch(typeof(Skills), "LowerAllSkills")]
		private static class Skills_OnDeath_SkillDrainMultiplier
		{
			private static void Prefix(ref float factor, Player ___m_player)
			{
				//IL_0014: Unknown result type (might be due to invalid IL or missing references)
				if (!((Object)(object)___m_player == (Object)null) && ProtectiveWards.InsideEnabledPlayersArea(((Component)___m_player).transform.position))
				{
					factor *= Math.Max(0f, ProtectiveWards.skillsDrainMultiplier.Value);
				}
			}
		}

		[HarmonyPatch(typeof(Fireplace), "GetTimeSinceLastUpdate")]
		private static class Fireplace_GetTimeSinceLastUpdate_FireplaceDrainMultiplier
		{
			private static void Postfix(Fireplace __instance, ref double __result)
			{
				//IL_001e: Unknown result type (might be due to invalid IL or missing references)
				if (ProtectiveWards.fireplaceDrainMultiplier.Value != 1f && ProtectiveWards.InsideEnabledPlayersArea(((Component)__instance).transform.position, checkCache: true))
				{
					__result *= Math.Max(0f, ProtectiveWards.fireplaceDrainMultiplier.Value);
				}
			}
		}

		[HarmonyPatch(typeof(Smelter), "GetDeltaTime")]
		private static class Smelter_GetDeltaTime_FireplaceDrainMultiplier_SmeltingSpeedMultiplier
		{
			private static void Postfix(Smelter __instance, ref double __result)
			{
				//IL_003e: Unknown result type (might be due to invalid IL or missing references)
				float num = ((__instance.m_name == "$piece_bathtub") ? ProtectiveWards.fireplaceDrainMultiplier.Value : ProtectiveWards.smeltingSpeedMultiplier.Value);
				if (num != 1f && ProtectiveWards.InsideEnabledPlayersArea(((Component)__instance).transform.position, checkCache: true))
				{
					__result *= Math.Max(0f, num);
				}
			}
		}

		[HarmonyPatch(typeof(CookingStation), "GetDeltaTime")]
		private static class CookingStation_GetDeltaTime_CookingSpeedMultiplier
		{
			private static void Postfix(Smelter __instance, ref float __result)
			{
				//IL_001e: Unknown result type (might be due to invalid IL or missing references)
				if (ProtectiveWards.cookingSpeedMultiplier.Value != 1f && ProtectiveWards.InsideEnabledPlayersArea(((Component)__instance).transform.position, checkCache: true))
				{
					__result *= Math.Max(0f, ProtectiveWards.cookingSpeedMultiplier.Value);
				}
			}
		}

		[HarmonyPatch(typeof(CookingStation), "UpdateFuel")]
		private static class CookingStation_UpdateFuel_FireplaceDrainMultiplier
		{
			private static void Prefix(Smelter __instance, ref float dt, ref float __state)
			{
				//IL_0032: Unknown result type (might be due to invalid IL or missing references)
				if ((ProtectiveWards.fireplaceDrainMultiplier.Value != 1f || ProtectiveWards.cookingSpeedMultiplier.Value != 1f) && ProtectiveWards.InsideEnabledPlayersArea(((Component)__instance).transform.position, checkCache: true))
				{
					__state = dt;
					dt *= Math.Max(0f, ProtectiveWards.fireplaceDrainMultiplier.Value);
					if (ProtectiveWards.cookingSpeedMultiplier.Value > 0f)
					{
						dt /= ProtectiveWards.cookingSpeedMultiplier.Value;
					}
				}
			}

			private static void Postfix(Smelter __instance, ref float dt, float __state)
			{
				if (__state != 0f)
				{
					dt = __state;
				}
			}
		}

		[HarmonyPatch(typeof(Fermenter), "GetFermentationTime")]
		private static class Fermenter_GetFermentationTime_FermentingSpeedMultiplier
		{
			private static void Postfix(Fermenter __instance, ref double __result)
			{
				//IL_001e: Unknown result type (might be due to invalid IL or missing references)
				if (ProtectiveWards.fermentingSpeedMultiplier.Value != 1f && ProtectiveWards.InsideEnabledPlayersArea(((Component)__instance).transform.position, checkCache: true))
				{
					__result *= Math.Max(0f, ProtectiveWards.fermentingSpeedMultiplier.Value);
				}
			}
		}

		[HarmonyPatch(typeof(SapCollector), "GetTimeSinceLastUpdate")]
		private static class SapCollector_GetTimeSinceLastUpdate_SapCollectingSpeedMultiplier
		{
			private static void Postfix(SapCollector __instance, ref float __result)
			{
				//IL_001e: Unknown result type (might be due to invalid IL or missing references)
				if (ProtectiveWards.sapCollectingSpeedMultiplier.Value != 1f && ProtectiveWards.InsideEnabledPlayersArea(((Component)__instance).transform.position, checkCache: true))
				{
					__result *= Math.Max(0f, ProtectiveWards.sapCollectingSpeedMultiplier.Value);
				}
			}
		}

		[HarmonyPatch(typeof(Turret), "IsCoolingDown")]
		private static class Turret_IsCoolingDown_turretFireRateMultiplier
		{
			private static void Prefix(Turret __instance, ref float ___m_attackCooldown, ref float __state)
			{
				//IL_001e: Unknown result type (might be due to invalid IL or missing references)
				if (ProtectiveWards.turretFireRateMultiplier.Value != 1f && ProtectiveWards.InsideEnabledPlayersArea(((Component)__instance).transform.position, checkCache: true))
				{
					__state = ___m_attackCooldown;
					___m_attackCooldown *= Math.Max(0f, ProtectiveWards.turretFireRateMultiplier.Value);
				}
			}

			private static void Postfix(ref float ___m_attackCooldown, float __state)
			{
				if (__state > 0f)
				{
					___m_attackCooldown = __state;
				}
			}
		}

		private static void ModifyHitDamage(ref HitData hit, float value)
		{
			((DamageTypes)(ref hit.m_damage)).Modify(Math.Max(value, 0f));
		}
	}
	internal class RaidProtection
	{
		[HarmonyPatch(typeof(Player), "UpdateBaseValue")]
		public static class Player_UpdateBaseValue_SittingRaidProtection
		{
			public static void Postfix(Player __instance, float ___m_baseValueUpdateTimer, ref int ___m_baseValue, ZNetView ___m_nview)
			{
				//IL_0057: Unknown result type (might be due to invalid IL or missing references)
				if (ProtectiveWards.sittingRaidProtection.Value && ___m_baseValueUpdateTimer == 0f && ___m_baseValue >= 3 && ((Character)__instance).IsSitting() && __instance.m_attached && ((Character)__instance).m_seman.HaveStatusEffect(SEMan.s_statusEffectCampFire) && ProtectiveWards.InsideEnabledPlayersArea(((Component)__instance).transform.position, checkCache: true))
				{
					___m_baseValue = ProtectiveWards.baseValueProtected;
					ZNet.instance.m_serverSyncedPlayerData["baseValue"] = ___m_baseValue.ToString();
					___m_nview.GetZDO().Set(ZDOVars.s_baseValue, ___m_baseValue, false);
				}
			}
		}

		[HarmonyPatch(typeof(RandEventSystem), "CheckBase")]
		public static class RandEventSystem_CheckBase_SittingRaidProtection
		{
			public static void Postfix(PlayerEventData player, ref bool __result)
			{
				//IL_001b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0036: Unknown result type (might be due to invalid IL or missing references)
				//IL_0037: 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_0047: Unknown result type (might be due to invalid IL or missing references)
				if (ProtectiveWards.sittingRaidProtection.Value && __result && player.baseValue == ProtectiveWards.baseValueProtected)
				{
					ProtectiveWards.LogInfo($"Player at {player.position.x} {player.position.z} is in raid protected state.");
					__result = false;
				}
			}
		}
	}
	public static class WardOfferings
	{
		[HarmonyPatch(typeof(PrivateArea), "UseItem")]
		public static class PrivateArea_UseItem_Offerings
		{
			private static bool Prefix(PrivateArea __instance, Humanoid user, ItemData item, ref bool __result)
			{
				//IL_0043: Unknown result type (might be due to invalid IL or missing references)
				//IL_019e: Unknown result type (might be due to invalid IL or missing references)
				//IL_01a4: Invalid comparison between Unknown and I4
				//IL_0250: Unknown result type (might be due to invalid IL or missing references)
				//IL_0257: Invalid comparison between Unknown and I4
				//IL_0315: Unknown result type (might be due to invalid IL or missing references)
				//IL_031b: Invalid comparison between Unknown and I4
				//IL_03b1: Unknown result type (might be due to invalid IL or missing references)
				if ((Object)(object)__instance == (Object)null || (Object)(object)__instance.m_nview == (Object)null || !__instance.m_nview.IsValid() || item == null || item.m_shared == null)
				{
					return true;
				}
				if ((int)__instance.m_ownerFaction != 0 || !WardZdoUtils.IsWardPrefab(((Component)__instance).gameObject))
				{
					return true;
				}
				if (!__instance.IsEnabled())
				{
					ProtectiveWards.LogInfo("Ward disabled");
					return true;
				}
				Player val = (Player)(object)((user is Player) ? user : null);
				if (!Object.op_Implicit((Object)(object)val) || (Object)(object)val != (Object)(object)Player.m_localPlayer)
				{
					ProtectiveWards.LogInfo("UseItem user not a player");
					return true;
				}
				if (ProtectiveWards.offeringProtectFromNonPermitted.Value && !ProtectiveWards.HasAccessToWardOrConnectedWard(__instance, val))
				{
					ProtectiveWards.LogInfo("No access");
					return true;
				}
				ProtectiveWards.LogInfo($"{val.GetPlayerName()} used {item.m_shared.m_name} on {__instance.m_nview.GetZDO()}");
				bool flag = ProtectiveWards.offeringTaxi.Value && WardTaxi.IsTaxiOfferingItem(item.m_shared.m_name);
				bool flag2 = !flag && item.m_shared.m_name == "$item_blackcore" && ProtectiveWards.offeringAugmenting.Value;
				bool flag3 = flag2 || (!flag && item.m_shared.m_name == "$item_surtlingcore" && ProtectiveWards.offeringActiveRepair.Value);
				bool flag4 = (int)item.m_shared.m_itemType == 2;
				bool flag5 = !flag && ProtectiveWards.offeringFood.Value && item.m_shared.m_food > 0f;
				bool flag6 = !flag && ProtectiveWards.offeringMead.Value && item.m_shared.m_food <= 0f && Object.op_Implicit((Object)(object)item.m_shared.m_consumeStatusEffect);
				bool flag7 = flag4 && (flag5 || flag6);
				bool flag8 = !flag && ProtectiveWards.offeringThundertone.Value && item.m_shared.m_name == "$item_thunderstone";
				bool flag9 = !flag && ProtectiveWards.offeringTrophy.Value && (int)item.m_shared.m_itemType == 13;
				bool flag10 = !flag && ProtectiveWards.offeringEitr.Value && item.m_shared.m_name == "$item_eitr";
				bool flag11 = (!flag && ProtectiveWards.offeringYmirRemains.Value && item.m_shared.m_name == "$item_ymirremains") || flag10;
				bool flag12 = !flag && ProtectiveWards.offeringDragonEgg.Value && item.m_shared.m_name == "$item_dragonegg" && ZoneSystem.instance.GetGlobalKey((GlobalKeys)34);
				if (!flag3 && !flag7 && !flag8 && !flag9 && !flag11 && !flag12 && !flag)
				{
					if ((int)item.m_shared.m_itemType == 2)
					{
						__result = true;
						return false;
					}
					return true;
				}
				if (flag3)
				{
					RepairNearestStructures(flag2, __instance, val, item);
				}
				if (flag7)
				{
					ApplyConsumableEffectToNearestPlayers(__instance, item, val);
				}
				if (flag8)
				{
					ApplyThunderstrikeOnNearbyEnemies(__instance, item, val);
				}
				if (flag9)
				{
					ApplyTrophyEffectOnNearbyEnemies(__instance, item, val);
				}
				if (flag11)
				{
					ApplyInstantGrowthEffectOnNearbyPlants(__instance, item, val, !flag10);
				}
				if (flag12)
				{
					ApplyModerPowerEffectToNearbyPlayers(__instance, item, val);
				}
				if (flag)
				{
					WardTaxi.TryStartTaxiFromOffering(item, val, ((Component)__instance).transform.position);
				}
				__result = true;
				return false;
			}
		}

		internal static int moderPowerHash = StringExtensionMethods.GetStableHashCode("GP_Moder");

		private static readonly WaitForSeconds wait1sec = new WaitForSeconds(1f);

		public static IEnumerator PassiveHealingEffect(PrivateArea ward, float amount, int seconds)
		{
			while (true)
			{
				if ((Object)(object)ward == (Object)null)
				{
					yield break;
				}
				if (Game.IsPaused())
				{
					yield return (object)new WaitForSeconds(2f);
				}
				if (!ProtectiveWards.wardIsHealing.TryGetValue(ward, out var secondsLeft))
				{
					yield break;
				}
				if (secondsLeft <= 0)
				{
					break;
				}
				ProtectiveWards.wardIsHealing[ward] -= seconds;
				List<Character> characters = new List<Character>();
				CollectionExtensions.Do<PrivateArea>(ProtectiveWards.ConnectedAreas(ward), (Action<PrivateArea>)delegate(PrivateArea area)
				{
					//IL_0006: Unknown result type (might be due to invalid IL or missing references)
					Character.GetCharactersInRange(((Component)area).transform.position, area.m_radius, characters);
				});
				CollectionExtensions.DoIf<Character>((IEnumerable<Character>)characters.ToHashSet(), (Func<Character, bool>)((Character character) => character.IsTamed() || character.IsPlayer()), (Action<Character>)delegate(Character character)
				{
					character.Heal(amount * (float)seconds, true);
				});
				yield return (object)new WaitForSecondsRealtime((float)seconds);
			}
			ProtectiveWards.wardIsHealing.Remove(ward);
			ProtectiveWards.LogInfo("Passive healing stopped");
		}

		public static IEnumerator LightningStrikeEffect(PrivateArea ward)
		{
			if (!((Object)(object)ward == (Object)null))
			{
				List<Player> players = new List<Player>();
				CollectionExtensions.Do<PrivateArea>(ProtectiveWards.ConnectedAreas(ward), (Action<PrivateArea>)delegate(PrivateArea area)
				{
					//IL_0006: Unknown result type (might be due to invalid IL or missing references)
					Player.GetPlayersInRange(((Component)area).transform.position, area.m_radius, players);
				});
				CollectionExtensions.Do<Player>((IEnumerable<Player>)players.ToHashSet(), (Action<Player>)delegate(Player player)
				{
					//IL_000b: Unknown result type (might be due to invalid IL or missing references)
					//IL_0016: Unknown result type (might be due to invalid IL or missing references)
					ProtectiveWards.preLightning.Create(((Component)player).transform.position, ((Component)player).transform.rotation, (Transform)null, 1f, -1);
				});
				ProtectiveWards.LogInfo("Thor is preparing his strike");
				yield return (object)new WaitForSeconds(Random.Range(5f, 7f));
				if (Game.IsPaused())
				{
					yield return wait1sec;
				}
				List<Character> characters = new List<Character>();
				CollectionExtensions.Do<PrivateArea>(ProtectiveWards.ConnectedAreas(ward), (Action<PrivateArea>)delegate(PrivateArea area)
				{
					//IL_0006: Unknown result type (might be due to invalid IL or missing references)
					Character.GetCharactersInRange(((Component)area).transform.position, area.m_radius, characters);
				});
				CollectionExtensions.DoIf<Character>((IEnumerable<Character>)characters.ToHashSet(), (Func<Character, bool>)((Character character) => character.IsMonsterFaction(Time.time)), (Action<Character>)delegate(Character character)
				{
					//IL_000b: Unknown result type (might be due to invalid IL or missing references)
					//IL_0016: Unknown result type (might be due to invalid IL or missing references)
					Object.Instantiate<GameObject>(ProtectiveWards.lightningAOE, ((Component)character).transform.position, ((Component)character).transform.rotation);
				});
			}
		}

		public static IEnumerator InstantGrowthEffect(PrivateArea ward, List<Plant> plants)
		{
			if ((Object)(object)ward == (Object)null)
			{
				yield break;
			}
			ProtectiveWards.LogInfo("Instant growth started");
			yield return wait1sec;
			foreach (Plant plant in plants.ToHashSet())
			{
				if (Object.op_Implicit((Object)(object)plant) && !((Object)(object)plant.m_nview == (Object)null) && plant.m_nview.IsValid() && plant.m_nview.IsOwner())
				{
					if ((int)plant.m_status > 0)
					{
						plant.UpdateHealth(0.0);
					}
					plant.Grow();
					yield return (object)new WaitForSeconds(0.25f);
				}
			}
			ProtectiveWards.LogInfo("Instant growth ended");
		}

		private static void RepairNearestStructures(bool augment, PrivateArea ward, Player initiator, ItemData item)
		{
			//IL_00a4: 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)
			int num = 0;
			int num2 = 0;
			List<Piece> pieces = new List<Piece>();
			CollectionExtensions.Do<PrivateArea>(ProtectiveWards.ConnectedAreas(ward), (Action<PrivateArea>)delegate(PrivateArea area)
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				Piece.GetAllPiecesInRadius(((Component)area).transform.position, area.m_radius, pieces);
			});
			WearNTear val = default(WearNTear);
			foreach (Piece item2 in pieces.Where((Piece piece) => piece.IsPlacedByPlayer()))
			{
				if (((Component)item2).TryGetComponent<WearNTear>(ref val))
				{
					if (val.Repair())
					{
						num++;
						item2.m_placeEffect.Create(((Component)item2).transform.position, ((Component)item2).transform.rotation, (Transform)null, 1f, -1);
					}
					if (augment && (Object)(object)val.m_nview != (Object)null && val.m_nview.IsValid() && val.m_nview.IsOwner() && val.m_nview.GetZDO().GetFloat(ZDOVars.s_health, val.m_health) < val.m_health * 2f)
					{
						val.m_nview.GetZDO().Set(ZDOVars.s_health, val.m_health * 2f);
						val.m_nview.InvokeRPC(ZNetView.Everybody, "WNTHealthChanged", new object[1] { val.m_health * 2f });
						num2++;
					}
				}
			}
			if (num + num2 > 0)
			{
				((Humanoid)initiator).GetInventory().RemoveOneItem(item);
			}
			if (num2 > 0)
			{
				((Character)initiator).Message((MessageType)2, "$msg_offerdone".Localize(), 0, (Sprite)null);
				if (num > 0)
				{
					((Character)initiator).Message((MessageType)1, "$msg_repaired".Localize(num.ToString()), 0, (Sprite)null);
				}
			}
			else if (num > 0)
			{
				((Character)initiator).Message((MessageType)2, "$msg_repaired".Localize(num.ToString()), 0, (Sprite)null);
			}
			else if (augment)
			{
				((Character)initiator).Message((MessageType)2, "$msg_cantoffer".Localize(), 0, (Sprite)null);
			}
			else
			{
				string text = "$msg_doesnotneedrepair".Localize();
				((Character)initiator).Message((MessageType)2, char.ToUpper(text[0]) + text.Substring(1), 0, (Sprite)null);
			}
		}

		private static void GetPlantsInRange(Vector3 point, float radius, List<Plant> plants, bool growableOnly)
		{
			//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_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Invalid comparison between Unknown and I4
			List<SlowUpdate> allInstaces = SlowUpdate.GetAllInstaces();
			float num = radius * radius;
			Plant val = default(Plant);
			foreach (SlowUpdate item in allInstaces)
			{
				if (((Component)item).TryGetComponent<Plant>(ref val) && !((Object)(object)val.m_nview == (Object)null) && val.m_nview.IsValid() && val.m_nview.IsOwner() && Utils.DistanceSqr(((Component)item).transform.position, point) < num && (!growableOnly || (int)val.m_status == 0))
				{
					plants.Add(val);
				}
			}
		}

		private static void ApplyTrophyEffectOnNearbyEnemies(PrivateArea ward, ItemData item, Player initiator)
		{
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			ProtectiveWards.trophyTargets = ((IEnumerable<Turret>)Resources.FindObjectsOfTypeAll<Turret>()).FirstOrDefault((Func<Turret, bool>)((Turret ws) => ((Object)ws).name == "piece_turret"))?.m_configTargets;
			if (ProtectiveWards.trophyTargets == null)
			{
				return;
			}
			bool flag = false;
			foreach (TrophyTarget item2 in ProtectiveWards.trophyTargets.Where((TrophyTarget configTarget) => item.m_shared.m_name == configTarget.m_item.m_itemData.m_shared.m_name))
			{
				List<Character> characters = new List<Character>();
				CollectionExtensions.Do<PrivateArea>(ProtectiveWards.ConnectedAreas(ward), (Action<PrivateArea>)delegate(PrivateArea area)
				{
					//IL_0006: Unknown result type (might be due to invalid IL or missing references)
					Character.GetCharactersInRange(((Component)area).transform.position, area.m_radius, characters);
				});
				foreach (Character item3 in from character in characters.ToHashSet()
					where character.IsMonsterFaction(Time.time)
					select character)
				{
					foreach (Character target in item2.m_targets)
					{
						if (item3.m_name == target.m_name)
						{
							item3.SetHealth(0f);
							flag = true;
						}
					}
				}
			}
			if (flag)
			{
				((Humanoid)initiator).GetInventory().RemoveOneItem(item);
				((Character)initiator).Message((MessageType)2, "$msg_offerdone".Localize(), 0, (Sprite)null);
			}
			else
			{
				((Character)initiator).Message((MessageType)2, "$msg_offerwrong".Localize(), 0, (Sprite)null);
			}
		}

		private static void ApplyThunderstrikeOnNearbyEnemies(PrivateArea ward, ItemData item, Player initiator)
		{
			if (!Object.op_Implicit((Object)(object)ProtectiveWards.lightningAOE))
			{
				Incinerator val = Resources.FindObjectsOfTypeAll<Incinerator>().FirstOrDefault();
				ProtectiveWards.lightningAOE = val.m_lightingAOEs;
				ProtectiveWards.preLightning = val.m_leverEffects;
			}
			((MonoBehaviour)ProtectiveWards.instance).StartCoroutine(LightningStrikeEffect(ward));
			((Humanoid)initiator).GetInventory().RemoveOneItem(item);
			((Character)initiator).Message((MessageType)2, "$piece_incinerator_conversion".Localize(), 0, (Sprite)null);
		}

		private static void ApplyConsumableEffectToNearestPlayers(PrivateArea ward, ItemData item, Player initiator)
		{
			if (item.m_shared.m_food > 0f)
			{
				if (ProtectiveWards.wardIsHealing.ContainsKey(ward))
				{
					((Character)initiator).Message((MessageType)2, "$msg_offerwrong".Localize(), 0, (Sprite)null);
					return;
				}
				ProtectiveWards.wardIsHealing.Add(ward, 180);
				((MonoBehaviour)ProtectiveWards.instance).StartCoroutine(PassiveHealingEffect(ward, item.m_shared.m_foodRegen / 2f, 1));
				ProtectiveWards.LogInfo("Passive healing begins");
				((Character)initiator).Message((MessageType)2, "$msg_consumed".Localize() + ": " + item.m_shared.m_name, 0, (Sprite)null);
				((Humanoid)initiator).GetInventory().RemoveOneItem(item);
			}
			else
			{
				if (!Object.op_Implicit((Object)(object)item.m_shared.m_consumeStatusEffect))
				{
					return;
				}
				ProtectiveWards.LogInfo("Consumable effect offered");
				List<Player> players = new List<Player>();
				CollectionExtensions.Do<PrivateArea>(ProtectiveWards.ConnectedAreas(ward), (Action<PrivateArea>)delegate(PrivateArea area)
				{
					//IL_0006: Unknown result type (might be due to invalid IL or missing references)
					Player.GetPlayersInRange(((Component)area).transform.position, area.m_radius, players);
				});
				bool flag = false;
				foreach (Player item2 in from player in players.ToHashSet()
					where ((Humanoid)player).CanConsumeItem(item, false)
					select player)
				{
					((Character)item2).m_seman.AddStatusEffect(item.m_shared.m_consumeStatusEffect.NameHash(), true, 0, 0f);
					flag = true;
				}
				if (!flag)
				{
					((Character)initiator).Message((MessageType)2, "$msg_cantoffer".Localize(), 0, (Sprite)null);
					return;
				}
				((Humanoid)initiator).GetInventory().RemoveOneItem(item);
				((Character)initiator).Message((MessageType)2, "$msg_offerdone".Localize(), 0, (Sprite)null);
			}
		}

		private static void ApplyInstantGrowthEffectOnNearbyPlants(PrivateArea ward, ItemData item, Player initiator, bool growableOnly = true)
		{
			List<Plant> plants = new List<Plant>();
			CollectionExtensions.Do<PrivateArea>(ProtectiveWards.ConnectedAreas(ward), (Action<PrivateArea>)delegate(PrivateArea area)
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				GetPlantsInRange(((Component)area).transform.position, area.m_radius, plants, growableOnly);
			});
			if (plants.Count == 0)
			{
				((Character)initiator).Message((MessageType)2, "$msg_cantoffer".Localize(), 0, (Sprite)null);
				return;
			}
			Inventory inventory = ((Humanoid)initiator).GetInventory();
			if (item.m_shared.m_name == "$item_eitr" && inventory.CountItems("$item_eitr", -1, true) < 5)
			{
				((Character)initiator).Message((MessageType)2, "$msg_incompleteoffering".Localize(), 0, (Sprite)null);
				return;
			}
			((MonoBehaviour)ward).StartCoroutine(InstantGrowthEffect(ward, plants));
			if (item.m_shared.m_name == "$item_eitr")
			{
				((Humanoid)initiator).GetInventory().RemoveItem("$item_eitr", 5, -1, true);
				ProtectiveWards.LogInfo("Offered " + item.m_shared.m_name + " x5");
			}
			else
			{
				((Humanoid)initiator).GetInventory().RemoveOneItem(item);
				ProtectiveWards.LogInfo("Offered " + item.m_shared.m_name);
			}
			((Character)initiator).Message((MessageType)2, "$msg_offerdone".Localize(), 0, (Sprite)null);
		}

		private static void ApplyModerPowerEffectToNearbyPlayers(PrivateArea ward, ItemData item, Player initiator)
		{
			ProtectiveWards.LogInfo("Dragon egg offered");
			List<Player> players = new List<Player>();
			CollectionExtensions.Do<PrivateArea>(ProtectiveWards.ConnectedAreas(ward), (Action<PrivateArea>)delegate(PrivateArea area)
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				Player.GetPlayersInRange(((Component)area).transform.position, area.m_radius, players);
			});
			foreach (Player item2 in players.ToHashSet())
			{
				StatusEffect statusEffect = ObjectDB.instance.GetStatusEffect(moderPowerHash);
				((Character)item2).GetSEMan().AddStatusEffect(statusEffect.NameHash(), true, 0, 0f);
			}
			((Humanoid)initiator).GetInventory().RemoveOneItem(item);
		}

		internal static bool IsBossTrophy(string itemName)
		{
			itemName = itemName.GetItemName();
			int result;
			switch (itemName)
			{
			default:
				result = ((itemName == "$item_trophy_fader") ? 1 : 0);
				break;
			case "$item_trophy_eikthyr":
			case "$item_trophy_elder":
			case "$item_trophy_bonemass":
			case "$item_trophy_dragonqueen":
			case "$item_trophy_goblinking":
			case "$item_trophy_seekerqueen":
				result = 1;
				break;
			}
			return (byte)result != 0;
		}

		internal static bool IsHildirChestItem(string itemName)
		{
			itemName = itemName.GetItemName();
			return itemName == "$item_chest_hildir1" || itemName == "$item_chest_hildir2" || itemName == "$item_chest_hildir3";
		}

		public static bool IsTeleportable(Player player)
		{
			if (((Humanoid)player).IsTeleportable())
			{
				return true;
			}
			foreach (ItemData allItem in ((Humanoid)player).GetInventory().GetAllItems())
			{
				if (IsHildirChestItem(allItem.m_shared.m_name) || allItem.m_shared.m_teleportable)
				{
					continue;
				}
				return false;
			}
			return true;
		}
	}
	internal static class WardTaxi
	{
		private enum TaxiState
		{
			Idle,
			WaitingOutbound,
			OutboundFlight,
			FallingBeforeReturn,
			WaitingReturn,
			WaitingRetry,
			ReturnFlight,
			Falling
		}

		internal struct TaxiOffer
		{
			public string LocationName;

			public string ItemName;

			public int Stack;

			public bool ConsumeItem;
		}

		internal sealed class SE_WardTaxi : SE_Stats
		{
			public override void UpdateStatusEffect(float dt)
			{
				((SE_Stats)this).UpdateStatusEffect(dt);
				WardTaxi.UpdateStatusEffect(this, dt);
			}

			public override void Stop()
			{
				OnStatusStopped(this);
				((StatusEffect)this).Stop();
			}
		}

		[HarmonyPatch(typeof(Valkyrie), "Awake")]
		private static class Valkyrie_Awake_Taxi
		{
			private static bool Prefix(Valkyrie __instance)
			{
				//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
				//IL_0123: Unknown result type (might be due to invalid IL or missing references)
				//IL_0128: Unknown result type (might be due to invalid IL or missing references)
				//IL_012e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0143: Unknown result type (might be due to invalid IL or missing references)
				//IL_0148: Unknown result type (might be due to invalid IL or missing references)
				//IL_014d: Unknown result type (might be due to invalid IL or missing references)
				//IL_015c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0161: Unknown result type (might be due to invalid IL or missing references)
				//IL_0174: Unknown result type (might be due to invalid IL or missing references)
				//IL_0179: Unknown result type (might be due to invalid IL or missing references)
				//IL_0215: Unknown result type (might be due to invalid IL or missing references)
				//IL_0222: Unknown result type (might be due to invalid IL or missing references)
				//IL_022e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0239: Unknown result type (might be due to invalid IL or missing references)
				//IL_0269: Unknown result type (might be due to invalid IL or missing references)
				//IL_0274: Unknown result type (might be due to invalid IL or missing references)
				//IL_027b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0280: Unknown result type (might be due to invalid IL or missing references)
				//IL_0297: Unknown result type (might be due to invalid IL or missing references)
				//IL_029d: Unknown result type (might be due to invalid IL or missing references)
				//IL_02a2: Unknown result type (might be due to invalid IL or missing references)
				//IL_02a7: Unknown result type (might be due to invalid IL or missing references)
				//IL_02d3: Unknown result type (might be due to invalid IL or missing references)
				//IL_02d8: Unknown result type (might be due to invalid IL or missing references)
				//IL_02e6: Unknown result type (might be due to invalid IL or missing references)
				//IL_02eb: Unknown result type (might be due to invalid IL or missing references)
				//IL_02f3: Unknown result type (might be due to invalid IL or missing references)
				//IL_02f8: Unknown result type (might be due to invalid IL or missing references)
				//IL_02fd: Unknown result type (might be due to invalid IL or missing references)
				//IL_033c: Unknown result type (might be due to invalid IL or missing references)
				//IL_034a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0374: Unknown result type (might be due to invalid IL or missing references)
				//IL_0398: Unknown result type (might be due to invalid IL or missing references)
				if (!ProtectiveWards.offeringTaxi.Value)
				{
					return true;
				}
				if ((s_state != TaxiState.OutboundFlight && s_state != TaxiState.ReturnFlight) || (Object)(object)s_player == (Object)null || !s_waitingForValkyrieSpawn)
				{
					return true;
				}
				__instance.m_nview = ((Component)__instance).GetComponent<ZNetView>();
				__instance.m_animator = ((Component)__instance).GetComponentInChildren<Animator>();
				if ((Object)(object)__instance.m_nview == (Object)null || !__instance.m_nview.IsOwner() || ((Object)(object)Valkyrie.m_instance != (Object)null && (Object)(object)Valkyrie.m_instance != (Object)(object)__instance))
				{
					((Behaviour)__instance).enabled = false;
					return false;
				}
				ZDO zDO = __instance.m_nview.GetZDO();
				if (zDO == null)
				{
					((Behaviour)__instance).enabled = false;
					return false;
				}
				Valkyrie.m_instance = __instance;
				s_activeValkyrieId = zDO.m_uid;
				__instance.m_startAltitude = 30f;
				__instance.m_textDuration = 0f;
				__instance.m_descentAltitude = 150f;
				__instance.m_attachOffset = new Vector3(-0.1f, 1.5f, 0.1f);
				__instance.m_targetPoint = s_currentFlightTargetPosition + new Vector3(0f, __instance.m_dropHeight, 0f);
				Vector3 position = ((Component)s_player).transform.position;
				position.y += __instance.m_startAltitude;
				float num = (__instance.m_startDistance = Utils.DistanceXZ(__instance.m_targetPoint, position));
				__instance.m_startDescentDistance = Math.Min(200f, num / 5f);
				__instance.m_speed = Math.Max(Math.Min(num / 90f, ProtectiveWards.maxTaxiSpeed.Value), 10f);
				if (__instance.m_speed <= 15f)
				{
					EnvMan.instance.m_introEnvironment = EnvMan.instance.m_currentEnv.m_name;
				}
				else
				{
					EnvMan.instance.m_introEnvironment = "ThunderStorm";
				}
				s_player.m_intro = true;
				((Component)__instance).transform.position = position;
				((Component)__instance).transform.rotation = s_currentFlightSpawnRotation;
				float val = Utils.DistanceXZ(__instance.m_targetPoint, ((Component)__instance).transform.position);
				float num2 = Mathf.Clamp(__instance.m_descentAltitude / Math.Max(val, 1f), 0.2f, 0.8f);
				__instance.m_descentStart = Vector3.Lerp(__instance.m_targetPoint, ((Component)__instance).transform.position, num2);
				__instance.m_descentStart.y = __instance.m_descentAltitude;
				Vector3 val2 = __instance.m_targetPoint - __instance.m_descentStart;
				val2.y = 0f;
				if (((Vector3)(ref val2)).sqrMagnitude < 1f)
				{
					val2 = ((Component)s_player).transform.forward;
				}
				else
				{
					((Vector3)(ref val2)).Normalize();
				}
				__instance.m_flyAwayPoint = __instance.m_targetPoint + val2 * __instance.m_startDescentDistance;
				__instance.m_flyAwayPoint.y += 100f;
				__instance.SyncPlayer(true);
				ResetTaxiProgressWatch(s_player);
				ProtectiveWards.LogInfo($"Setting up Valkyrie passage from {((Component)__instance).transform.position} to {__instance.m_targetPoint} distance {num:0.0} speed {__instance.m_speed:0.0} yaw {((Component)__instance).transform.eulerAngles.y:0.0} yawOffset {s_currentFlightSpawnYawOffset:0.0} reference {ZNet.instance.GetReferencePosition()}");
				return false;
			}
		}

		[HarmonyPatch(typeof(Valkyrie), "OnDestroy")]
		private static class Valkyrie_OnDestroy_Taxi
		{
			private static void Prefix(Valkyrie __instance)
			{
				//IL_0010: Unknown result type (might be due to invalid IL or missing references)
				//IL_0015: Unknown result type (might be due to invalid IL or missing references)
				if (IsActiveTaxiValkyrie(__instance))
				{
					s_activeValkyrieId = ZDOID.None;
					if ((s_state == TaxiState.OutboundFlight || s_state == TaxiState.ReturnFlight) && (Object)(object)s_player != (Object)null && !((Character)s_player).InIntro())
					{
						HandleFlightEnded(s_player, dropped: false);
					}
				}
			}
		}

		[HarmonyPatch(typeof(Valkyrie), "DropPlayer")]
		private static class Valkyrie_DropPlayer_Taxi
		{
			private static void Postfix(Valkyrie __instance)
			{
				if (ProtectiveWards.offeringTaxi.Value && IsActiveTaxiValkyrie(__instance) && !((Object)(object)s_player == (Object)null) && !((Object)(object)Player.m_localPlayer != (Object)(object)s_player))
				{
					HandleFlightEnded(s_player, dropped: true);
				}
			}
		}

		[HarmonyPatch(typeof(Player), "SetIntro")]
		private static class Player_SetIntro_Taxi
		{
			private static void Postfix(Player __instance)
			{
				if (!((Character)__instance).InIntro() && !((Object)(object)__instance != (Object)(object)s_player) && (s_state == TaxiState.OutboundFlight || s_state == TaxiState.ReturnFlight))
				{
					HandleFlightEnded(__instance, dropped: false);
				}
			}
		}

		[HarmonyPatch(typeof(SEMan), "Update")]
		private static class SEMan_Update_TaxiStatusConsistency
		{
			private static void Postfix(SEMan __instance)
			{
				Player localPlayer = Player.m_localPlayer;
				if ((Object)(object)localPlayer == (Object)null || __instance != ((Character)localPlayer).m_seman)
				{
					return;
				}
				bool flag = HasTaxiStatusEffect(localPlayer);
				if (s_deferredStatusRemoval)
				{
					s_deferredStatusRemoval = false;
					if (flag)
					{
						RemoveTaxiStatusEffect(localPlayer, controlled: true);
					}
				}
				else if (s_statusExpected && !flag)
				{
					ProtectiveWards.LogInfo("Valkyrie passage status effect disappeared. Cleaning up taxi state.");
					CleanupActiveValkyrie();
					ResetState();
				}
				else if (!s_statusExpected && flag)
				{
					RemoveTaxiStatusEffect(localPlayer, controlled: true);
				}
			}
		}

		[HarmonyPatch(typeof(ObjectDB), "Awake")]
		private static class ObjectDB_Awake_RegisterTaxiStatusEffect
		{
			private static void Postfix()
			{
				RegisterTaxiStatusEffect();
			}
		}

		[HarmonyPatch(typeof(ObjectDB), "CopyOtherDB")]
		private static class ObjectDB_CopyOtherDB_RegisterTaxiStatusEffect
		{
			private static void Postfix()
			{
				RegisterTaxiStatusEffect();
			}
		}

		[HarmonyPatch(typeof(ZoneSystem), "Start")]
		private static class ZoneSystem_Start_Taxi
		{
			private static void Postfix()
			{
				CleanupActiveValkyrie();
				ResetState();
				RegisterRPCs();
			}
		}

		private const string WardTaxiStatusEffectName = "PW_WardTaxiStatus";

		internal static readonly int wardTaxiStatusHash = StringExtensionMethods.GetStableHashCode("PW_WardTaxiStatus");

		private static readonly int slowFallHash = StringExtensionMethods.GetStableHashCode("SlowFall");

		private const float MinTaxiDistance = 200f;

		private const float MaxTaxiOfferingSourceDistance = 50f;

		private const float TaxiStartAltitude = 30f;

		private const float TaxiDescentAltitude = 150f;

		private const float TaxiProgressDistance = 3f;

		private const float TaxiStuckSeconds = 10f;

		private const int TaxiOutboundWaitSeconds = 10;

		private const string EikthyrAltarLocation = "Eikthyrnir";

		private const string ElderAltarLocation = "GDKing";

		private const string BonemassAltarLocation = "Bonemass";

		private const string ModerAltarLocation = "Dragonqueen";

		private const string YagluthAltarLocation = "GoblinKing";

		private const string QueenAltarLocation = "Mistlands_DvergrBossEntrance1";

		private const string FaderAltarLocation = "FaderLocation";

		private static TaxiState s_state = TaxiState.Idle;

		private static Player s_player;

		private static Vector3 s_targetPosition;

		private static Vector3 s_returnPosition;

		private static Vector3 s_currentFlightTargetPosition;

		private static Quaternion s_currentFlightSpawnRotation = Quaternion.identity;

		private static float s_currentFlightSpawnYawOffset;

		private static TaxiOffer s_offer;

		private static bool s_returnBack;

		private static bool s_waitingForValkyrieSpawn;

		private static bool s_statusExpected;

		private static bool s_controlledStatusRemoval;

		private static bool s_deferredStatusRemoval;

		private static ZDOID s_activeValkyrieId = ZDOID.None;

		private static Vector3 s_lastProgressPosition;

		private static float s_lastProgressTime;

		internal static bool IsTaxiOfferingItem(string itemName)
		{
			TaxiOffer offer;
			return TryGetTaxiOffer(itemName, out offer);
		}

		internal static void TryStartTaxiFromOffering(ItemData item, Player initiator, Vector3 offeringPosition)
		{
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: 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_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			if (item == null || item.m_shared == null || (Object)(object)initiator == (Object)null || !TryGetTaxiOffer(item.m_shared.m_name, out var offer))
			{
				return;
			}
			if (((Character)initiator).IsEncumbered())
			{
				((Character)initiator).Message((MessageType)2, "$se_encumbered_start".Localize(), 0, (Sprite)null);
				return;
			}
			if (!WardOfferings.IsTeleportable(initiator))
			{
				((Character)initiator).Message((MessageType)2, "$pw_msg_notravel".Localize(), 0, (Sprite)null);
				return;
			}
			Vector3 target = Vector3.zero;
			if (TryGetFoundLocation(offer.LocationName, offeringPosition, ref target))
			{
				TryStartPassage(initiator, offeringPosition, target, offer);
			}
			else if ((Object)(object)ZNet.instance != (Object)null && !ZNet.instance.IsServer())
			{
				ClosestLocationRequest(offer, offeringPosition);
			}
			else
			{
				ProtectiveWards.LogInfo("Location " + offer.LocationName + " is not found");
			}
		}

		internal static void RegisterRPCs()
		{
			if (ZRoutedRpc.instance != null && !((Object)(object)ZNet.instance == (Object)null))
			{
				if (ZNet.instance.IsServer())
				{
					ZRoutedRpc.instance.Register<ZPackage>("ClosestLocationRequest", (Action<long, ZPackage>)RPC_ClosestLocationRequest);
				}
				else
				{
					ZRoutedRpc.instance.Register<ZPackage>("StartTaxi", (Action<long, ZPackage>)RPC_StartTaxi);
				}
			}
		}

		private static void ClosestLocationRequest(TaxiOffer offer, Vector3 offeringPosition)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Expected O, but got Unknown
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			ProtectiveWards.LogInfo(offer.LocationName + " closest location request");
			ZPackage val = new ZPackage();
			val.Write(offer.LocationName);
			val.Write(offer.ItemName);
			val.Write(offer.Stack);
			val.Write(offeringPosition);
			ZRoutedRpc.instance.InvokeRoutedRPC("ClosestLocationRequest", new object[1] { val });
		}

		private static void RPC_ClosestLocationRequest(long sender, ZPackage pkg)
		{
			//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_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: 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_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Expected O, but got Unknown
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			string text = pkg.ReadString();
			string itemName = pkg.ReadString().GetItemName();
			int num = pkg.ReadInt();
			Vector3 offeringPosition = pkg.ReadVector3();
			if (TryGetTaxiRequester(sender, out var requester) && IsValidServerTaxiRequest(text, itemName, num))
			{
				Vector3 target = Vector3.zero;
				Vector3 validatedOfferingSourcePosition = GetValidatedOfferingSourcePosition(requester, offeringPosition);
				if (!TryGetFoundLocation(text, validatedOfferingSourcePosition, ref target))
				{
					ProtectiveWards.LogInfo("Location " + text + " is not found");
					return;
				}
				ZPackage val = new ZPackage();
				val.Write(target);
				val.Write(text);
				val.Write(itemName);
				val.Write(num);
				val.Write(validatedOfferingSourcePosition);
				val.Write(ShouldConsumeTaxiItem(text, itemName));
				ZRoutedRpc.instance.InvokeRoutedRPC(sender, "StartTaxi", new object[1] { val });
			}
		}

		private static void RPC_StartTaxi(long sender, ZPackage pkg)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: 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)
			Vector3 position = pkg.ReadVector3();
			string locationName = pkg.ReadString();
			string itemName = pkg.ReadString().GetItemName();
			int stack = pkg.ReadInt();
			Vector3 offeringPosition = pkg.ReadVector3();
			bool consumeItem = pkg.ReadBool();
			ProtectiveWards.LogInfo("Server responded with closest location");
			TryStartPassage(Player.m_localPlayer, offeringPosition, position, new TaxiOffer
			{
				LocationName = locationName,
				ItemName = itemName,
				Stack = stack,
				ConsumeItem = consumeItem
			});
		}

		private static bool TryGetTaxiRequester(long sender, out ProtectiveWards.RoutedPlayerContext requester)
		{
			requester = default(ProtectiveWards.RoutedPlayerContext);
			return sender != 0L && ProtectiveWards.TryGetRoutedPlayer(sender, out requester);
		}

		private static bool IsValidServerTaxiRequest(string name, string itemName, int stack)
		{
			itemName = itemName.GetItemName();
			if (1 == 0)
			{
			}
			bool result = name switch
			{
				"StartTemple" => ProtectiveWards.offeringTaxiStartTempleEnabled.Value && WardOfferings.IsBossTrophy(itemName) && stack == GetSacrificialStonesTaxiStack(), 
				"Vendor_BlackForest" => ProtectiveWards.offeringTaxiHaldorEnabled.Value && IsItemForHaldorTravel(itemName) && stack == GetExpectedHaldorTaxiPrice(), 
				"Hildir_camp" => ProtectiveWards.offeringTaxiHildirEnabled.Value && ((ProtectiveWards.offeringTaxiHildirChestsEnabled.Value && WardOfferings.IsHildirChestItem(itemName) && stack == 1) || (IsItemForHildirTravel(itemName) && stack == GetHildirTaxiPrice())), 
				"BogWitch_Camp" => ProtectiveWards.offeringTaxiBogWitchEnabled.Value && IsItemForBogWitchTravel(itemName) && stack == ProtectiveWards.offeringTaxiPriceBogWitchAmount.Value, 
				_ => IsValidBossAltarTaxiRequest(name, itemName, stack), 
			};
			if (1 == 0)
			{
			}
			return result;
		}

		private static void TryStartPassage(Player initiator, Vector3 offeringPosition, Vector3 position, TaxiOffer offer)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: 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_0108: Unknown result type (might be due to invalid IL or missing references)
			//IL_011f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0120: Unknown result type (might be due to invalid IL or missing references)
			//IL_0125: 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_0143: Unknown result type (might be due to invalid IL or missing references)
			//IL_0148: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)initiator == (Object)null)
			{
				return;
			}
			Vector3 position2 = ((Component)initiator).transform.position;
			if (IsTaxiDestinationTooClose(position2, position))
			{
				ProtectiveWards.LogInfo($"Valkyrie passage destination is too close. Source: {position2}, destination: {position}, distance: {GetTaxiDistance(position2, position):0.0}");
				((Character)initiator).Message((MessageType)2, "$pw_msg_tooclose".Localize(), 0, (Sprite)null);
				return;
			}
			if (HasTaxiStatusEffect(initiator) || s_statusExpected || s_state != TaxiState.Idle)
			{
				if (ProtectiveWards.offeringTaxiExistingFlightMode.Value == ProtectiveWards.WardTaxiExistingFlightMode.StopActivePassage)
				{
					StopActivePassage(initiator, showMessage: true);
				}
				else
				{
					((Character)initiator).Message((MessageType)2, "$pw_msg_taxi_already_active".Localize(), 0, (Sprite)null);
				}
				return;
			}
			if (!HasTaxiPayment(initiator, offer))
			{
				((Character)initiator).Message((MessageType)2, "$msg_incompleteoffering".Localize(), 0, (Sprite)null);
				return;
			}
			s_player = initiator;
			float taxiDistance = GetTaxiDistance(position2, position);
			ProtectiveWards.LogInfo($"Valkyrie passage destination accepted. Source: {position2}, destination: {position}, distance: {taxiDistance:0.0}");
			s_targetPosition = position;
			s_returnPosition = position2;
			s_offer = offer;
			s_returnBack = ProtectiveWards.offeringTaxiSecondsToFlyBack.Value > 0;
			s_activeValkyrieId = ZDOID.None;
			s_waitingForValkyrieSpawn = false;
			SetState(TaxiState.WaitingOutbound, 10);
			((Character)initiator).Message((MessageType)2, "$pw_msg_valkyrie_coming".Localize(), 0, (Sprite)null);
		}

		private static void StopActivePassage(Player player, bool showMessage)
		{
			if (showMessage && player != null)
			{
				((Character)player).Message((MessageType)2, "$pw_msg_taxi_stopped".Localize(), 0, (Sprite)null);
			}
			CleanupActiveValkyrie();
			RemoveTaxiStatusEffect(player ?? s_player, controlled: true);
			ResetState();
		}

		private static void UpdateStatusEffect(SE_WardTaxi status, float dt)
		{
			Player val = s_player;
			if ((Object)(object)val == (Object)null || (Object)(object)Player.m_localPlayer != (Object)(object)val)
			{
				return;
			}
			switch (s_state)
			{
			case TaxiState.WaitingOutbound:
				if (((StatusEffect)status).m_time >= (float)Math.Max(10, 1))
				{
					TryStartFlight(isReturnFlight: false);
				}
				break;
			case TaxiState.OutboundFlight:
			case TaxiState.ReturnFlight:
				UpdateActiveFlight();
				break;
			case TaxiState.FallingBeforeReturn:
				ApplyTaxiSlowFall(status);
				if (PlayerIsGrounded(val))
				{
					StartWaitingReturn(val);
				}
				break;
			case TaxiState.WaitingReturn:
				if (((StatusEffect)status).m_time >= (float)Math.Max(ProtectiveWards.offeringTaxiSecondsToFlyBack.Value, 1))
				{
					TryStartFlight(isReturnFlight: true);
				}
				break;
			case TaxiState.WaitingRetry:
			{
				if (CanStartValkyrieFlight(val, silent: true))
				{
					TryStartFlight(isReturnFlight: true);
					break;
				}
				int num = Math.Max(ProtectiveWards.offeringTaxiReturnWaitLimitSeconds.Value, 0);
				if (num > 0 && ((StatusEffect)status).m_time >= (float)num)
				{
					((Character)val).Message((MessageType)2, "$pw_msg_taxi_return_wait_expired".Localize(), 0, (Sprite)null);
					FinishTaxiStatus(val);
				}
				break;
			}
			case TaxiState.Falling:
				ApplyTaxiSlowFall(status);
				if (PlayerIsGrounded(val))
				{
					((Character)val).Message((MessageType)2, "$pw_msg_taxi_complete".Localize(), 0, (Sprite)null);
					FinishTaxiStatus(val);
				}
				break;
			}
		}

		private static void TryStartFlight(bool isReturnFlight)
		{
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			Player val = s_player;
			if ((Object)(object)val == (Object)null)
			{
				return;
			}
			if (!CanStartValkyrieFlight(val, silent: false))
			{
				if (isReturnFlight)
				{
					SetState(TaxiState.WaitingRetry, Math.Max(ProtectiveWards.offeringTaxiReturnWaitLimitSeconds.Value, 0));
					((Character)val).Message((MessageType)2, "$pw_msg_taxi_waiting".Localize(), 0, (Sprite)null);
				}
				else
				{
					((Character)val).Message((MessageType)2, "$pw_msg_canttravel".Localize(), 0, (Sprite)null);
					FinishTaxiStatus(val);
				}
				return;
			}
			Vector3 val2 = (isReturnFlight ? s_returnPosition : s_targetPosition);
			if (IsTaxiDestinationTooClose(((Component)val).transform.position, val2))
			{
				if (isReturnFlight)
				{
					((Character)val).Message((MessageType)2, "$pw_msg_taxi_complete".Localize(), 0, (Sprite)null);
				}
				else
				{
					((Character)val).Message((MessageType)2, "$pw_msg_tooclose".Localize(), 0, (Sprite)null);
				}
				FinishTaxiStatus(val);
			}
			else if (!isReturnFlight && !TryConsumeTaxiPayment(val, s_offer))
			{
				((Character)val).Message((MessageType)2, "$msg_incompleteoffering".Localize(), 0, (Sprite)null);
				FinishTaxiStatus(val);
			}
			else if (!TrySpawnValkyrie(val, val2, isReturnFlight))
			{
				((Character)val).Message((MessageType)2, "$pw_msg_canttravel".Localize(), 0, (Sprite)null);
				FinishTaxiStatus(val);
			}
		}

		private static Vector3 GetValidatedOfferingSourcePosition(ProtectiveWards.RoutedPlayerContext requester, Vector3 offeringPosition)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: 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_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			if (!requester.HasPosition)
			{
				return offeringPosition;
			}
			return (Vector3.Distance(requester.Position, offeringPosition) <= 50f) ? offeringPosition : requester.Position;
		}

		private static bool IsTaxiDestinationTooClose(Vector3 sourcePosition, Vector3 destinationPosition)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			return GetTaxiDistance(sourcePosition, destinationPosition) < 200f;
		}

		private static float GetTaxiDistance(Vector3 sourcePosition, Vector3 destinationPosition)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			return Utils.DistanceXZ(sourcePosition, destinationPosition);
		}

		private static bool CanStartValkyrieFlight(Player player, bool silent)
		{
			if ((Object)(object)player == (Object)null || ((Character)player).IsDead())
			{
				return false;
			}
			if ((Object)(object)Valkyrie.m_instance != (Object)null && ((Behaviour)Valkyrie.m_instance).enabled && (Object)(object)Valkyrie.m_instance.m_nview != (Object)null && Valkyrie.m_instance.m_nview.IsOwner())
			{
				if (!silent)
				{
					((Character)player).Message((MessageType)2, "$menu_pleasewait".Localize(), 0, (Sprite)null);
				}
				return false;
			}
			if (((Character)player).IsAttachedToShip() || ((Character)player).IsAttached() || ((Character)player).IsRiding() || player.IsSleeping() || ((Character)player).IsTeleporting() || ((Character)player).InPlaceMode() || ((Character)player).InBed() || ((Character)player).InCutscene() || ((Character)player).InInterior())
			{
				if (!silent)
				{
					((Character)player).Message((MessageType)1, "$pw_msg_travel_inside".Localize(""), 0, (Sprite)null);
				}
				return false;
			}
			if (((Character)player).IsEncumbered())
			{
				if (!silent)
				{
					((Character)player).Message((MessageType)2, "$se_encumbered_start".Localize(), 0, (Sprite)null);
				}
				return false;
			}
			if (!WardOfferings.IsTeleportable(player))
			{
				if (!silent)
				{
					((Character)player).Message((MessageType)2, "$pw_msg_notravel".Localize(), 0, (Sprite)null);
				}
				return false;
			}
			return true;
		}

		private static bool TrySpawnValkyrie(Player player, Vector3 targetPosition, bool isReturnFlight)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: 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_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0114: Expected O, but got Unknown
			bool flag = false;
			try
			{
				Player.m_localPlayer.m_valkyrie.Load();
				flag = true;
				GameObject asset = Player.m_localPlayer.m_valkyrie.Asset;
				if ((Object)(object)asset == (Object)null || !Object.op_Implicit((Object)(object)asset.GetComponent<ZNetView>()))
				{
					throw new InvalidOperationException("Failed to load Valkyrie passage prefab.");
				}
				s_currentFlightTargetPosition = targetPosition;
				s_currentFlightSpawnRotation = GetValkyrieSpawnRotation(((Component)player).transform.position, targetPosition, ((Component)player).transform, out var yawOffset);
				s_currentFlightSpawnYawOffset = yawOffset;
				s_activeValkyrieId = ZDOID.None;
				s_waitingForValkyrieSpawn = true;
				SetState(isReturnFlight ? TaxiState.ReturnFlight : TaxiState.OutboundFlight, 0);
				ResetTaxiProgressWatch(player);
				((Character)player).Message((MessageType)2, "$pw_msg_travel_start".Localize(), 0, (Sprite)null);
				GameObject val = Object.Instantiate<GameObject>(asset, ((Component)player).transform.position, s_currentFlightSpawnRotation);
				s_waitingForValkyrieSpawn = false;
				ZNetView val2 = default(ZNetView);
				if ((Object)(object)val == (Object)null || !val.TryGetComponent<ZNetView>(ref val2))
				{
					throw new InvalidOperationException("Failed to create Valkyrie passage instance.");
				}
				val2.HoldReferenceTo((IReferenceCounted)(object)Player.m_localPlayer.m_valkyrie);
				return true;
			}
			catch (Exception arg)
			{
				s_waitingForValkyrieSpawn = false;
				ProtectiveWards.LogInfo($"Valkyrie passage start failed: {arg}");
				return false;
			}
			finally
			{
				if (flag)
				{
					Player.m_localPlayer.m_valkyrie.Release();
				}
			}
		}

		private static Quaternion GetValkyrieSpawnRotation(Vector3 sourcePosition, Vector3 targetPosition, Transform fallbackTransform, out float yawOffset)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			Vector3 val = targetPosition - sourcePosition;
			val.y = 0f;
			if (((Vector3)(ref val)).sqrMagnitude < 0.01f)
			{
				val = (((Object)(object)fallbackTransform != (Object)null) ? fallbackTransform.forward : Vector3.forward);
				val.y = 0f;
			}
			if (((Vector3)(ref val)).sqrMagnitude < 0.01f)
			{
				val = Vector3.forward;
			}
			((Vector3)(ref val)).Normalize();
			yawOffset = Random.Range(-60f, 60f);
			return Quaternion.LookRotation(val, Vector3.up) * Quaternion.Euler(0f, yawOffset, 0f);
		}

		private static void UpdateActiveFlight()
		{
			Valkyrie activeValkyrie = GetActiveValkyrie();
			if (!((Object)(object)activeValkyrie == (Object)null))
			{
				UpdateTaxiProgressWatch(activeValkyrie);
				if ((ZInput.GetButton("Use") && ZInput.GetButton("AltPlace")) || (ZInput.GetButton("JoyUse") && ZInput.GetButton("JoyAltPlace")))
				{
					activeValkyrie.DropPlayer(true);
				}
			}
		}

		private static void HandleFlightEnded(Player player, bool dropped)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)player == (Object)null)
			{
				return;
			}
			TaxiState taxiState = s_state;
			s_activeValkyrieId = ZDOID.None;
			s_waitingForValkyrieSpawn = false;
			if (dropped)
			{
				s_returnBack = false;
				SetState(TaxiState.Falling, 0);
				return;
			}
			((Character)player).Message((MessageType)2, "$pw_msg_taxi_complete".Localize(), 0, (Sprite)null);
			if (taxiState == TaxiState.OutboundFlight && s_returnBack && ProtectiveWards.offeringTaxiSecondsToFlyBack.Value > 0)
			{
				SetState(TaxiState.FallingBeforeReturn, 0);
			}
			else
			{
				SetState(TaxiState.Falling, 0);
			}
		}

		private static void StartWaitingReturn(Player player)
		{
			if (!((Object)(object)player == (Object)null))
			{
				int num = Math.Max(ProtectiveWards.offeringTaxiSecondsToFlyBack.Value, 0);
				if (num <= 0)
				{
					FinishTaxiStatus(player);
					return;
				}
				s_returnBack = false;
				SetState(TaxiState.WaitingReturn, num);
			}
		}

		private static void SetState(TaxiState state, int durationSeconds)
		{
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			Player val = s_player;
			s_state = state;
			RegisterTaxiStatusEffect();
			SE_WardTaxi taxiStatusEffect = GetTaxiStatusEffect(val);
			if ((Object)(object)taxiStatusEffect == (Object)null && (Object)(object)val != (Object)null && ((Character)val).m_seman != null && state != TaxiState.Idle)
			{
				s_statusExpected = true;
				((Character)val).m_seman.AddStatusEffect(wardTaxiStatusHash, true, 0, 0f);
				taxiStatusEffect = GetTaxiStatusEffect(val);
			}
			if ((Object)(object)taxiStatusEffect == (Object)null)
			{
				if (state != TaxiState.Idle)
				{
					ProtectiveWards.LogInfo("Failed to add Valkyrie passage status effect. Cleaning up taxi state.");
					ResetState();
				}
				return;
			}
			((StatusEffect)taxiStatusEffect).m_time = 0f;
			((StatusEffect)taxiStatusEffect).m_ttl = Math.Max(durationSeconds, 0);
			((StatusEffect)taxiStatusEffect).m_name = "$pw_se_ward_taxi_status";
			((StatusEffect)taxiStatusEffect).m_icon = GetTaxiStatusEffectIcon();
			((StatusEffect)taxiStatusEffect).m_startMessage = "$pw_msg_valkyrie_coming";
			((StatusEffect)taxiStatusEffect).m_startMessageType = (MessageType)2;
			((StatusEffect)taxiStatusEffect).m_stopMessage = "$pw_msg_taxi_stopped";
			((StatusEffect)taxiStatusEffect).m_stopMessageType = (MessageType)2;
			ClearTaxiSlowFall(taxiStatusEffect);
			SE_WardTaxi sE_WardTaxi = taxiStatusEffect;
			if (1 == 0)
			{
			}
			string tooltip;
			switch (state)
			{
			case TaxiState.WaitingOutbound:
				tooltip = "$pw_se_ward_taxi_waiting_outbound_tooltip".Localize();
				break;
			case TaxiState.OutboundFlight:
			case TaxiState.ReturnFlight:
				tooltip = "$pw_se_ward_taxi_flight_tooltip".Localize(GetDropHotkeyText());
				break;
			case TaxiState.WaitingReturn:
				tooltip = "$pw_se_ward_taxi_return_tooltip".Localize();
				break;
			case TaxiState.WaitingRetry:
				tooltip = "$pw_se_ward_taxi_waiting_retry_tooltip".Localize();
				break;
			case TaxiState.FallingBeforeReturn:
			case TaxiState.Falling:
				tooltip = "$pw_se_ward_taxi_falling_tooltip".Localize();
				break;
			default:
				tooltip = "";
				break;
			}
			if (1 == 0)
			{
			}
			((StatusEffect)sE_WardTaxi).m_tooltip = tooltip;
			if (state == TaxiState.FallingBeforeReturn || state == TaxiState.Falling)
			{
				ApplyTaxiSlowFall(taxiStatusEffect);
			}
		}

		private static void FinishTaxiStatus(Player player)
		{
			ResetState();
			s_deferredStatusRemoval = true;
		}

		private static void OnStatusStopped(SE_WardTaxi status)
		{
			if (!s_controlledStatusRemoval && s_statusExpected)
			{
				ProtectiveWards.LogInfo("Valkyrie passage status effect stopped unexpectedly. Cleaning up taxi state.");
				CleanupActiveValkyrie();
				ResetState();
			}
		}

		private static void RegisterTaxiStatusEffect()
		{
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)ObjectDB.instance == (Object)null)
			{
				return;
			}
			StatusEffect val = null;
			for (int num = ObjectDB.instance.m_StatusEffects.Count - 1; num >= 0; num--)
			{
				StatusEffect val2 = ObjectDB.instance.m_StatusEffects[num];
				if (!((Object)(object)val2 == (Object)null) && !(((Object)val2).name != "PW_WardTaxiStatus"))
				{
					if ((Object)(object)val == (Object)null && val2 is SE_WardTaxi)
					{
						val = val2;
					}
					else
					{
						ObjectDB.instance.m_StatusEffects.RemoveAt(num);
					}
				}
			}
			if ((Object)(object)val == (Object)null)
			{
				val = (StatusEffect)(object)ScriptableObject.CreateInstance<SE_WardTaxi>();
				((Object)val).name = "PW_WardTaxiStatus";
				val.m_name = "$pw_se_ward_taxi_status";
				val.m_icon = GetTaxiStatusEffectIcon();
				val.m_startMessage = "$pw_msg_valkyrie_coming";
				val.m_startMessageType = (MessageType)2;
				val.m_stopMessage = "$pw_msg_taxi_stopped";
				val.m_stopMessageType = (MessageType)2;
				ObjectDB.instance.m_StatusEffects.Add(val);
			}
		}

		private static SE_WardTaxi GetTaxiStatusEffect(Player player)
		{
			object obj;
			if (player == null)
			{
				obj = null;
			}
			else
			{
				SEMan seman = ((Character)player).m_seman;
				obj = ((seman != null) ? seman.GetStatusEffect(wardTaxiStatusHash) : null);
			}
			return obj as SE_WardTaxi;
		}

		private static bool HasTaxiStatusEffect(Player player)
		{
			return (Object)(object)player != (Object)null && ((Character)player).m_seman != null && ((Character)player).m_seman.HaveStatusEffect(wardTaxiStatusHash);
		}

		private static void RemoveTaxiStatusEffect(Player player, bool controlled)
		{
			if (!HasTaxiStatusEffect(player))
			{
				return;
			}
			bool flag = s_controlledStatusRemoval;
			s_controlledStatusRemoval = controlled;
			try
			{
				((Character)player).m_seman.RemoveStatusEffect(wardTaxiStatusHash, true);
			}
			finally
			{
				s_controlledStatusRemoval = flag;
			}
		}

		private static void ResetState()
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_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)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			s_state = TaxiState.Idle;
			s_player = null;
			s_targetPosition = Vector3.zero;
			s_returnPosition = Vector3.zero;
			s_offer = default(TaxiOffer);
			s_returnBack = false;
			s_waitingForValkyrieSpawn = false;
			s_currentFlightTargetPosition = Vector3.zero;
			s_currentFlightSpawnRotation = Quaternion.identity;
			s_currentFlightSpawnYawOffset = 0f;
			s_statusExpected = false;
			s_controlledStatusRemoval = false;
			s_activeValkyrieId = ZDOID.None;
			s_lastProgressPosition = Vector3.zero;
			s_lastProgressTime = 0f;
		}

		private static void CleanupActiveValkyrie()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			GameObject activeValkyrieObject = GetActiveValkyrieObject();
			s_activeValkyrieId = ZDOID.None;
			s_waitingForValkyrieSpawn = false;
			if (!((Object)(object)activeValkyrieObject == (Object)null))
			{
				Valkyrie component = activeValkyrieObject.GetComponent<Valkyrie>();
				if ((Object)(object)component != (Object)null && (Object)(object)s_player != (Object)null && ((Character)s_player).InIntro())
				{
					component.DropPlayer(true);
				}
				else if ((Object)(object)ZNetScene.instance != (Object)null)
				{
					ZNetScene.instance.Destroy(activeValkyrieObject);
				}
			}
		}

		private static GameObject GetActiveValkyrieObject()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			if (((ZDOID)(ref s_activeValkyrieId)).Equals(ZDOID.None) || (Object)(object)ZNetScene.instance == (Object)null)
			{
				return null;
			}
			return ZNetScene.instance.FindInstance(s_activeValkyrieId);
		}

		private static Valkyrie GetActiveValkyrie()
		{
			GameObject activeValkyrieObject = GetActiveValkyrieObject();
			return (activeValkyrieObject != null) ? activeValkyrieObject.GetComponent<Valkyrie>() : null;
		}

		private static bool IsActiveTaxiValkyrie(Valkyrie valkyrie)
		{
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)valkyrie == (Object)null || (Object)(object)valkyrie.m_nview == (Object)null || !valkyrie.m_nview.IsValid())
			{
				return false;
			}
			ZDO zDO = valkyrie.m_nview.GetZDO();
			return zDO != null && !((ZDOID)(ref s_activeValkyrieId)).Equals(ZDOID.None) && ((ZDOID)(ref zDO.m_uid)).Equals(s_activeValkyrieId);
		}

		private static void ResetTaxiProgressWatch(Player player)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)player == (Object)null))
			{
				s_lastProgressPosition = ((Component)player).transform.position;
				s_lastProgressTime = Time.time;
			}
		}

		private static void UpdateTaxiProgressWatch(Valkyrie valkyrie)
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)s_player == (Object)null) && IsActiveTaxiValkyrie(valkyrie))
			{
				if (Vector3.Distance(((Component)s_player).transform.position, s_lastProgressPosition) >= 3f)
				{
					ResetTaxiProgressWatch(s_player);
				}
				else if (!(Time.time - s_lastProgressTime < 10f))
				{
					ProtectiveWards.LogInfo("Valkyrie passage appears stuck. Dropping player.");
					valkyrie.DropPlayer(true);
					ResetTaxiProgressWatch(s_player);
				}
			}
		}

		private static bool PlayerIsGrounded(Player player)
		{
			return (Object)(object)player == (Object)null || ((Character)player).IsOnGround() || ((Character)player).IsSwimming();
		}

		private static void ApplyTaxiSlowFall(SE_WardTaxi status)
		{
			if (!((Object)(object)status == (Object)null))
			{
				ObjectDB instance = ObjectDB.instance;
				StatusEffect obj = ((instance != null) ? instance.GetStatusEffect(slowFallHash) : null);
				SE_Stats val = (SE_Stats)(object)((obj is SE_Stats) ? obj : null);
				if ((Object)(object)val != (Object)null)
				{
					((SE_Stats)status).m_maxMaxFallSpeed = val.m_maxMaxFallSpeed;
					((SE_Stats)status).m_fallDamageModifier = val.m_fallDamageModifier;
				}
				else
				{
					((SE_Stats)status).m_maxMaxFallSpeed = 5f;
					((SE_Stats)status).m_fallDamageModifier = -1f;
				}
			}
		}

		private static void ClearTaxiSlowFall(SE_WardTaxi status)
		{
			if (!((Object)(object)status == (Object)null))
			{
				((SE_Stats)status).m_maxMaxFallSpeed = 0f;
				((SE_Stats)status).m_fallDamageModifier = 0f;
			}
		}

		private static Sprite GetTaxiStatusEffectIcon()
		{
			ObjectDB instance = ObjectDB.instance;
			GameObject val = ((instance != null) ? instance.GetItemPrefab("CelestialFeather") : null);
			ItemDrop val2 = ((val != null) ? val.GetComponent<ItemDrop>() : null);
			return (val2 != null) ? val2.m_itemData.GetIcon() : null;
		}

		private static string GetDropHotkeyText()
		{
			string text = "$KEY_AltPlace".Localize();
			string text2 = "$KEY_Use".Localize();
			if (text == "$KEY_AltPlace")
			{
				text = "AltPlace";
			}
			if (text2 == "$KEY_Use")
			{
				text2 = "Use";
			}
			return text + " + " + text2;
		}

		internal static bool TryGetFoundLocation(string name, Vector3 position, ref Vector3 target)
		{
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: 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_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fe: 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)
			if ((Object)(object)ZoneSystem.instance == (Object)null)
			{
				return false;
			}
			ZoneSystem.instance.tempIconList.Clear();
			ZoneSystem.instance.GetLocationIcons(ZoneSystem.instance.tempIconList);
			bool flag = false;
			float num = float.MaxValue;
			foreach (KeyValuePair<Vector3, string> tempIcon in ZoneSystem.instance.tempIconList)
			{
				if (!(tempIcon.Value != name))
				{
					float num2 = Utils.DistanceXZ(position, tempIcon.Key);
					if (!(num2 >= num))
					{
						num = num2;
						target = tempIcon.Key;
						flag = true;
					}
				}
			}
			if (flag)
			{
				ProtectiveWards.LogInfo("Found closest " + name + " in icon list");
				return true;
			}
			LocationInstance val = default(LocationInstance);
			if (ZoneSystem.instance.FindClosestLocation(name, position, ref val))
			{
				target = val.m_position;
				ProtectiveWards.LogInfo("Found closest " + name + " in location list");
				return true;
			}
			return false;
		}

		private static bool HasTaxiPayment(Player player, TaxiOffer offer)
		{
			return offer.Stack <= 0 || ((Humanoid)player).GetInventory().CountItems(offer.ItemName, -1, true) >= offer.Stack;
		}

		private static bool TryConsumeTaxiPayment(Player player, TaxiOffer offer)
		{
			if (!HasTaxiPayment(player, offer))
			{
				return false;
			}
			if (offer.ConsumeItem && offer.Stack > 0)
			{
				((Humanoid)player).GetInventory().RemoveItem(offer.ItemName, offer.Stack, -1, true);
			}
			return true;
		}

		private static bool TryGetTaxiOffer(string itemName, out TaxiOffer offer)
		{
			offer = default(TaxiOffer);
			itemName = itemName.GetItemName();
			if (ProtectiveWards.offeringTaxiStartTempleEnabled.Value && WardOfferings.IsBossTrophy(itemName))
			{
				offer = new TaxiOffer
				{
					LocationName = "StartTemple",
					ItemName = itemName,
					Stack = GetSacrificialStonesTaxiStack(),
					ConsumeItem = ProtectiveWards.offeringTaxiStartTempleConsumeItem.Value
				};
				return true;
			}
			if (ProtectiveWards.offeringTaxiHaldorEnabled.Value && IsItemForHaldorTravel(itemName))
			{
				offer = new TaxiOffer
				{
					LocationName = "Vendor_BlackForest",
					ItemName = itemName,
					Stack = GetExpectedHaldorTaxiPrice(),
					ConsumeItem = ProtectiveWards.offeringTaxiHaldorConsumeItem.Value
				};
				return true;
			}
			if (ProtectiveWards.offeringTaxiHildirEnabled.Value && ProtectiveWards.offeringTaxiHildirChestsEnabled.Value && WardOfferings.IsHildirChestItem(itemName))
			{
				offer = new TaxiOffer
				{
					LocationName = "Hildir_camp",
					ItemName = itemName,
					Stack = 1,
					ConsumeItem = false
				};
				return true;
			}
			if (ProtectiveWards.offeringTaxiHildirEnabled.Value && IsItemForHildirTravel(itemName))
			{
				offer = new TaxiOffer
				{
					LocationName = "Hildir_camp",
					ItemName = itemName,
					Stack = GetHildirTaxiPrice(),
					ConsumeItem = ProtectiveWards.offeringTaxiHildirConsumeItem.Value
				};
				return true;
			}
			if (ProtectiveWards.offeringTaxiBogWitchEnabled.Value && IsItemForBogWitchTravel(itemName))
			{
				offer = new TaxiOffer
				{
					LocationName = "BogWitch_Camp",
					ItemName = itemName,
					Stack = ProtectiveWards.offeringTaxiPriceBogWitchAmount.Value,
					ConsumeItem = ProtectiveWards.offeringTaxiBogWitchConsumeItem.Value
				};
				return true;
			}
			return TryGetBossAltarTaxiOffer(itemName, out offer);
		}

		private static bool IsItemForHaldorTravel(string itemName)
		{
			return ConfiguredItemName(ProtectiveWards.offeringTaxiPriceHaldorItem) != "" && itemName.GetItemName() == ConfiguredItemName(ProtectiveWards.offeringTaxiPriceHaldorItem);
		}

		private static bool IsItemForHildirTravel(string itemName)
		{
			return ConfiguredItemName(ProtectiveWards.offeringTaxiPriceHildirItem) != "" && itemName.GetItemName() == ConfiguredItemName(ProtectiveWards.offeringTaxiPriceHildirItem);
		}

		private static bool IsItemForBogWitchTravel(string itemName)
		{
			return ConfiguredItemName(ProtectiveWards.offeringTaxiPriceBogWitchItem) != "" && itemName.GetItemName() == ConfiguredItemName(ProtectiveWards.offeringTaxiPriceBogWitchItem);
		}

		private static string ConfiguredItemName(ConfigEntry<string> entry)
		{
			return entry.Value.GetItemName();
		}

		private static int GetExpectedHaldorTaxiPrice()
		{
			return HasLocationIcon("Vendor_BlackForest") ? ProtectiveWards.offeringTaxiPriceHaldorDiscovered.Value : ProtectiveWards.offeringTaxiPriceHaldorUndiscovered.Value;
		}

		private static int GetHildirTaxiPrice()
		{
			return Math.Max(ProtectiveWards.offeringTaxiPriceHildirAmount.Value, 0);
		}

		private static int GetSacrificialStonesTaxiStack()
		{
			return ProtectiveWards.offeringTaxiStartTempleConsumeItem.Value ? 1 : 0;
		}

		private static bool HasLocationIcon(string name)
		{
			if ((Object)(object)ZoneSystem.instance == (Object)null)
			{
				return false;
			}
			ZoneSystem.instance.tempIconList.Clear();
			ZoneSystem.instance.GetLocationIcons(ZoneSystem.instance.tempIconList);
			return ZoneSystem.instance.tempIconList.Any((KeyValuePair<Vector3, string> icon) => icon.Value == name);
		}

		private static bool ShouldConsumeTaxiItem(string locationName, string itemName)
		{
			itemName = itemName.GetItemName();
			if (1 == 0)
			{
			}
			bool consumeItem;
			bool result = locationName switch
			{
				"StartTemple" => ProtectiveWards.offeringTaxiStartTempleConsumeItem.Value, 
				"Vendor_BlackForest" => ProtectiveWards.offeringTaxiHaldorConsumeItem.Value, 
				"Hildir_camp" => !WardOfferings.IsHildirChestItem(itemName) && ProtectiveWards.offeringTaxiHildirConsumeItem.Value, 
				"BogWitch_Camp" => ProtectiveWards.offeringTaxiBogWitchConsumeItem.Value, 
				_ => TryGetBossAltarConsumeItem(locationName, itemName, out consumeItem) && consumeItem, 
			};
			if (1 == 0)
			{
			}
			return result;
		}

		private static bool TryGetBossAltarTaxiOffer(string itemName, out TaxiOffer offer)
		{
			itemName = itemName.GetItemName();
			return TryGetBossAltarTaxiOffer(ProtectiveWards.offeringTaxiEikthyrAltarEnabled, "Eikthyrnir", ProtectiveWards.offeringTaxiEikthyrAltarItem, ProtectiveWards.offeringTaxiEikthyrAltarAmount, ProtectiveWards.offeringTaxiEikthyrAltarConsumeItem, itemName, out offer) || TryGetBossAltarTaxiOffer(ProtectiveWards.offeringTaxiElderAltarEnabled, "GDKing", ProtectiveWards.offeringTaxiElderAltarItem, ProtectiveWards.offeringTaxiElderAltarAmount, ProtectiveWards.offeringTaxiElderAltarConsumeItem, itemName, out offer) || TryGetBossAltarTaxiOffer(ProtectiveWards.offeringTaxiBonemassAltarEnabled, "Bonemass", ProtectiveWards.offeringTaxiBonemassAltarItem, ProtectiveWards.offeringTaxiBonemassAltarAmount, ProtectiveWards.offeringTaxiBonemassAltarConsumeItem, itemName, out offer) || TryGetBossAltarTaxiOffer(ProtectiveWards.offeringTaxiModerAltarEnabled, "Dragonqueen", ProtectiveWards.offeringTaxiModerAltarItem, ProtectiveWards.offeringTaxiModerAltarAmount, ProtectiveWards.offeringTaxiModerAltarConsumeItem, itemName, out offer) || TryGetBossAltarTaxiOffer(ProtectiveWards.offeringTaxiYagluthAltarEnabled, "GoblinKing", ProtectiveWards.offeringTaxiYagluthAltarItem, ProtectiveWards.offeringTaxiYagluthAltarAmount, ProtectiveWards.offeringTaxiYagluthAltarConsumeItem, itemName, out offer) || TryGetBossAltarTaxiOffer(ProtectiveWards.offeringTaxiQueenAltarEnabled, "Mistlands_DvergrBossEntrance1", ProtectiveWards.offeringTaxiQueenAltarItem, ProtectiveWards.offeringTaxiQueenAltarAmount, ProtectiveWards.offeringTaxiQueenAltarConsumeItem, itemName, out offer) || TryGetBossAltarTaxiOffer(ProtectiveWards.offeringTaxiFaderAltarEnabled, "FaderLocation", ProtectiveWards.offeringTaxiFaderAltarItem, ProtectiveWards.offeringTaxiFaderAltarAmount, ProtectiveWards.offeringTaxiFaderAltarConsumeItem, itemName, out offer);
		}

		private static bool TryGetBossAltarTaxiOffer(ConfigEntry<bool> enabled, string locationName, ConfigEntry<string> item, ConfigEntry<int> amount, ConfigEntry<bool> consume, string itemName, out TaxiOffer offer)
		{
			offer = default(TaxiOffer);
			string text = ConfiguredItemName(item);
			if (!enabled.Value || text == "" || itemName != text)
			{
				return false;
			}
			offer = new TaxiOffer
			{
				LocationName = locationName,
				ItemName = text,
				Stack = Math.Max(amount.Value, 0),
				ConsumeItem = consume.Value
			};
			return true;
		}

		private static bool IsValidBossAltarTaxiRequest(string locationName, string itemName, int stack)
		{
			itemName = itemName.GetItemName();
			return IsValidBossAltarTaxiRequest(ProtectiveWards.offeringTaxiEikthyrAltarEnabled, "Eikthyrnir", ProtectiveWards.offeringTaxiEikthyrAltarItem, ProtectiveWards.offeringTaxiEikthyrAltarAmount, locationName, itemName, stack) || IsValidBossAltarTaxiRequest(ProtectiveWards.offeringTaxiElderAltarEnabled, "GDKing", ProtectiveWards.offeringTaxiElderAltarItem, ProtectiveWards.offeringTaxiElderAltarAmount, locationName, itemName, stack) || IsValidBossAltarTaxiRequest(ProtectiveWards.offeringTaxiBonemassAltarEnabled, "Bonemass", ProtectiveWards.offeringTaxiBonemassAltarItem, ProtectiveWards.offeringTaxiBonemassAltarAmount, locationName, itemName, stack) || IsValidBossAltarTaxiRequest(ProtectiveWards.offeringTaxiModerAltarEnabled, "Dragonqueen", ProtectiveWards.offeringTaxiModerAltarItem, ProtectiveWards.offeringTaxiModerAltarAmount, locationName, itemName, stack) || IsValidBossAltarTaxiRequest(ProtectiveWards.offeringTaxiYagluthAltarEnabled, "GoblinKing", ProtectiveWards.offeringTaxiYagluthAltarItem, ProtectiveWards.offeringTaxiYagluthAltarAmount, locationName, itemName, stack) || IsValidBossAltarTaxiRequest(ProtectiveWards.offeringTaxiQueenAltarEnabled, "Mistlands_DvergrBossEntrance1", ProtectiveWards.offeringTaxiQueenAltarItem, ProtectiveWards.offeringTaxiQueenAltarAmount, locationName, itemName, stack) || IsValidBossAltarTaxiRequest(ProtectiveWards.offeringTaxiFaderAltarEnabled, "FaderLocation", ProtectiveWards.offeringTaxiFaderAltarItem, ProtectiveWards.offeringTaxiFaderAltarAmount, locationName, itemName, stack);
		}

		private static bool IsValidBossAltarTaxiRequest(ConfigEntry<bool> enabled, string expectedLocationName, ConfigEntry<string> item, ConfigEntry<int> amount, string locationName, string itemName, int stack)
		{
			return enabled.Value && locationName == expectedLocationName && itemName == ConfiguredItemName(item) && stack == Math.Max(amount.Value, 0);
		}

		private static bool TryGetBossAltarConsumeItem(string locationName, string itemName, out bool consumeItem)
		{
			itemName = itemName.GetItemName();
			return TryGetBossAltarConsumeItem("Eikthyrnir", ProtectiveWards.offeringTaxiEikthyrAltarItem, ProtectiveWards.offeringTaxiEikthyrAltarConsumeItem, locationName, itemName, out consumeItem) || TryGetBossAltarConsumeItem("GDKing", ProtectiveWards.offeringTaxiElderAltarItem, ProtectiveWards.offeringTaxiElderAltarConsumeItem, locationName, itemName, out consumeItem) || TryGetBossAltarConsumeItem("Bonemass", ProtectiveWards.offeringTaxiBonemassAltarItem, ProtectiveWards.offeringTaxiBonemassAltarConsumeItem, locationName, itemName, out consumeItem) || TryGetBossAltarConsumeItem("Dragonqueen", ProtectiveWards.offeringTaxiModerAltarItem, ProtectiveWards.offeringTaxiModerAltarConsumeItem, locationName, itemName, out consumeItem) || TryGetBossAltarConsumeItem("GoblinKing", ProtectiveWards.offeringTaxiYagluthAltarItem, ProtectiveWards.offeringTaxiYagluthAltarConsumeItem, locationName, itemName, out consumeItem) || TryGetBossAltarConsumeItem("Mistlands_DvergrBossEntrance1", ProtectiveWards.offeringTaxiQueenAltarItem, ProtectiveWards.offeringTaxiQueenAltarConsumeItem, locationName, itemName, out consumeItem) || TryGetBossAltarConsumeItem("FaderLocation", ProtectiveWards.offeringTaxiFaderAltarItem, ProtectiveWards.offeringTaxiFaderAltarConsumeItem, locationName, itemName, out consumeItem);
		}

		private static bool TryGetBossAltarConsumeItem(string expectedLocationName, ConfigEntry<string> item, ConfigEntry<bool> consume, string locationName, string itemName, out bool consumeItem)
		{
			consumeItem = false;
			if (locationName != expectedLocationName || itemName != ConfiguredItemName(item))
			{
				return false;
			}
			consumeItem = consume.Value;
			return true;
		}
	}
	internal static class WardSettingsUI
	{
		private enum SettingsPage
		{
			Main,
			Visuals,
			BubbleVisual,
			CircleVisual,
			Access
		}

		private enum FieldId
		{
			BubbleEnabled,
			BubbleColor,
			BubbleRefraction,
			BubbleWave,
			BubbleGlossiness,
			BubbleMetallic,
			BubbleNormalScale,
			BubbleDepthFade,
			CustomRange,
			Range,
			CustomColor,
			EmissionColor,
			EmissionColorMultiplier,
			CircleEnabled,
			CircleStartColor,
			CircleEndColor,
			CircleSpeed,
			CircleLength,
			CircleWidth,
			CircleAmount,
			PermitEveryone
		}

		private sealed class WardSettingValue
		{
			public bool UseDefault;

			public bool BoolValue;

			public float FloatValue;

			public Color ColorValue;
		}

		private abstract class WardSettingRow
		{
			protected readonly FieldId Field;

			private readonly string m_labelToken;

			protected Toggle UseDefaultToggle;

			public FieldId FieldId => Field;

			protected bool UseDefault { get; private set; }

			protected WardSettingRow(FieldId field, string labelToken, bool hasOverride)
			{
				Field = field;
				m_labelToken = labelToken;
				UseDefault = !hasOverride;
			}

			public WardSettingValue Capture()
			{
				WardSettingValue wardSettingValue = new WardSettingValue
				{
					UseDefault = UseDefault
				};
				CaptureValue(wardSettingValue);
				return wardSettingValue;
			}

			public void Create(Transform parent, float y)
			{
				//IL_0013: 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_0045: Unknown result type (might be due to invalid IL or missing references)
				CreateRowText(parent, m_labelToken.Localize(), new Vector2(s_labelX, y), s_labelWidth, Color.white);
				GameObject val = GUIManager.Instance.CreateToggle(parent, 26f, 26f);
				SetRect(val, new Vector2(s_useDefaultX, y), 26f, 26f);
				UseDefaultToggle = val.GetComponent<Toggle>();
				UseDefaultToggle.isOn = UseDefault;
				((UnityEvent<bool>)(object)UseDefaultToggle.onValueChanged).AddListener((UnityAction<bool>)delegate(bool value)
				{
					UseDefault = value;
					SetValueInteractable(!value);
				});
				CreateValueControl(parent, y);
				SetValueInteractable(!UseDefault);
			}

			public void Write(ZPackage package)
			{
				package.Write((int)Field);
				package.Write(UseDefault);
				if (!UseDefault)
				{
					WriteValue(package);
				}
			}

			protected abstract void CreateValueControl(Transform parent, float y);

			protected abstract void SetValueInteractable(bool interactable);

			protected abstract void CaptureValue(WardSettingValue value);

			protected abstract void WriteValue(ZPackage package);
		}

		private sealed class BoolRow : WardSettingRow
		{
			private readonly bool m_initialValue;

			private Toggle m_valueToggle;

			public BoolRow(FieldId field, string labelToken, bool hasOverride, bool initialValue)
				: base(field, labelToken, hasOverride)
			{
				m_initialValue = initialValue;
			}

			protected override void CreateValueControl(Transform parent, float y)
			{
				//IL_001e: Unknown result type (might be due to invalid IL or missing references)
				GameObject val = GUIManager.Instance.CreateToggle(parent, 26f, 26f);
				SetRect(val, new Vector2(s_valueBoolX, y), 26f, 26f);
				m_valueToggle = val.GetComponent<Toggle>();
				m_valueToggle.isOn = m_initialValue;
			}

			protected override void SetValueInteractable(bool interactable)
			{
				if ((Object)(object)m_valueToggle != (Object)null)
				{
					((Selectable)m_valueToggle).interactable = interactable;
				}
			}

			protected override void CaptureValue(WardSettingValue value)
			{
				value.BoolValue = (Object)(object)m_valueToggle != (Object)null && m_valueToggle.isOn;
			}

			protected override void WriteValue(ZPackage package)
			{
				package.Write((Object)(object)m_valueToggle != (Object)null && m_valueToggle.isOn);
			}
		}

		private sealed class FloatRow : WardSettingRow
		{
			private readonly float m_initialValue;

			private InputField m_input;

			public FloatRow(FieldId field, string labelToken, bool hasOverride, float initialValue)
				: base(field, labelToken, hasOverride)
			{
				m_initialValue = initialValue;
			}

			protected override void CreateValueControl(Transform parent, float y)
			{
				//IL_0011: Unknown result type (might be due to invalid IL or missing references)
				//IL_0020: Unknown result type (might be due to invalid IL or missing references)
				//IL_002b: Unknown result type (might be due to invalid IL or missing references)
				GameObject val = GUIManager.Instance.CreateInputField(parent, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), new Vector2(s_valueX, y), (ContentType)3, (string)null, 17, 99f, 30f);
				m_input = val.GetComponent<InputField>();
				InputField input = m_input;
				float initialValue = m_initialValue;
				input.text = initialValue.ToString(CultureInfo.InvariantCulture);
				if ((Object)(object)m_input.textComponent != (Object)null)
				{
					m_input.textComponent.alignment = (TextAnchor)3;
				}
			}

			protected override void SetValueInteractable(bool interactable)
			{
				if ((Object)(object)m_input != (Object)null)
				{
					((Selectable)m_input).interactable = interactable;
				}
			}

			protected override void CaptureValue(WardSettingValue value)
			{
				if ((Object)(object)m_input == (Object)null || !float.TryParse(m_input.text, NumberStyles.Float, CultureInfo.InvariantCulture, out value.FloatValue))
				{
					value.FloatValue = 0f;
				}
			}

			protected override void WriteValue(ZPackage package)
			{
				if (!float.TryParse(m_input.text, NumberStyles.Float, CultureInfo.InvariantCulture, out var result))
				{
					result = 0f;
				}
				package.Write(result);
			}
		}

		private class ColorRow : WardSettingRow
		{
			protected readonly Color InitialValue;

			protected InputField Input;

			private Button m_pickerButton;

			public ColorRow(FieldId field, string labelToken, bool hasOverride, Color initialValue)
				: base(field, labelToken, hasOverride)
			{
				//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)
				InitialValue = initialValue;
			}

			protected override void CreateValueControl(Transform parent, float y)
			{
				//IL_0011: Unknown result type (might be due to invalid IL or missing references)
				//IL_0020: Unknown result type (might be due to invalid IL or missing references)
				//IL_002b: Unknown result type (might be due to invalid IL or missing references)
				//IL_005b: 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)
				//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c4: 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_0101: Expected O, but got Unknown
				GameObject val = GUIManager.Instance.CreateInputField(parent, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), new Vector2(s_colorInputX, y), (ContentType)0, "#RRGGBBAA", 17, 99f, 30f);
				Input = val.GetComponent<InputField>();
				Input.text = ColorToHtml(InitialValue, includeAlpha: true);
				ConfigureColorInputText();
				((UnityEvent<string>)(object)Input.onValueChanged).AddListener((UnityAction<string>)delegate
				{
					ConfigureColorInputText();
				});
				GameObject val2 = GUIManager.Instance.CreateButton("$pw_ward_settings_set_color".Localize(), parent, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), new Vector2(s_colorButtonX, y), 99f, 30f);
				m_pickerButton = val2.GetComponent<Button>();
				((UnityEvent)m_pickerButton.onClick).AddListener(new UnityAction(OpenColorPicker));
			}

			protected override void SetValueInteractable(bool interactable)
			{
				if ((Object)(object)Input != (Object)null)
				{
					((Selectable)Input).interactable = interactable;
				}
				if ((Object)(object)m_pickerButton != (Object)null)
				{
					((Selectable)m_pickerButton).interactable = interactable;
				}
			}

			private void OpenColorPicker()
			{
				//IL_0022: Unknown result type (might be due to invalid IL or missing references)
				//IL_004b: Unknown result type (might be due to invalid IL or missing references)
				//IL_005a: 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_0064: 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_0082: Unknown result type (might be due to invalid IL or missing references)
				//IL_008d: Expected O, but got Unknown
				//IL_008d: Expected O, but got Unknown
				//IL_0036: 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)
				if (!TryParseColor(((Object)(object)Input != (Object)null) ? Input.text : "#FFFFFFFF", InitialValue, out var color))
				{
					color = InitialValue;
				}
				GUIManager.Instance.CreateColorPicker(new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), Vector2.zero, color, "$pw_ward_settings_set_color".Localize(), (ColorEvent)delegate(Color color2)
				{
					//IL_0001: Unknown result type (might be due to invalid IL or missing references)
					SetColor(color2);
				}, (ColorEvent)delegate(Color color2)
				{
					//IL_0001: Unknown result type (might be due to invalid IL or missing references)
					SetColor(color2);
				}, true);
			}

			private void SetColor(Color color)
			{
				//IL_0017: Unknown result type (might be due to invalid IL or missing references)
				if ((Object)(object)Input != (Object)null)
				{
					Input.text = ColorToHtml(color, includeAlpha: true);
				}
				ConfigureColorInputText();
			}

			private void ConfigureColorInputText()
			{
				//IL_0035: Unknown result type (might be due to invalid IL or missing references)
				//IL_0066: Unknown result type (might be due to invalid IL or missing references)
				//IL_0049: Unknown result type (might be due to invalid IL or missing references)
				//IL_004e: Unknown result type (might be due to invalid IL or missing references)
				if (!((Object)(object)Input == (Object)null) && !((Object)(object)Input.textComponent == (Object)null))
				{
					if (!TryParseColor(Input.text, InitialValue, out var color))
					{
						color = InitialValue;
					}
					color.a = 1f;
					((Graphic)Input.textComponent).color = color;
					Input.textComponent.alignment = (TextAnchor)3;
				}
			}

			protected override void CaptureValue(WardSettingValue value)
			{
				//IL_0022: 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_0040: Unknown result type (might be due to invalid IL or missing references)
				if (!TryParseColor(((Object)(object)Input != (Object)null) ? Input.text : "#FFFFFFFF", InitialValue, out value.ColorValue))
				{
					value.ColorValue = InitialValue;
				}
			}

			protected override void WriteValue(ZPackage package)
			{
				//IL_0022: Unknown result type (might be due to invalid IL or missing references)
				//IL_003d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0036: 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)
				if (!TryParseColor(((Object)(object)Input != (Object)null) ? Input.text : "#FFFFFFFF", InitialValue, out var color))
				{
					color = InitialValue;
				}
				WriteColor(package, color);
			}
		}

		private sealed class StringColorRow : ColorRow
		{
			public StringColorRow(FieldId field, string labelToken, bool hasOverride, Color initialValue)
				: base(field, labelToken, hasOverride, initialValue)
			{
			}//IL_0004: Unknown result type (might be due to invalid IL or missing references)


			protected override void WriteValue(ZPackage package)
			{
				//IL_0022: Unknown result type (might be due to invalid IL or missing references)
				//IL_003d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0036: 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)
				if (!TryParseColor(((Object)(object)Input != (Object)null) ? Input.text : "#FFFFFFFF", InitialValue, out var color))
				{
					color = InitialValue;
				}
				package.Write(ColorUtility.ToHtmlStringRGBA(color));
			}
		}

		[HarmonyPatch(typeof(Player), "Update")]
		private static class Player_Update_CloseWardSettingsUI
		{
			private static void Postfix()
			{
				if (!((Object)(object)s_panel == (Object)null))
				{
					if (ZInput.GetKeyDown((KeyCode)27, true))
					{
						Close();
					}
					else if ((Object)(object)s_permittedPlayerInput != (Object)null && s_permittedPlayerInput.isFocused && (ZInput.GetKeyDown((KeyCode)13, true) || ZInput.GetKeyDown((KeyCode)271, true)))
					{
						RequestAddOnlinePlayer();
					}
				}
			}
		}

		[HarmonyPatch(typeof(ZoneSystem), "Start")]
		private static class ZoneSystem_Start_RegisterWardSettingsRPC
		{
			private static void Postfix()
			{
				RegisterRPCs();
			}
		}

		[HarmonyPatch(typeof(ZoneSystem), "OnDestroy")]
		private static class ZoneSystem_OnDestroy_ResetWardSettingsRPC
		{
			private static void Postfix()
			{
				ResetRPCRegistration();
			}
		}

		[CompilerGenerated]
		private static class <>O
		{
			public static Action<long, ZPackage> <0>__RPC_ApplyWardSettingsServer;

			public static Action<long, ZPackage> <1>__RPC_RefreshWardSettingsClient;

			public static Action <2>__OpenPermittedPlayersPage;

			public static UnityAction <3>__ToggleGuildBinding;

			public static UnityAction <4>__RemovePassword;

			public static UnityAction <5>__SetNewPassword;

			public static UnityAction <6>__Apply;

			public static UnityAction <7>__Close;

			public static UnityAction <8>__RequestAddOnlinePlayer;
		}

		private const string RPC_ApplyWardSettings = "PW_ApplyWardSettings";

		private const string RPC_RefreshWardSettings = "PW_RefreshWardSettings";

		private const float MaxPanelWidth = 666f;

		private const float MinPanelWidth = 558f;

		private const float PanelHeight = 600f;

		private const int TitleFontSize = 32;

		private const int HeaderFontSize = 18;

		private const int RowFontSize = 17;

		private const float RowStep = 34f;

		private const float AccessRowStep = 30f;

		private const float NoteTopSpacing = 6f;

		private const float PanelPadding = 30.6f;

		private const float ColumnGap = 14.4f;

		private const float UseDefaultColumnWidth = 99f;

		private const float ValueWidth = 99f;

		private const float ValueGap = 7.2f;

		private const float ToggleSize = 26f;

		private const float MaxLabelWidth = 256.5f;

		private const float MinLabelWidth = 148.5f;

		private static float s_panelWidth = 666f;

		private static float s_labelX = -215f;

		private static float s_labelWidth = 260f;

		private static float s_useDefaultX = 55f;

		private static float s_useDefaultHeaderX = 55f;

		private static float s_useDefaultHeaderWidth = 99f;

		private static float s_valueX = 190f;

		private static float s_valueHeaderX = 190f;

		private static float s_valueHeaderWidth = 205.2f;

		private static float s_valueBoolX = 190f;

		private static float s_colorInputX = 170f;

		private static float s_colorButtonX = 285f;

		private static float s_sectionX = -215f;

		private static float s_sectionDividerX = 30f;

		private static float s_sectionDividerWidth = 470f;

		private static string s_layoutLanguageKey = "";

		private static GameObject s_panel;

		private static ZDO s_zdo;

		private static readonly List<WardSettingRow> s_rows = new List<WardSettingRow>();

		private static readonly Dictionary<FieldId, WardSettingValue> s_values = new Dictionary<FieldId, WardSettingValue>();

		private static bool s_rpcRegistered;

		private static bool s_inputBlocked;

		private static bool s_canEditGeneralSettings;

		private static bool s_canChangePassword;

		private static SettingsPage s_currentPage;

		private static Toggle s_passwordEnabledToggle;

		private static InputField s_passwordInput;

		private static Text s_passwordStatusText;

		private static Button s_removePasswordButton;

		private static bool s_passwordEnabled;

		private static bool s_passwordExists;

		private static string s_passwordValue = "";

		private static bool s_passwordValueChanged;

		private static Toggle s_guildAccessEnabledToggle;

		private static Text s_boundGuildText;

		private static Button s_guildBindingButton;

		private static bool s_guildAccessEnabled;

		private static bool s_guildAccessEnabledChanged;

		private static int s_boundGuildId;

		private static string s_boundGuildName = "";

		private static bool s_currentGuildAvailable;

		private static InputField s_permittedPlayerInput;

		private static string s_permittedPlayerQuery = "";

		private static readonly string[] s_sectionLayoutTokens = new string[8] { "$pw_ward_settings_section_range", "$pw_ward_settings_section_visuals", "$pw_ward_settings_section_emission", "$pw_ward_settings_section_bubble", "$pw_ward_settings_section_circle", "$pw_ward_settings_section_access", "$pw_ward_guild_section", "$pw_ward_password_section" };

		private static readonly string[] s_labelLayoutTokens = new string[32]
		{
			"$pw_ward_settings_custom_range", "$pw_ward_settings_range", "$pw_ward_settings_emission_enabled", "$pw_ward_settings_emission_color", "$pw_ward_settings_emission_multiplier", "$pw_ward_settings_visuals", "$pw_ward_settings_permitted_players", "$pw_ward_permitted_add_section", "$pw_ward_settings_bubble_enabled", "$pw_ward_settings_bubble_color",
			"$pw_ward_settings_bubble_visual", "$pw_ward_settings_circle_enabled", "$pw_ward_settings_circle_visual", "$pw_ward_settings_bubble_refraction", "$pw_ward_settings_bubble_wave", "$pw_ward_settings_bubble_glossiness", "$pw_ward_settings_bubble_metallic", "$pw_ward_settings_bubble_normal", "$pw_ward_settings_bubble_depth", "$pw_ward_settings_circle_start",
			"$pw_ward_settings_circle_end", "$pw_ward_settings_circle_speed", "$pw_ward_settings_circle_length", "$pw_ward_settings_circle_width", "$pw_ward_settings_circle_amount", "$pw_ward_settings_permit_everyone", "$pw_ward_guild_enabled", "$pw_ward_guild_bound", "$pw_ward_password_enabled", "$pw_ward_password_status",
			"$pw_ward_password_value", "$pw_ward_password_new"
		};

		internal static void RegisterRPCs()
		{
			if (!s_rpcRegistered && ZRoutedRpc.instance != null)
			{
				if ((Object)(object)ZNet.instance != (Object)null && ZNet.instance.IsServer())
				{
					ZRoutedRpc.instance.Register<ZPackage>("PW_ApplyWardSettings", (Action<long, ZPackage>)RPC_ApplyWardSettingsServer);
				}
				ZRoutedRpc.instance.Register<ZPackage>("PW_RefreshWardSettings", (Action<long, ZPackage>)RPC_RefreshWardSettingsClient);
				s_rpcRegistered = true;
			}
		}

		internal static void ResetRPCRegistration()
		{
			s_rpcRegistered = false;
		}

		internal static void HandleSettingsModeChanged()
		{
			if (!ProtectiveWards.ArePerWardSettingsEnabled())
			{
				Close();
				WardPermittedPlayersUI.Close();
			}
		}

		internal static void Open(PrivateArea ward)
		{
			if (!ProtectiveWards.ArePerWardSettingsEnabled() || (Object)(object)ward == (Object)null || (Object)(object)ward.m_nview == (Object)null || !ward.m_nview.IsValid())
			{
				return;
			}
			WardPermittedPlayersUI.Close();
			Close();
			Player localPlayer = Player.m_localPlayer;
			s_canEditGeneralSettings = ProtectiveWards.CanEditWardSettings(ward, localPlayer);
			s_canChangePassword = WardPasswordProtection.CanChangePassword(ward, localPlayer);
			if (!s_canEditGeneralSettings && !s_canChangePassword)
			{
				if (localPlayer != null)
				{
					((Character)localPlayer).Message((MessageType)2, "$msg_privatezone", 0, (Sprite)null);
				}
				return;
			}
			ZDO zDO = ward.m_nview.GetZDO();
			if (zDO == null)
			{
				return;
			}
			if (GUIManager.Instance == null || (Object)(object)GUIManager.CustomGUIFront == (Object)null)
			{
				if (localPlayer != null)
				{
					((Character)localPlayer).Message((MessageType)2, "ProtectiveWards: GUIManager is not ready", 0, (Sprite)null);
				}
			}
			else
			{
				s_zdo = zDO;
				LoadValuesFromZDO();
				LoadPasswordValuesFromZDO();
				LoadGuildValuesFromZDO();
				OpenPage((!s_canEditGeneralSettings) ? SettingsPage.Access : SettingsPage.Main);
			}
		}

		internal static void Close()
		{
			DestroyPanel();
			s_zdo = null;
			s_values.Clear();
			s_canEditGeneralSettings = false;
			s_canChangePassword = false;
			s_currentPage = SettingsPage.Main;
			s_passwordEnabledToggle = null;
			s_passwordInput = null;
			s_passwordStatusText = null;
			s_removePasswordButton = null;
			s_passwordEnabled = false;
			s_passwordExists = false;
			s_passwordValue = "";
			s_passwordValueChanged = false;
			s_guildAccessEnabledToggle = null;
			s_boundGuildText = null;
			s_guildBindingButton = null;
			s_guildAccessEnabled = false;
			s_guildAccessEnabledChanged = false;
			s_boundGuildId = 0;
			s_boundGuildName = "";
			s_currentGuildAvailable = false;
			s_permittedPlayerInput = null;
			s_permittedPlayerQuery = "";
			SetInputBlocked(blocked: false);
		}

		private static void DestroyPanel()
		{
			if ((Object)(object)s_panel != (Object)null)
			{
				Object.Destroy((Object)(object)s_panel);
			}
			s_panel = null;
			s_rows.Clear();
			s_passwordEnabledToggle = null;
			s_passwordInput = null;
			s_passwordStatusText = null;
			s_removePasswordButton = null;
			s_guildAccessEnabledToggle = null;
			s_boundGuildText = null;
			s_guildBindingButton = null;
			s_permittedPlayerInput = null;
		}

		private static void SetInputBlocked(bool blocked)
		{
			if (s_inputBlocked != blocked)
			{
				GUIManager.BlockInput(blocked);
				s_inputBlocked = blocked;
			}
		}

		private static void CaptureCurrentRows()
		{
			foreach (WardSettingRow s_row in s_rows)
			{
				s_values[s_row.FieldId] = s_row.Capture();
			}
			if (s_currentPage == SettingsPage.Access)
			{
				CaptureGuildControls();
				CapturePasswordControls();
			}
		}

		private static void OpenPage(SettingsPage page)
		{
			if (s_zdo == null)
			{
				Close();
				return;
			}
			CaptureCurrentRows();
			DestroyPanel();
			s_currentPage = page;
			CreatePanel(page);
			SetInputBlocked(blocked: true);
		}

		private static void EnsureLayout()
		{
			string text = BuildLayoutLanguageKey();
			if (!(text == s_layoutLanguageKey))
			{
				s_layoutLanguageKey = text;
				float num = 0f;
				string[] array = s_labelLayoutTokens;
				foreach (string text2 in array)
				{
					num = Math.Max(num, EstimateTextWidth(text2.Localize(), 17) + 14f);
				}
				float num2 = 0f;
				string[] array2 = s_sectionLayoutTokens;
				foreach (string text3 in array2)
				{
					num2 = Math.Max(num2, EstimateTextWidth(text3.Localize(), 18) + 18f);
				}
				float num3 = 205.2f;
				s_labelWidth = Mathf.Clamp(num, 148.5f, 256.5f);
				s_panelWidth = Mathf.Clamp(61.2f + s_labelWidth + 99f + num3 + 28.8f, 558f, 666f);
				float num4 = (0f - s_panelWidth) * 0.5f + 30.6f;
				float num5 = num4 + s_labelWidth;
				float num6 = num5 + 14.4f;
				float num7 = num6 + 99f + 14.4f;
				float num8 = s_panelWidth * 0.5f - 30.6f;
				s_labelX = num4 + s_labelWidth * 0.5f;
				s_sectionX = s_labelX;
				s_useDefaultHeaderWidth = 129f;
				s_useDefaultHeaderX = num6 + 99f - 8f - s_useDefaultHeaderWidth * 0.5f;
				s_useDefaultX = num6 + 99f - 13f;
				s_valueHeaderWidth = num3;
				s_valueHeaderX = num7;
				s_valueX = num7 + 49.5f;
				s_valueBoolX = num7 + 13f + 8f;
				s_colorInputX = s_valueX;
				s_colorButtonX = s_colorInputX + 99f + 7.2f;
				float num9 = num4 + Math.Max(80f, num2);
				s_sectionDividerWidth = Math.Max(80f, num8 - num9);
				s_sectionDividerX = num9 + s_sectionDividerWidth * 0.5f;
			}
		}

		private static string BuildLayoutLanguageKey()
		{
			List<string> list = new List<string>(s_labelLayoutTokens.Length + s_sectionLayoutTokens.Length);
			string[] array = s_labelLayoutTokens;
			foreach (string text in array)
			{
				list.Add(text.Localize());
			}
			string[] array2 = s_sectionLayoutTokens;
			foreach (string text2 in array2)
			{
				list.Add(text2.Localize());
			}
			return string.Join("|", list.ToArray());
		}

		private static float EstimateTextWidth(string text, int fontSize)
		{
			if (string.IsNullOrEmpty(text))
			{
				return 0f;
			}
			float num = 0f;
			foreach (char c in text)
			{
				num = ((!char.IsWhiteSpace(c)) ? ((c > '\u007f') ? ((c >= 'Ѐ' && c <= 'ӿ') ? (num + (float)fontSize * 0.58f) : ((c < '⺀') ? (num + (float)fontSize * 0.62f) : (num + (float)fontSize * 0.9f))) : (num + (float)fontSize * 0.52f)) : (num + (float)fontSize * 0.28f));
			}
			return num;
		}

		private static void CreatePanel(SettingsPage page)
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: 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)
			EnsureLayout();
			s_panel = GUIManager.Instance.CreateWoodpanel(GUIManager.CustomGUIFront.transform, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), Vector2.zero, s_panelWidth, 600f, true);
			s_panel.SetActive(true);
			string text = page switch
			{
				SettingsPage.Access => "$pw_ward_settings_access_title", 
				SettingsPage.CircleVisual => "$pw_ward_settings_circle_visual_title", 
				SettingsPage.BubbleVisual => "$pw_ward_settings_bubble_visual_title", 
				SettingsPage.Visuals => "$pw_ward_settings_visuals_title", 
				_ => "$pw_ward_settings_title", 
			};
			float num = 300f;
			CreateText(text.Localize(), new Vector2(0f, num - 35f), 32, s_panelWidth - 61.2f, 44f, GUIManager.Instance.ValheimOrange, (TextAnchor)4, (FontStyle)1);
			if (page != SettingsPage.Access || s_canEditGeneralSettings)
			{
				CreateColumnHeaders(num - 72f);
			}
			float y = num - 96f;
			switch (page)
			{
			case SettingsPage.Visuals:
				CreateVisualRows(ref y);
				CreateFooterButtons(showBack: true);
				break;
			case SettingsPage.BubbleVisual:
				CreateBubbleVisualRows(ref y);
				CreateFooterButtons(showBack: true, SettingsPage.Visuals);
				break;
			case SettingsPage.CircleVisual:
				CreateCircleVisualRows(ref y);
				CreateFooterButtons(showBack: true, SettingsPage.Visuals);
				break;
			case SettingsPage.Access:
				CreateAccessRows(ref y);
				CreateFooterButtons(s_canEditGeneralSettings);
				break;
			default:
				CreateMainRows(ref y);
				CreateFooterButtons(showBack: false);
				break;
			}
		}

		private static void CreateMainRows(ref float y)
		{
			AddSection("$pw_ward_settings_section_range", ref y);
			AddBool(FieldId.CustomRange, "$pw_ward_settings_custom_range", ref y);
			AddFloat(FieldId.Range, "$pw_ward_settings_range", ref y);
			AddSection("$pw_ward_settings_section_visuals", ref y);
			AddNavigationRow("$pw_ward_settings_visuals", "$pw_ward_settings_open", SettingsPage.Visuals, ref y);
			AddSection("$pw_ward_settings_section_access", ref y);
			AddNavigationRow("$pw_ward_settings_access", "$pw_ward_settings_open", SettingsPage.Access, ref y);
			AddNavigationRow("$pw_ward_settings_permitted_players", "$pw_ward_settings_open", OpenPermittedPlayersPage, ref y);
			CreateAddOnlinePlayerRow(ref y);
		}

		private static void CreateVisualRows(ref float y)
		{
			AddSection("$pw_ward_settings_section_emission", ref y);
			AddBool(FieldId.CustomColor, "$pw_ward_settings_emission_enabled", ref y);
			AddEmissionColor(ref y);
			AddFloat(FieldId.EmissionColorMultiplier, "$pw_ward_settings_emission_multiplier", ref y);
			AddSection("$pw_ward_settings_section_bubble", ref y);
			AddBool(FieldId.BubbleEnabled, "$pw_ward_settings_bubble_enabled", ref y);
			AddColor(FieldId.BubbleColor, "$pw_ward_settings_bubble_color", ref y);
			AddNavigationRow("$pw_ward_settings_bubble_visual", "$pw_ward_settings_open", SettingsPage.BubbleVisual, ref y);
			AddSection("$pw_ward_settings_section_circle", ref y);
			AddBool(FieldId.CircleEnabled, "$pw_ward_settings_circle_enabled", ref y);
			AddNavigationRow("$pw_ward_settings_circle_visual", "$pw_ward_settings_open", SettingsPage.CircleVisual, ref y);
		}

		private static void CreateBubbleVisualRows(ref float y)
		{
			AddSection("$pw_ward_settings_section_bubble", ref y);
			AddFloat(FieldId.BubbleRefraction, "$pw_ward_settings_bubble_refraction", ref y);
			AddFloat(FieldId.BubbleWave, "$pw_ward_settings_bubble_wave", ref y);
			AddFloat(FieldId.BubbleGlossiness, "$pw_ward_settings_bubble_glossiness", ref y);
			AddFloat(FieldId.BubbleMetallic, "$pw_ward_settings_bubble_metallic", ref y);
			AddFloat(FieldId.BubbleNormalScale, "$pw_ward_settings_bubble_normal", ref y);
			AddFloat(FieldId.BubbleDepthFade, "$pw_ward_settings_bubble_depth", ref y);
		}

		private static void CreateCircleVisualRows(ref float y)
		{
			AddSection("$pw_ward_settings_section_circle", ref y);
			AddStringColor(FieldId.CircleStartColor, "$pw_ward_settings_circle_start", ref y);
			AddStringColor(FieldId.CircleEndColor, "$pw_ward_settings_circle_end", ref y);
			AddFloat(FieldId.CircleSpeed, "$pw_ward_settings_circle_speed", ref y);
			AddFloat(FieldId.CircleLength, "$pw_ward_settings_circle_length", ref y);
			AddFloat(FieldId.CircleWidth, "$pw_ward_settings_circle_width", ref y);
			AddFloat(FieldId.CircleAmount, "$pw_ward_settings_circle_amount", ref y);
		}

		private static void CreateAccessRows(ref float y)
		{
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			if (s_canEditGeneralSettings)
			{
				AddAccessSection("$pw_ward_settings_section_access", ref y);
				AddAccessBool(FieldId.PermitEveryone, "$pw_ward_settings_permit_everyone", ref y);
				AddInfoNote("$pw_ward_settings_permit_everyone_note", ref y, 34f, new Color(0.85f, 0.85f, 0.85f), -5f);
				if (GuildsCompat.IsEnabled)
				{
					CreateGuildRows(ref y);
				}
			}
			if (s_canChangePassword)
			{
				CreatePasswordRows(ref y);
			}
		}

		private static void CreateGuildRows(ref float y)
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0102: Unknown result type (might be due to invalid IL or missing references)
			//IL_012d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0154: Unknown result type (might be due to invalid IL or missing references)
			//IL_014d: 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_0197: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0212: Unknown result type (might be due to invalid IL or missing references)
			//IL_01dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e8: Expected O, but got Unknown
			AddAccessSection("$pw_ward_guild_section", ref y);
			CreateRowText(s_panel.transform, "$pw_ward_guild_enabled".Localize(), new Vector2(s_labelX, y), s_labelWidth, Color.white);
			GameObject val = GUIManager.Instance.CreateToggle(s_panel.transform, 26f, 26f);
			SetRect(val, new Vector2(s_valueBoolX, y), 26f, 26f);
			s_guildAccessEnabledToggle = val.GetComponent<Toggle>();
			s_guildAccessEnabledToggle.isOn = s_guildAccessEnabled;
			((Selectable)s_guildAccessEnabledToggle).interactable = HasBoundGuild();
			((UnityEvent<bool>)(object)s_guildAccessEnabledToggle.onValueChanged).AddListener((UnityAction<bool>)delegate(bool value)
			{
				s_guildAccessEnabled = value;
				s_guildAccessEnabledChanged = true;
			});
			y -= 30f;
			CreateRowText(s_panel.transform, "$pw_ward_guild_bound".Localize(), new Vector2(s_labelX, y), s_labelWidth, Color.white);
			GameObject val2 = CreateRowText(s_panel.transform, GetBoundGuildDisplay(), new Vector2(GetPasswordInputX(150f, 170f), y), 150f, (Color)(HasBoundGuild() ? Color.white : new Color(1f, 0.72f, 0.42f)));
			s_boundGuildText = val2.GetComponent<Text>();
			GameObject val3 = GUIManager.Instance.CreateButton(GetGuildBindingButtonText(), s_panel.transform, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), new Vector2(GetPasswordButtonX(), y), 170f, 32f);
			s_guildBindingButton = val3.GetComponent<Button>();
			ButtonClickedEvent onClick = s_guildBindingButton.onClick;
			object obj = <>O.<3>__ToggleGuildBinding;
			if (obj == null)
			{
				UnityAction val4 = ToggleGuildBinding;
				<>O.<3>__ToggleGuildBinding = val4;
				obj = (object)val4;
			}
			((UnityEvent)onClick).AddListener((UnityAction)obj);
			y -= 30f;
			AddInfoNote("$pw_ward_guild_note", ref y, 48f, new Color(0.85f, 0.85f, 0.85f), -2f);
			UpdateGuildControls();
		}

		private static void CreatePasswordRows(ref float y)
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			AddAccessSection("$pw_ward_password_section", ref y);
			CreateRowText(s_panel.transform, "$pw_ward_password_enabled".Localize(), new Vector2(s_labelX, y), s_labelWidth, Color.white);
			GameObject val = GUIManager.Instance.CreateToggle(s_panel.transform, 26f, 26f);
			SetRect(val, new Vector2(s_valueBoolX, y), 26f, 26f);
			s_passwordEnabledToggle = val.GetComponent<Toggle>();
			s_passwordEnabledToggle.isOn = s_passwordEnabled;
			((UnityEvent<bool>)(object)s_passwordEnabledToggle.onValueChanged).AddListener((UnityAction<bool>)delegate(bool value)
			{
				s_passwordEnabled = value;
			});
			y -= 30f;
			if (ProtectiveWards.wardPasswordFieldMode.Value == ProtectiveWards.WardPasswordFieldMode.SetNewPasswordOnly)
			{
				CreateSetNewPasswordRows(ref y);
			}
			else
			{
				CreateEditablePasswordRow(ref y);
			}
		}

		private static void CreateSetNewPasswordRows(ref float y)
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0151: 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_01ab: 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_01c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_011b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0120: Unknown result type (might be due to invalid IL or missing references)
			//IL_0126: Expected O, but got Unknown
			//IL_022b: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0201: Expected O, but got Unknown
			CreateRowText(s_panel.transform, "$pw_ward_password_status".Localize(), new Vector2(s_labelX, y), s_labelWidth, Color.white);
			GameObject val = CreateRowText(s_panel.transform, GetPasswordStatusToken().Localize(), new Vector2(GetPasswordInputX(150f, 170f), y), 150f, (Color)(s_passwordExists ? Color.white : new Color(1f, 0.72f, 0.42f)));
			s_passwordStatusText = val.GetComponent<Text>();
			GameObject val2 = GUIManager.Instance.CreateButton("$pw_ward_password_remove".Localize(), s_panel.transform, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), new Vector2(GetPasswordButtonX(), y), 170f, 32f);
			s_removePasswordButton = val2.GetComponent<Button>();
			((Selectable)s_removePasswordButton).interactable = s_passwordExists;
			ButtonClickedEvent onClick = s_removePasswordButton.onClick;
			object obj = <>O.<4>__RemovePassword;
			if (obj == null)
			{
				UnityAction val3 = RemovePassword;
				<>O.<4>__RemovePassword = val3;
				obj = (object)val3;
			}
			((UnityEvent)onClick).AddListener((UnityAction)obj);
			y -= 30f;
			CreateRowText(s_panel.transform, "$pw_ward_password_new".Localize(), new Vector2(s_labelX, y), s_labelWidth, Color.white);
			CreatePasswordInput(y, showPassword: false, "", 150f, GetPasswordInputX(150f, 170f));
			GameObject val4 = GUIManager.Instance.CreateButton("$pw_ward_password_set_new".Localize(), s_panel.transform, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), new Vector2(GetPasswordButtonX(), y), 170f, 32f);
			ButtonClickedEvent onClick2 = val4.GetComponent<Button>().onClick;
			object obj2 = <>O.<5>__SetNewPassword;
			if (obj2 == null)
			{
				UnityAction val5 = SetNewPassword;
				<>O.<5>__SetNewPassword = val5;
				obj2 = (object)val5;
			}
			((UnityEvent)onClick2).AddListener((UnityAction)obj2);
			y -= 30f;
			AddInfoNote("$pw_ward_password_hash_note", ref y, 44f, new Color(0.85f, 0.85f, 0.85f), -5f);
		}

		private static void CreateEditablePasswordRow(ref float y)
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			CreateRowText(s_panel.transform, "$pw_ward_password_value".Localize(), new Vector2(s_labelX, y), s_labelWidth, Color.white);
			CreatePasswordInput(y, showPassword: true, s_passwordValue, 320f, GetPasswordWideInputX(320f));
			y -= 30f;
			AddInfoNote("$pw_ward_password_plaintext_note", ref y, 44f, new Color(0.85f, 0.85f, 0.85f), -5f);
		}

		private static void AddInfoNote(string token, ref float y, float height, Color color, float topSpacing = 6f)
		{
			//IL_001d: 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)
			y -= topSpacing;
			CreateText(token.Localize(), new Vector2(0f, y - height * 0.5f), 15, s_panelWidth - 61.2f, height, color, (TextAnchor)0, (FontStyle)0);
			y -= height;
		}

		private static void CreatePasswordInput(float y, bool showPassword, string initialValue, float width, float x)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = GUIManager.Instance.CreateInputField(s_panel.transform, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), new Vector2(x, y), (ContentType)((!showPassword) ? 7 : 0), "$pw_ward_password_placeholder".Localize(), 17, width, 30f);
			s_passwordInput = val.GetComponent<InputField>();
			s_passwordInput.characterLimit = 64;
			s_passwordInput.text = initialValue ?? "";
			if ((Object)(object)s_passwordInput.textComponent != (Object)null)
			{
				s_passwordInput.textComponent.alignment = (TextAnchor)3;
			}
			((UnityEvent<string>)(object)s_passwordInput.onValueChanged).AddListener((UnityAction<string>)delegate(string value)
			{
				s_passwordValue = value;
				s_passwordValueChanged = true;
			});
		}

		private static float GetPasswordButtonX()
		{
			float num = s_panelWidth * 0.5f - 30.6f;
			return num - 85f;
		}

		private static float GetPasswordInputX(float inputWidth, float buttonWidth)
		{
			float num = GetPasswordButtonX() - buttonWidth * 0.5f;
			return num - 7.2f - inputWidth * 0.5f;
		}

		private static float GetPasswordWideInputX(float width)
		{
			float num = s_panelWidth * 0.5f - 30.6f;
			return num - width * 0.5f;
		}

		private static string GetPasswordStatusToken()
		{
			return s_passwordExists ? "$pw_ward_password_is_set" : "$pw_ward_password_not_set";
		}

		private static void CreateColumnHeaders(float y)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			CreateText("$pw_ward_settings_use_default".Localize(), new Vector2(s_useDefaultHeaderX, y), 18, s_useDefaultHeaderWidth, 30f, Color.white, (TextAnchor)5, (FontStyle)1);
			CreateText("$pw_ward_settings_value".Localize(), new Vector2(s_valueHeaderX + s_valueHeaderWidth * 0.5f, y), 18, s_valueHeaderWidth, 30f, Color.white, (TextAnchor)3, (FontStyle)1);
		}

		private static void CreateFooterButtons(bool showBack, SettingsPage backPage = SettingsPage.Main)
		{
			//IL_00b3: 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_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Expected O, but got Unknown
			//IL_0133: Unknown result type (might be due to invalid IL or missing references)
			//IL_0142: Unknown result type (might be due to invalid IL or missing references)
			//IL_014d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0104: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: Expected O, but got Unknown
			//IL_017f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0184: Unknown result type (might be due to invalid IL or missing references)
			//IL_018a: Expected O, but got Unknown
			float num = -255f;
			if (showBack)
			{
				GameObject val = GUIManager.Instance.CreateButton("$pw_ward_settings_back".Localize(), s_panel.transform, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), new Vector2(0f, num), 170f, 50f);
				((UnityEvent)val.GetComponent<Button>().onClick).AddListener((UnityAction)delegate
				{
					OpenPage(backPage);
				});
				return;
			}
			GameObject val2 = GUIManager.Instance.CreateButton("$pw_ward_settings_apply".Localize(), s_panel.transform, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), new Vector2(-120f, num), 220f, 50f);
			ButtonClickedEvent onClick = val2.GetComponent<Button>().onClick;
			object obj = <>O.<6>__Apply;
			if (obj == null)
			{
				UnityAction val3 = Apply;
				<>O.<6>__Apply = val3;
				obj = (object)val3;
			}
			((UnityEvent)onClick).AddListener((UnityAction)obj);
			GameObject val4 = GUIManager.Instance.CreateButton("$pw_ward_settings_cancel".Localize(), s_panel.transform, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), new Vector2(140f, num), 170f, 50f);
			ButtonClickedEvent onClick2 = val4.GetComponent<Button>().onClick;
			object obj2 = <>O.<7>__Close;
			if (obj2 == null)
			{
				UnityAction val5 = Close;
				<>O.<7>__Close = val5;
				obj2 = (object)val5;
			}
			((UnityEvent)onClick2).AddListener((UnityAction)obj2);
		}

		private static void Apply()
		{
			//IL_0116: 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_00e7: Expected O, but got Unknown
			if (s_zdo == null)
			{
				Close();
				return;
			}
			CaptureCurrentRows();
			bool flag = false;
			if (s_canChangePassword && ProtectiveWards.wardPasswordFieldMode.Value == ProtectiveWards.WardPasswordFieldMode.EditablePassword)
			{
				flag = s_passwordValueChanged || !s_passwordExists;
			}
			bool flag2 = (flag ? (!string.IsNullOrEmpty(s_passwordValue)) : s_passwordExists);
			if (s_canChangePassword && s_passwordEnabled && !flag2)
			{
				Player localPlayer = Player.m_localPlayer;
				if (localPlayer != null)
				{
					((Character)localPlayer).Message((MessageType)2, "$pw_ward_password_required", 0, (Sprite)null);
				}
				return;
			}
			if (s_canEditGeneralSettings)
			{
				ZPackage val = CreateApplyPackage();
				if ((Object)(object)ZNet.instance != (Object)null && ZNet.instance.IsServer())
				{
					RPC_ApplyWardSettingsServer(0L, new ZPackage(val.GetArray()));
				}
				else
				{
					ZRoutedRpc.instance.InvokeRoutedRPC("PW_ApplyWardSettings", new object[1] { val });
				}
			}
			if (s_canChangePassword)
			{
				WardPasswordProtection.RequestSettingsUpdate(s_zdo.m_uid, s_passwordEnabled, flag, s_passwordValue);
			}
			Player localPlayer2 = Player.m_localPlayer;
			if (localPlayer2 != null)
			{
				((Character)localPlayer2).Message((MessageType)2, "$pw_ward_settings_applied", 0, (Sprite)null);
			}
			Close();
		}

		private static void CapturePasswordControls()
		{
			if ((Object)(object)s_passwordEnabledToggle != (Object)null)
			{
				s_passwordEnabled = s_passwordEnabledToggle.isOn;
			}
			if (ProtectiveWards.wardPasswordFieldMode.Value == ProtectiveWards.WardPasswordFieldMode.EditablePassword && (Object)(object)s_passwordInput != (Object)null)
			{
				s_passwordValue = s_passwordInput.text ?? "";
			}
		}

		private static void CaptureGuildControls()
		{
			if (!((Object)(object)s_guildAccessEnabledToggle == (Object)null))
			{
				bool isOn = s_guildAccessEnabledToggle.isOn;
				if (isOn != s_guildAccessEnabled)
				{
					s_guildAccessEnabledChanged = true;
				}
				s_guildAccessEnabled = isOn;
			}
		}

		private static void LoadGuildValuesFromZDO()
		{
			s_guildAccessEnabled = GuildsCompat.IsGuildAccessEnabled(s_zdo);
			s_guildAccessEnabledChanged = false;
			s_boundGuildId = GuildsCompat.GetBoundGuildId(s_zdo);
			s_boundGuildName = GuildsCompat.GetBoundGuildName(s_zdo);
			s_currentGuildAvailable = HasCurrentPlayerGuild();
		}

		private static bool HasBoundGuild()
		{
			return s_boundGuildId > 0 && !string.IsNullOrEmpty(s_boundGuildName);
		}

		private static string GetBoundGuildDisplay()
		{
			return HasBoundGuild() ? s_boundGuildName : "$pw_ward_guild_not_bound".Localize();
		}

		private static bool HasCurrentPlayerGuild()
		{
			Player localPlayer = Player.m_localPlayer;
			GuildsCompat.GuildIdentity guild;
			return (Object)(object)localPlayer != (Object)null && GuildsCompat.TryGetPlayerGuild(localPlayer.GetPlayerID(), out guild);
		}

		private static string GetGuildBindingButtonText()
		{
			if (HasBoundGuild())
			{
				return "$pw_ward_guild_unbind".Localize();
			}
			return s_currentGuildAvailable ? "$pw_ward_guild_bind_current".Localize() : "$pw_ward_guild_not_found".Localize();
		}

		private static void ToggleGuildBinding()
		{
			//IL_0027: 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)
			if (s_zdo != null && GuildsCompat.IsEnabled)
			{
				if (HasBoundGuild())
				{
					GuildsCompat.RequestUnbindGuild(s_zdo.m_uid);
				}
				else if (s_currentGuildAvailable)
				{
					GuildsCompat.RequestBindCurrentGuild(s_zdo.m_uid);
				}
			}
		}

		internal static void OnGuildBindingResult(ZDOID wardID, GuildsCompat.GuildBindingResult result, bool enabled, int guildId, string guildName)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			if (s_zdo != null && ((ZDOID)(ref s_zdo.m_uid)).Equals(wardID) && (result == GuildsCompat.GuildBindingResult.Success || result == GuildsCompat.GuildBindingResult.NoGuild))
			{
				if (result == GuildsCompat.GuildBindingResult.Success)
				{
					s_guildAccessEnabled = enabled;
					s_guildAccessEnabledChanged = false;
					s_boundGuildId = guildId;
					s_boundGuildName = guildName ?? "";
				}
				else
				{
					s_currentGuildAvailable = false;
				}
				UpdateGuildControls();
			}
			Player localPlayer = Player.m_localPlayer;
			if (!((Object)(object)localPlayer == (Object)null))
			{
				switch (result)
				{
				case GuildsCompat.GuildBindingResult.Success:
					((Character)localPlayer).Message((MessageType)2, "$pw_ward_guild_updated", 0, (Sprite)null);
					break;
				case GuildsCompat.GuildBindingResult.NoGuild:
					((Character)localPlayer).Message((MessageType)2, "$pw_ward_guild_no_guild", 0, (Sprite)null);
					break;
				case GuildsCompat.GuildBindingResult.NotAuthorized:
					((Character)localPlayer).Message((MessageType)2, "$msg_privatezone", 0, (Sprite)null);
					break;
				case GuildsCompat.GuildBindingResult.TooFar:
					((Character)localPlayer).Message((MessageType)2, "$pw_ward_guild_too_far", 0, (Sprite)null);
					break;
				default:
					((Character)localPlayer).Message((MessageType)2, "$pw_ward_guild_unavailable", 0, (Sprite)null);
					break;
				}
			}
		}

		private static void UpdateGuildControls()
		{
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			bool flag = HasBoundGuild();
			bool flag2 = !flag && s_currentGuildAvailable;
			if ((Object)(object)s_guildAccessEnabledToggle != (Object)null)
			{
				s_guildAccessEnabledToggle.SetIsOnWithoutNotify(s_guildAccessEnabled);
				((Selectable)s_guildAccessEnabledToggle).interactable = flag;
			}
			if ((Object)(object)s_boundGuildText != (Object)null)
			{
				s_boundGuildText.text = GetBoundGuildDisplay();
				((Graphic)s_boundGuildText).color = (Color)(flag ? Color.white : new Color(1f, 0.72f, 0.42f));
			}
			if ((Object)(object)s_guildBindingButton != (Object)null)
			{
				((Selectable)s_guildBindingButton).interactable = flag || flag2;
				Text componentInChildren = ((Component)s_guildBindingButton).GetComponentInChildren<Text>();
				if ((Object)(object)componentInChildren != (Object)null)
				{
					componentInChildren.text = GetGuildBindingButtonText();
				}
			}
		}

		private static void SetNewPassword()
		{
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			if (s_zdo == null || !s_canChangePassword)
			{
				return;
			}
			CapturePasswordControls();
			string text = (((Object)(object)s_passwordInput != (Object)null) ? s_passwordInput.text : "");
			if (string.IsNullOrEmpty(text))
			{
				Player localPlayer = Player.m_localPlayer;
				if (localPlayer != null)
				{
					((Character)localPlayer).Message((MessageType)2, "$pw_ward_password_required", 0, (Sprite)null);
				}
			}
			else
			{
				WardPasswordProtection.RequestSettingsUpdate(s_zdo.m_uid, s_passwordEnabled, replacePassword: true, text);
			}
		}

		private static void RemovePassword()
		{
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			if (s_zdo != null && s_canChangePassword)
			{
				s_passwordEnabled = false;
				if ((Object)(object)s_passwordEnabledToggle != (Object)null)
				{
					s_passwordEnabledToggle.isOn = false;
				}
				WardPasswordProtection.RequestSettingsUpdate(s_zdo.m_uid, enabled: false, replacePassword: true, "");
			}
		}

		private static void LoadPasswordValuesFromZDO()
		{
			s_passwordEnabled = s_zdo != null && s_zdo.GetBool(WardPasswordProtection.s_passwordProtectionEnabled, false);
			s_passwordExists = WardPasswordProtection.HasPassword(s_zdo);
			s_passwordValue = WardPasswordProtection.GetEditablePassword(s_zdo);
			s_passwordValueChanged = false;
		}

		internal static void OnPasswordSettingsResult(ZDOID wardID, WardPasswordProtection.PasswordSettingsResult result, bool enabled, bool hasPassword)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			bool flag = s_zdo != null && ((ZDOID)(ref s_zdo.m_uid)).Equals(wardID);
			if (result == WardPasswordProtection.PasswordSettingsResult.Success && flag)
			{
				s_passwordEnabled = enabled;
				s_passwordExists = hasPassword;
				if (!hasPassword)
				{
					s_passwordValue = "";
				}
				if ((Object)(object)s_passwordEnabledToggle != (Object)null)
				{
					s_passwordEnabledToggle.isOn = enabled;
				}
				if (ProtectiveWards.wardPasswordFieldMode.Value == ProtectiveWards.WardPasswordFieldMode.SetNewPasswordOnly && (Object)(object)s_passwordInput != (Object)null)
				{
					s_passwordInput.text = "";
					s_passwordValueChanged = false;
				}
				UpdatePasswordStatusControls();
			}
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null)
			{
				return;
			}
			switch (result)
			{
			case WardPasswordProtection.PasswordSettingsResult.Success:
				if ((Object)(object)s_panel != (Object)null)
				{
					((Character)localPlayer).Message((MessageType)2, "$pw_ward_password_settings_saved", 0, (Sprite)null);
				}
				break;
			case WardPasswordProtection.PasswordSettingsResult.MissingPassword:
				((Character)localPlayer).Message((MessageType)2, "$pw_ward_password_required", 0, (Sprite)null);
				break;
			case WardPasswordProtection.PasswordSettingsResult.NotAuthorized:
				((Character)localPlayer).Message((MessageType)2, "$msg_privatezone", 0, (Sprite)null);
				break;
			case WardPasswordProtection.PasswordSettingsResult.TooFar:
				((Character)localPlayer).Message((MessageType)2, "$pw_ward_password_too_far", 0, (Sprite)null);
				break;
			case WardPasswordProtection.PasswordSettingsResult.PasswordTooLong:
				((Character)localPlayer).Message((MessageType)2, "$pw_ward_password_too_long", 0, (Sprite)null);
				break;
			default:
				((Character)localPlayer).Message((MessageType)2, "$pw_ward_password_unavailable", 0, (Sprite)null);
				break;
			}
		}

		private static void UpdatePasswordStatusControls()
		{
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)s_passwordStatusText != (Object)null)
			{
				s_passwordStatusText.text = GetPasswordStatusToken().Localize();
				((Graphic)s_passwordStatusText).color = (Color)(s_passwordExists ? Color.white : new Color(1f, 0.72f, 0.42f));
			}
			if ((Object)(object)s_removePasswordButton != (Object)null)
			{
				((Selectable)s_removePasswordButton).interactable = s_passwordExists;
			}
		}

		private static ZPackage CreateApplyPackage()
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			ZPackage val = new ZPackage();
			val.Write(s_zdo.m_uid);
			val.Write(((Object)(object)Player.m_localPlayer != (Object)null) ? Player.m_localPlayer.GetPlayerID() : 0);
			val.Write(s_values.Count);
			foreach (KeyValuePair<FieldId, WardSettingValue> s_value in s_values)
			{
				WriteStoredField(val, s_value.Key, s_value.Value);
			}
			bool flag = GuildsCompat.IsEnabled && s_guildAccessEnabledChanged;
			val.Write(flag);
			if (flag)
			{
				val.Write(s_guildAccessEnabled);
			}
			return val;
		}

		private static void WriteStoredField(ZPackage package, FieldId field, WardSettingValue value)
		{
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			package.Write((int)field);
			package.Write(value.UseDefault);
			if (!value.UseDefault)
			{
				switch (field)
				{
				case FieldId.BubbleEnabled:
				case FieldId.CustomRange:
				case FieldId.CustomColor:
				case FieldId.CircleEnabled:
				case FieldId.PermitEveryone:
					package.Write(value.BoolValue);
					break;
				case FieldId.BubbleRefraction:
				case FieldId.BubbleWave:
				case FieldId.BubbleGlossiness:
				case FieldId.BubbleMetallic:
				case FieldId.BubbleNormalScale:
				case FieldId.BubbleDepthFade:
				case FieldId.Range:
				case FieldId.EmissionColorMultiplier:
				case FieldId.CircleSpeed:
				case FieldId.CircleLength:
				case FieldId.CircleWidth:
				case FieldId.CircleAmount:
					package.Write(value.FloatValue);
					break;
				case FieldId.BubbleColor:
				case FieldId.EmissionColor:
					WriteColor(package, value.ColorValue);
					break;
				case FieldId.CircleStartColor:
				case FieldId.CircleEndColor:
					package.Write(ColorUtility.ToHtmlStringRGBA(value.ColorValue));
					break;
				}
			}
		}

		private static void RPC_ApplyWardSettingsServer(long sender, ZPackage package)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Expected O, but got Unknown
			//IL_005e: 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)
			ZDOID val = package.ReadZDOID();
			long claimedPlayerID = package.ReadLong();
			if (!ProtectiveWards.TryGetRoutedPlayer(sender, claimedPlayerID, out var player))
			{
				return;
			}
			ZDO ward = WardZdoUtils.GetWard(val);
			if (ward != null && ProtectiveWards.CanApplyWardSettings(ward, player.PlayerID))
			{
				int num = package.ReadInt();
				ZPackage val2 = new ZPackage();
				val2.Write(val);
				val2.Write(num);
				for (int i = 0; i < num; i++)
				{
					ApplyField(ward, package, val2);
				}
				bool flag = package.ReadBool();
				val2.Write(flag);
				if (flag)
				{
					bool enabled = package.ReadBool();
					GuildsCompat.SetGuildAccessEnabled(ward, enabled);
					val2.Write(GuildsCompat.IsGuildAccessEnabled(ward));
				}
				BroadcastWardSettingsRefresh(val2);
				ProtectiveWards.LogInfo($"Ward settings applied for {val}");
			}
		}

		private static void BroadcastWardSettingsRefresh(ZPackage package)
		{
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Expected O, but got Unknown
			if (ZRoutedRpc.instance != null)
			{
				ZRoutedRpc.instance.InvokeRoutedRPC(ZRoutedRpc.Everybody, "PW_RefreshWardSettings", new object[1] { package });
			}
			else
			{
				RPC_RefreshWardSettingsClient(0L, new ZPackage(package.GetArray()));
			}
		}

		private static void RPC_RefreshWardSettingsClient(long _, ZPackage package)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			ZDOID val = package.ReadZDOID();
			ZDOMan instance = ZDOMan.instance;
			ZDO val2 = ((instance != null) ? instance.GetZDO(val) : null);
			if (val2 != null)
			{
				int num = package.ReadInt();
				for (int i = 0; i < num; i++)
				{
					ApplyField(val2, package);
				}
				if (package.ReadBool())
				{
					GuildsCompat.SetGuildAccessEnabled(val2, package.ReadBool());
				}
				RefreshLoadedWard(val);
			}
		}

		private static void ApplyField(ZDO zdo, ZPackage package, ZPackage mirror = null)
		{
			FieldId fieldId = (FieldId)package.ReadInt();
			bool flag = package.ReadBool();
			if (mirror != null)
			{
				mirror.Write((int)fieldId);
			}
			if (mirror != null)
			{
				mirror.Write(flag);
			}
			switch (fieldId)
			{
			case FieldId.BubbleEnabled:
				ApplyBool(zdo, ProtectiveWards.s_bubbleEnabled, flag, package, mirror);
				break;
			case FieldId.BubbleColor:
				ApplyColor(zdo, ProtectiveWards.s_bubbleColor, ProtectiveWards.s_bubbleColorAlpha, flag, package, mirror);
				break;
			case FieldId.BubbleRefraction:
				ApplyFloat(zdo, ProtectiveWards.s_bubbleRefractionIntensity, flag, package, mirror);
				break;
			case FieldId.BubbleWave:
				ApplyFloat(zdo, ProtectiveWards.s_bubbleWaveVel, flag, package, mirror);
				break;
			case FieldId.BubbleGlossiness:
				ApplyFloat(zdo, ProtectiveWards.s_bubbleGlossiness, flag, package, mirror);
				break;
			case FieldId.BubbleMetallic:
				ApplyFloat(zdo, ProtectiveWards.s_bubbleMetallic, flag, package, mirror);
				break;
			case FieldId.BubbleNormalScale:
				ApplyFloat(zdo, ProtectiveWards.s_bubbleNormalScale, flag, package, mirror);
				break;
			case FieldId.BubbleDepthFade:
				ApplyFloat(zdo, ProtectiveWards.s_bubbleDepthFade, flag, package, mirror);
				break;
			case FieldId.CustomRange:
				ApplyBool(zdo, ProtectiveWards.s_customRange, flag, package, mirror);
				break;
			case FieldId.Range:
				ApplyFloat(zdo, ProtectiveWards.s_range, flag, package, mirror);
				break;
			case FieldId.CustomColor:
				ApplyBool(zdo, ProtectiveWards.s_customColor, flag, package, mirror);
				break;
			case FieldId.EmissionColor:
				ApplyColor(zdo, ProtectiveWards.s_color, 0, flag, package, mirror, writeAlpha: false);
				break;
			case FieldId.EmissionColorMultiplier:
				ApplyFloat(zdo, ProtectiveWards.s_colorMultiplier, flag, package, mirror);
				break;
			case FieldId.CircleEnabled:
				ApplyBool(zdo, ProtectiveWards.s_circleEnabled, flag, package, mirror);
				break;
			case FieldId.CircleStartColor:
				ApplyString(zdo, ProtectiveWards.s_circleStartColor, flag, package, mirror);
				break;
			case FieldId.CircleEndColor:
				ApplyString(zdo, ProtectiveWards.s_circleEndColor, flag, package, mirror);
				break;
			case FieldId.CircleSpeed:
				ApplyFloat(zdo, ProtectiveWards.s_circleSpeed, flag, package, mirror);
				break;
			case FieldId.CircleLength:
				ApplyFloat(zdo, ProtectiveWards.s_circleLength, flag, package, mirror);
				break;
			case FieldId.CircleWidth:
				ApplyFloat(zdo, ProtectiveWards.s_circleWidth, flag, package, mirror);
				break;
			case FieldId.CircleAmount:
				ApplyFloat(zdo, ProtectiveWards.s_circleAmount, flag, package, mirror);
				break;
			case FieldId.PermitEveryone:
				ApplyBool(zdo, ProtectiveWards.s_permitEveryone, flag, package, mirror);
				break;
			}
		}

		private static Color ReadColor(ZPackage package)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			return new Color(package.ReadSingle(), package.ReadSingle(), package.ReadSingle(), package.ReadSingle());
		}

		private static void WriteColor(ZPackage package, Color color)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			if (package != null)
			{
				package.Write(color.r);
				package.Write(color.g);
				package.Write(color.b);
				package.Write(color.a);
			}
		}

		private static void ApplyBool(ZDO zdo, int key, bool useDefault, ZPackage package, ZPackage mirror = null)
		{
			if (useDefault)
			{
				ProtectiveWards.RemoveZdoBool(zdo, key);
				return;
			}
			bool flag = package.ReadBool();
			if (mirror != null)
			{
				mirror.Write(flag);
			}
			zdo.Set(key, flag);
		}

		private static void ApplyFloat(ZDO zdo, int key, bool useDefault, ZPackage package, ZPackage mirror = null)
		{
			if (useDefault)
			{
				ProtectiveWards.RemoveZdoFloat(zdo, key);
				return;
			}
			float num = package.ReadSingle();
			if (mirror != null)
			{
				mirror.Write(num);
			}
			zdo.Set(key, num);
		}

		private static void ApplyColor(ZDO zdo, int colorKey, int alphaKey, bool useDefault, ZPackage package, ZPackage mirror = null, bool writeAlpha = true)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			if (useDefault)
			{
				ProtectiveWards.RemoveZdoVec3(zdo, colorKey);
				if (writeAlpha)
				{
					ProtectiveWards.RemoveZdoFloat(zdo, alphaKey);
				}
				return;
			}
			Color val = ReadColor(package);
			WriteColor(mirror, val);
			zdo.Set(colorKey, new Vector3(val.r, val.g, val.b));
			if (writeAlpha)
			{
				zdo.Set(alphaKey, val.a);
			}
		}

		private static void ApplyString(ZDO zdo, int key, bool useDefault, ZPackage package, ZPackage mirror = null)
		{
			if (useDefault)
			{
				ProtectiveWards.RemoveZdoString(zdo, key);
				return;
			}
			string text = package.ReadString();
			if (mirror != null)
			{
				mirror.Write(text);
			}
			zdo.Set(key, string.IsNullOrEmpty(text) ? "#FFFFFFFF" : text);
		}

		private static void RefreshLoadedWard(ZDOID zdoID)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			PrivateArea val = WardZdoUtils.FindLoadedWard(zdoID);
			if (!((Object)(object)val == (Object)null))
			{
				ProtectiveWards.RefreshWardVisuals(val);
				val.m_addPermittedEffect.Create(((Component)val).transform.position, ((Component)val).transform.rotation, (Transform)null, 1f, -1);
			}
		}

		private static void LoadValuesFromZDO()
		{
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_0145: Unknown result type (might be due to invalid IL or missing references)
			//IL_015c: Unknown result type (might be due to invalid IL or missing references)
			s_values.Clear();
			StoreBool(FieldId.CustomRange, ProtectiveWards.s_customRange, ProtectiveWards.setWardRange.Value);
			StoreFloat(FieldId.Range, ProtectiveWards.s_range, ProtectiveWards.wardRange.Value);
			StoreBool(FieldId.CustomColor, ProtectiveWards.s_customColor, ProtectiveWards.wardEmissionColorEnabled.Value);
			StoreEmissionColor();
			StoreFloat(FieldId.EmissionColorMultiplier, ProtectiveWards.s_colorMultiplier, ProtectiveWards.wardEmissionColorMultiplier.Value);
			StoreBool(FieldId.BubbleEnabled, ProtectiveWards.s_bubbleEnabled, ProtectiveWards.wardBubbleShow.Value);
			StoreColor(FieldId.BubbleColor, ProtectiveWards.s_bubbleColor, ProtectiveWards.s_bubbleColorAlpha, ProtectiveWards.wardBubbleColor.Value);
			StoreFloat(FieldId.BubbleRefraction, ProtectiveWards.s_bubbleRefractionIntensity, ProtectiveWards.wardBubbleRefractionIntensity.Value);
			StoreFloat(FieldId.BubbleWave, ProtectiveWards.s_bubbleWaveVel, ProtectiveWards.wardBubbleWaveIntensity.Value);
			StoreFloat(FieldId.BubbleGlossiness, ProtectiveWards.s_bubbleGlossiness, ProtectiveWards.wardBubbleGlossiness.Value);
			StoreFloat(FieldId.BubbleMetallic, ProtectiveWards.s_bubbleMetallic, ProtectiveWards.wardBubbleMetallic.Value);
			StoreFloat(FieldId.BubbleNormalScale, ProtectiveWards.s_bubbleNormalScale, ProtectiveWards.wardBubbleNormalScale.Value);
			StoreFloat(FieldId.BubbleDepthFade, ProtectiveWards.s_bubbleDepthFade, ProtectiveWards.wardBubbleDepthFade.Value);
			StoreBool(FieldId.CircleEnabled, ProtectiveWards.s_circleEnabled, ProtectiveWards.wardAreaMarkerPatch.Value);
			StoreStringColor(FieldId.CircleStartColor, ProtectiveWards.s_circleStartColor, ProtectiveWards.wardAreaMarkerStartColor.Value);
			StoreStringColor(FieldId.CircleEndColor, ProtectiveWards.s_circleEndColor, ProtectiveWards.wardAreaMarkerEndColor.Value);
			StoreFloat(FieldId.CircleSpeed, ProtectiveWards.s_circleSpeed, ProtectiveWards.wardAreaMarkerSpeed.Value);
			StoreFloat(FieldId.CircleLength, ProtectiveWards.s_circleLength, ProtectiveWards.wardAreaMarkerLength.Value);
			StoreFloat(FieldId.CircleWidth, ProtectiveWards.s_circleWidth, ProtectiveWards.wardAreaMarkerWidth.Value);
			StoreFloat(FieldId.CircleAmount, ProtectiveWards.s_circleAmount, ProtectiveWards.wardAreaMarkerAmount.Value);
			StoreBool(FieldId.PermitEveryone, ProtectiveWards.s_permitEveryone, ProtectiveWards.permitEveryone.Value);
		}

		private static void StoreBool(FieldId field, int key, bool defaultValue)
		{
			bool flag = ProtectiveWards.HasZdoBool(s_zdo, key);
			s_values[field] = new WardSettingValue
			{
				UseDefault = !flag,
				BoolValue = (flag ? s_zdo.GetBool(key, defaultValue) : defaultValue)
			};
		}

		private static void StoreFloat(FieldId field, int key, float defaultValue)
		{
			bool flag = ProtectiveWards.HasZdoFloat(s_zdo, key);
			s_values[field] = new WardSettingValue
			{
				UseDefault = !flag,
				FloatValue = (flag ? s_zdo.GetFloat(key, defaultValue) : defaultValue)
			};
		}

		private static void StoreColor(FieldId field, int colorKey, int alphaKey, Color defaultValue)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: 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_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			bool flag = ProtectiveWards.HasZdoVec3(s_zdo, colorKey) || ProtectiveWards.HasZdoFloat(s_zdo, alphaKey);
			Vector3 wardVec3Setting = ProtectiveWards.GetWardVec3Setting(s_zdo, colorKey, new Vector3(defaultValue.r, defaultValue.g, defaultValue.b));
			float wardFloatSetting = ProtectiveWards.GetWardFloatSetting(s_zdo, alphaKey, defaultValue.a);
			s_values[field] = new WardSettingValue
			{
				UseDefault = !flag,
				ColorValue = new Color(wardVec3Setting.x, wardVec3Setting.y, wardVec3Setting.z, wardFloatSetting)
			};
		}

		private static void StoreEmissionColor()
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			bool flag = ProtectiveWards.HasZdoVec3(s_zdo, ProtectiveWards.s_color);
			Vector3 wardVec3Setting = ProtectiveWards.GetWardVec3Setting(s_zdo, ProtectiveWards.s_color, new Vector3(ProtectiveWards.wardEmissionColor.Value.r, ProtectiveWards.wardEmissionColor.Value.g, ProtectiveWards.wardEmissionColor.Value.b));
			s_values[FieldId.EmissionColor] = new WardSettingValue
			{
				UseDefault = !flag,
				ColorValue = new Color(wardVec3Setting.x, wardVec3Setting.y, wardVec3Setting.z, 1f)
			};
		}

		private static void StoreStringColor(FieldId field, int key, Color defaultValue)
		{
			//IL_001e: 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_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_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)
			bool flag = ProtectiveWards.HasZdoString(s_zdo, key);
			string text = (flag ? s_zdo.GetString(key, ColorUtility.ToHtmlStringRGBA(defaultValue)) : ColorUtility.ToHtmlStringRGBA(defaultValue));
			Color colorValue = default(Color);
			if (!ColorUtility.TryParseHtmlString("#" + text, ref colorValue))
			{
				colorValue = defaultValue;
			}
			s_values[field] = new WardSettingValue
			{
				UseDefault = !flag,
				ColorValue = colorValue
			};
		}

		private static WardSettingValue GetValue(FieldId field)
		{
			return s_values[field];
		}

		private static void AddBool(FieldId field, string labelToken, ref float y)
		{
			WardSettingValue value = GetValue(field);
			BoolRow boolRow = new BoolRow(field, labelToken, !value.UseDefault, value.BoolValue);
			boolRow.Create(s_panel.transform, y);
			s_rows.Add(boolRow);
			y -= 34f;
		}

		private static void AddFloat(FieldId field, string labelToken, ref float y)
		{
			WardSettingValue value = GetValue(field);
			FloatRow floatRow = new FloatRow(field, labelToken, !value.UseDefault, value.FloatValue);
			floatRow.Create(s_panel.transform, y);
			s_rows.Add(floatRow);
			y -= 34f;
		}

		private static void AddColor(FieldId field, string labelToken, ref float y)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			WardSettingValue value = GetValue(field);
			ColorRow colorRow = new ColorRow(field, labelToken, !value.UseDefault, value.ColorValue);
			colorRow.Create(s_panel.transform, y);
			s_rows.Add(colorRow);
			y -= 34f;
		}

		private static void AddEmissionColor(ref float y)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			WardSettingValue value = GetValue(FieldId.EmissionColor);
			ColorRow colorRow = new ColorRow(FieldId.EmissionColor, "$pw_ward_settings_emission_color", !value.UseDefault, value.ColorValue);
			colorRow.Create(s_panel.transform, y);
			s_rows.Add(colorRow);
			y -= 34f;
		}

		private static void AddStringColor(FieldId field, string labelToken, ref float y)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			WardSettingValue value = GetValue(field);
			StringColorRow stringColorRow = new StringColorRow(field, labelToken, !value.UseDefault, value.ColorValue);
			stringColorRow.Create(s_panel.transform, y);
			s_rows.Add(stringColorRow);
			y -= 34f;
		}

		private static void AddAccessBool(FieldId field, string labelToken, ref float y)
		{
			AddBool(field, labelToken, ref y);
			y += 4f;
		}

		private static void AddAccessSection(string labelToken, ref float y)
		{
			//IL_0018: 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)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			y -= 4f;
			CreateText(labelToken.Localize(), new Vector2(s_sectionX, y), 18, s_labelWidth, 30f, GUIManager.Instance.ValheimOrange, (TextAnchor)3, (FontStyle)1);
			CreateDivider(new Vector2(s_sectionDividerX, y - 1f), s_sectionDividerWidth);
			y -= 30f;
		}

		private static void AddSection(string labelToken, ref float y)
		{
			//IL_0018: 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)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			y -= 8f;
			CreateText(labelToken.Localize(), new Vector2(s_sectionX, y), 18, s_labelWidth, 30f, GUIManager.Instance.ValheimOrange, (TextAnchor)3, (FontStyle)1);
			CreateDivider(new Vector2(s_sectionDividerX, y - 1f), s_sectionDividerWidth);
			y -= 34f;
		}

		private static void AddNavigationRow(string labelToken, string buttonToken, SettingsPage targetPage, ref float y)
		{
			AddNavigationRow(labelToken, buttonToken, delegate
			{
				OpenPage(targetPage);
			}, ref y);
		}

		private static void AddNavigationRow(string labelToken, string buttonToken, Action action, ref float y)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Expected O, but got Unknown
			CreateRowText(s_panel.transform, labelToken.Localize(), new Vector2(s_labelX, y), s_labelWidth, Color.white);
			GameObject val = GUIManager.Instance.CreateButton(buttonToken.Localize(), s_panel.transform, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), new Vector2(s_valueX, y), 99f, 32f);
			((UnityEvent)val.GetComponent<Button>().onClick).AddListener((UnityAction)delegate
			{
				action?.Invoke();
			});
			y -= 34f;
		}

		private static void CreateAddOnlinePlayerRow(ref float y)
		{
			//IL_004c: 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_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: 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_0165: Unknown result type (might be due to invalid IL or missing references)
			//IL_016d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_019f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01aa: Expected O, but got Unknown
			float num = s_panelWidth * 0.5f - 30.6f;
			float num2 = num - 55f;
			float num3 = num2 - 55f - 7.2f;
			float num4 = num3 - 95f;
			CreateRowText(s_panel.transform, "$pw_ward_permitted_add_section".Localize(), new Vector2(s_labelX, y), s_labelWidth, Color.white);
			GameObject val = GUIManager.Instance.CreateInputField(s_panel.transform, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), new Vector2(num4, y), (ContentType)0, "$pw_ward_permitted_placeholder".Localize(), 17, 190f, 30f);
			s_permittedPlayerInput = val.GetComponent<InputField>();
			s_permittedPlayerInput.characterLimit = 64;
			s_permittedPlayerInput.text = s_permittedPlayerQuery;
			((UnityEvent<string>)(object)s_permittedPlayerInput.onValueChanged).AddListener((UnityAction<string>)delegate(string value)
			{
				s_permittedPlayerQuery = value ?? "";
			});
			if ((Object)(object)s_permittedPlayerInput.textComponent != (Object)null)
			{
				s_permittedPlayerInput.textComponent.alignment = (TextAnchor)3;
			}
			GameObject val2 = GUIManager.Instance.CreateButton("$pw_ward_permitted_add".Localize(), s_panel.transform, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), new Vector2(num2, y), 110f, 32f);
			ButtonClickedEvent onClick = val2.GetComponent<Button>().onClick;
			object obj = <>O.<8>__RequestAddOnlinePlayer;
			if (obj == null)
			{
				UnityAction val3 = RequestAddOnlinePlayer;
				<>O.<8>__RequestAddOnlinePlayer = val3;
				obj = (object)val3;
			}
			((UnityEvent)onClick).AddListener((UnityAction)obj);
			y -= 34f;
			AddInfoNote("$pw_ward_permitted_add_note", ref y, 34f, new Color(0.85f, 0.85f, 0.85f), -5f);
		}

		private static void RequestAddOnlinePlayer()
		{
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			if (s_zdo != null)
			{
				WardPermittedPlayersUI.RequestAddPlayer(query: s_permittedPlayerQuery = (((Object)(object)s_permittedPlayerInput != (Object)null) ? s_permittedPlayerInput.text.Trim() : s_permittedPlayerQuery.Trim()), wardID: s_zdo.m_uid);
			}
		}

		internal static void HandlePermittedPlayerAdded(ZDOID wardID)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			if (s_zdo != null && ((ZDOID)(ref s_zdo.m_uid)).Equals(wardID))
			{
				s_permittedPlayerQuery = "";
				if ((Object)(object)s_permittedPlayerInput != (Object)null)
				{
					s_permittedPlayerInput.text = "";
				}
			}
		}

		private static void OpenPermittedPlayersPage()
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			if (s_zdo != null)
			{
				PrivateArea val = WardZdoUtils.FindLoadedWard(s_zdo.m_uid);
				if ((Object)(object)val != (Object)null)
				{
					WardPermittedPlayersUI.Open(val);
				}
			}
		}

		private static GameObject CreateText(string text, Vector2 position, int fontSize, float width, float height, Color color, TextAnchor alignment = (TextAnchor)3, FontStyle fontStyle = (FontStyle)0)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: 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_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = GUIManager.Instance.CreateText(text, s_panel.transform, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), position, GUIManager.Instance.AveriaSerif, fontSize, color, true, Color.black, width, height, false);
			ConfigureText(val, alignment, fontStyle);
			return val;
		}

		private static GameObject CreateRowText(Transform parent, string text, Vector2 position, float width, Color color)
		{
			//IL_0012: 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_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = GUIManager.Instance.CreateText(text, parent, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), position, GUIManager.Instance.AveriaSerif, 17, color, true, Color.black, width, 30f, false);
			ConfigureText(val, (TextAnchor)3, (FontStyle)0);
			return val;
		}

		private static void ConfigureText(GameObject obj, TextAnchor alignment, FontStyle fontStyle)
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			Text val = ((obj != null) ? obj.GetComponent<Text>() : null);
			if (!((Object)(object)val == (Object)null))
			{
				val.alignment = alignment;
				val.fontStyle = fontStyle;
			}
		}

		private static void CreateDivider(Vector2 position, float width)
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Expected O, but got Unknown
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("Divider", new Type[2]
			{
				typeof(RectTransform),
				typeof(Image)
			});
			val.transform.SetParent(s_panel.transform, false);
			Image component = val.GetComponent<Image>();
			((Graphic)component).color = new Color(1f, 0.62f, 0.18f, 0.55f);
			SetRect(val, position, width, 2f);
		}

		private static void SetRect(GameObject obj, Vector2 position, float width, float height)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			RectTransform component = obj.GetComponent<RectTransform>();
			component.anchorMin = new Vector2(0.5f, 0.5f);
			component.anchorMax = new Vector2(0.5f, 0.5f);
			component.anchoredPosition = position;
			component.sizeDelta = new Vector2(width, height);
		}

		private static string ColorToHtml(Color color, bool includeAlpha)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			return includeAlpha ? ("#" + ColorUtility.ToHtmlStringRGBA(color)) : ("#" + ColorUtility.ToHtmlStringRGB(color));
		}

		private static bool TryParseColor(string value, Color fallback, out Color color)
		{
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			value = value.Trim();
			if (!value.StartsWith("#"))
			{
				value = "#" + value;
			}
			if (ColorUtility.TryParseHtmlString(value, ref color))
			{
				return true;
			}
			color = fallback;
			return false;
		}
	}
	internal static class WardPermittedPlayersUI
	{
		private enum PermittedPlayerAction
		{
			Refresh,
			Add,
			Remove
		}

		private enum PermittedPlayerResult
		{
			Success,
			NoMatch,
			MultipleMatches,
			AlreadyPermitted,
			NotPermitted,
			NotAuthorized,
			TooFar,
			Unavailable
		}

		[HarmonyPatch(typeof(Player), "Update")]
		private static class Player_Update_ClosePermittedPlayersUI
		{
			private static void Postfix()
			{
				if (!((Object)(object)s_panel == (Object)null) && ZInput.GetKeyDown((KeyCode)27, true))
				{
					Close();
				}
			}
		}

		[HarmonyPatch(typeof(ZoneSystem), "Start")]
		private static class ZoneSystem_Start_RegisterPermittedPlayersRPCs
		{
			private static void Postfix()
			{
				RegisterRPCs();
			}
		}

		[HarmonyPatch(typeof(ZoneSystem), "OnDestroy")]
		private static class ZoneSystem_OnDestroy_ResetPermittedPlayersRPCs
		{
			private static void Postfix()
			{
				ResetRPCRegistration();
				Close();
			}
		}

		[CompilerGenerated]
		private static class <>O
		{
			public static UnityAction <0>__BackToWardSettings;

			public static Action<long, ZPackage> <1>__RPC_UpdatePermittedPlayersResultClient;

			public static Action<long, ZPackage> <2>__RPC_UpdatePermittedPlayersServer;
		}

		[Serializable]
		[CompilerGenerated]
		private sealed class <>c
		{
			public static readonly <>c <>9 = new <>c();

			public static Func<KeyValuePair<long, string>, string> <>9__20_0;

			public static UnityAction <>9__23_0;

			public static UnityAction <>9__23_1;

			public static Func<Player, string> <>9__35_0;

			public static Func<Player, bool> <>9__36_0;

			public static Func<KeyValuePair<long, string>, string> <>9__37_0;

			internal string <LoadPermittedPlayers>b__20_0(KeyValuePair<long, string> player)
			{
				return player.Value;
			}

			internal void <CreatePaginationControls>b__23_0()
			{
				ChangePage(-1);
			}

			internal void <CreatePaginationControls>b__23_1()
			{
				ChangePage(1);
			}

			internal string <RPC_UpdatePermittedPlayersServer>b__35_0(Player player)
			{
				return player.GetPlayerName();
			}

			internal bool <FindOnlinePlayers>b__36_0(Player player)
			{
				return (Object)(object)player != (Object)null;
			}

			internal string <SendResult>b__37_0(KeyValuePair<long, string> player)
			{
				return player.Value;
			}
		}

		private const string RPC_UpdatePermittedPlayers = "PW_UpdatePermittedPlayers";

		private const string RPC_UpdatePermittedPlayersResult = "PW_UpdatePermittedPlayersResult";

		private const float PanelWidth = 600f;

		private const float PanelHeight = 600f;

		private const float PanelPadding = 30f;

		private const int PlayersPerPage = 10;

		private const int RowFontSize = 17;

		private const float RowStep = 38f;

		private static readonly List<KeyValuePair<long, string>> s_permittedPlayers = new List<KeyValuePair<long, string>>();

		private static GameObject s_panel;

		private static ZDOID s_wardID = ZDOID.None;

		private static long s_wardCreatorID;

		private static int s_page;

		private static bool s_rpcRegistered;

		private static bool s_inputBlocked;

		internal static void Open(PrivateArea ward)
		{
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			if (!ProtectiveWards.ArePerWardSettingsEnabled() || ward == null)
			{
				return;
			}
			ZNetView nview = ward.m_nview;
			if (((nview != null) ? new bool?(nview.IsValid()) : ((bool?)null)) != true || !ProtectiveWards.CanEditWardSettings(ward, Player.m_localPlayer))
			{
				return;
			}
			if (GUIManager.Instance == null || (Object)(object)GUIManager.CustomGUIFront == (Object)null)
			{
				Player localPlayer = Player.m_localPlayer;
				if (localPlayer != null)
				{
					((Character)localPlayer).Message((MessageType)2, "ProtectiveWards: GUIManager is not ready", 0, (Sprite)null);
				}
				return;
			}
			WardSettingsUI.Close();
			Close();
			s_wardID = ward.m_nview.GetZDO().m_uid;
			Piece piece = ward.m_piece;
			s_wardCreatorID = ((piece != null) ? piece.GetCreator() : 0);
			s_page = 0;
			LoadPermittedPlayers(ward);
			CreatePanel();
			SetInputBlocked(blocked: true);
			RequestUpdate(s_wardID, PermittedPlayerAction.Refresh, 0L, "");
		}

		internal static void Close()
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)s_panel != (Object)null)
			{
				Object.Destroy((Object)(object)s_panel);
			}
			s_panel = null;
			s_wardID = ZDOID.None;
			s_wardCreatorID = 0L;
			s_page = 0;
			s_permittedPlayers.Clear();
			SetInputBlocked(blocked: false);
		}

		private static void SetInputBlocked(bool blocked)
		{
			if (s_inputBlocked != blocked)
			{
				GUIManager.BlockInput(blocked);
				s_inputBlocked = blocked;
			}
		}

		private static void LoadPermittedPlayers(PrivateArea ward)
		{
			s_permittedPlayers.Clear();
			if (!((Object)(object)ward == (Object)null))
			{
				s_permittedPlayers.AddRange(WardZdoUtils.GetPermittedPlayers(ward.GetWardZDO()).OrderBy<KeyValuePair<long, string>, string>((KeyValuePair<long, string> player) => player.Value, StringComparer.OrdinalIgnoreCase));
			}
		}

		private static void CreatePanel()
		{
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			if (GUIManager.Instance == null || (Object)(object)GUIManager.CustomGUIFront == (Object)null || ((ZDOID)(ref s_wardID)).IsNone())
			{
				Close();
				return;
			}
			if ((Object)(object)s_panel != (Object)null)
			{
				Object.Destroy((Object)(object)s_panel);
			}
			s_panel = GUIManager.Instance.CreateWoodpanel(GUIManager.CustomGUIFront.transform, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), Vector2.zero, 600f, 600f, true);
			s_panel.SetActive(true);
			CreateText("$pw_ward_permitted_title".Localize(), new Vector2(0f, 265f), 32, 540f, 44f, GUIManager.Instance.ValheimOrange, (TextAnchor)4, (FontStyle)1);
			float y = 205f;
			CreatePermittedPlayerRows(ref y);
			CreatePaginationControls();
			CreateBackButton();
		}

		private static void CreatePermittedPlayerRows(ref float y)
		{
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0128: Unknown result type (might be due to invalid IL or missing references)
			//IL_0137: Unknown result type (might be due to invalid IL or missing references)
			//IL_0140: Unknown result type (might be due to invalid IL or missing references)
			//IL_0178: Unknown result type (might be due to invalid IL or missing references)
			//IL_0182: Expected O, but got Unknown
			int pageCount = GetPageCount();
			s_page = Mathf.Clamp(s_page, 0, pageCount - 1);
			if (s_permittedPlayers.Count == 0)
			{
				CreateText("$pw_ward_permitted_empty".Localize(), new Vector2(0f, y - 10f), 17, 540f, 36f, new Color(0.85f, 0.85f, 0.85f), (TextAnchor)4, (FontStyle)0);
				return;
			}
			int num = s_page * 10;
			int num2 = Math.Min(num + 10, s_permittedPlayers.Count);
			float num3 = -270f;
			float num4 = 270f;
			float num5 = num4 - 60f;
			float num6 = num5 - 60f - 8f - num3;
			for (int i = num; i < num2; i++)
			{
				KeyValuePair<long, string> keyValuePair = s_permittedPlayers[i];
				CreateRowText(GetPlayerDisplayName(keyValuePair.Value), new Vector2(num3 + num6 * 0.5f, y), num6, Color.white);
				GameObject val = GUIManager.Instance.CreateButton("$pw_ward_permitted_remove".Localize(), s_panel.transform, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), new Vector2(num5, y), 120f, 32f);
				long playerID = keyValuePair.Key;
				((UnityEvent)val.GetComponent<Button>().onClick).AddListener((UnityAction)delegate
				{
					RequestRemovePlayer(playerID);
				});
				y -= 38f;
			}
		}

		private static void CreatePaginationControls()
		{
			//IL_0037: 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_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_011e: Unknown result type (might be due to invalid IL or missing references)
			//IL_012d: 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_009a: 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_00a5: Expected O, but got Unknown
			//IL_0186: Unknown result type (might be due to invalid IL or missing references)
			//IL_018b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0191: Expected O, but got Unknown
			int pageCount = GetPageCount();
			if (pageCount <= 1)
			{
				return;
			}
			GameObject val = GUIManager.Instance.CreateButton("<", s_panel.transform, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), new Vector2(-80f, -205f), 50f, 34f);
			Button component = val.GetComponent<Button>();
			((Selectable)component).interactable = s_page > 0;
			ButtonClickedEvent onClick = component.onClick;
			object obj = <>c.<>9__23_0;
			if (obj == null)
			{
				UnityAction val2 = delegate
				{
					ChangePage(-1);
				};
				<>c.<>9__23_0 = val2;
				obj = (object)val2;
			}
			((UnityEvent)onClick).AddListener((UnityAction)obj);
			CreateText("$pw_ward_permitted_page".Localize((s_page + 1).ToString(), pageCount.ToString()), new Vector2(0f, -205f), 17, 90f, 30f, Color.white, (TextAnchor)4, (FontStyle)0);
			GameObject val3 = GUIManager.Instance.CreateButton(">", s_panel.transform, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), new Vector2(80f, -205f), 50f, 34f);
			Button component2 = val3.GetComponent<Button>();
			((Selectable)component2).interactable = s_page + 1 < pageCount;
			ButtonClickedEvent onClick2 = component2.onClick;
			object obj2 = <>c.<>9__23_1;
			if (obj2 == null)
			{
				UnityAction val4 = delegate
				{
					ChangePage(1);
				};
				<>c.<>9__23_1 = val4;
				obj2 = (object)val4;
			}
			((UnityEvent)onClick2).AddListener((UnityAction)obj2);
		}

		private static void CreateBackButton()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Expected O, but got Unknown
			GameObject val = GUIManager.Instance.CreateButton("$pw_ward_settings_back".Localize(), s_panel.transform, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), new Vector2(0f, -255f), 170f, 50f);
			ButtonClickedEvent onClick = val.GetComponent<Button>().onClick;
			object obj = <>O.<0>__BackToWardSettings;
			if (obj == null)
			{
				UnityAction val2 = BackToWardSettings;
				<>O.<0>__BackToWardSettings = val2;
				obj = (object)val2;
			}
			((UnityEvent)onClick).AddListener((UnityAction)obj);
		}

		private static GameObject CreateText(string text, Vector2 position, int fontSize, float width, float height, Color color, TextAnchor alignment, FontStyle fontStyle = (FontStyle)0)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: 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_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: 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)
			GameObject val = GUIManager.Instance.CreateText(text, s_panel.transform, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), position, GUIManager.Instance.AveriaSerif, fontSize, color, true, Color.black, width, height, false);
			Text component = val.GetComponent<Text>();
			if ((Object)(object)component != (Object)null)
			{
				component.alignment = alignment;
				component.fontStyle = fontStyle;
			}
			return val;
		}

		private static GameObject CreateRowText(string text, Vector2 position, float width, Color color)
		{
			//IL_0002: 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)
			return CreateText(text, position, 17, width, 30f, color, (TextAnchor)3, (FontStyle)0);
		}

		private static string GetPlayerDisplayName(string playerName)
		{
			return CensorShittyWords.FilterUGC(playerName ?? "", (UGCType)2, s_wardCreatorID);
		}

		private static int GetPageCount()
		{
			return Math.Max(1, (s_permittedPlayers.Count + 10 - 1) / 10);
		}

		private static void ChangePage(int direction)
		{
			s_page = Mathf.Clamp(s_page + direction, 0, GetPageCount() - 1);
			CreatePanel();
		}

		internal static void RequestAddPlayer(ZDOID wardID, string query)
		{
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			string text = (query ?? "").Trim();
			if (text.Length == 0)
			{
				Player localPlayer = Player.m_localPlayer;
				if (localPlayer != null)
				{
					((Character)localPlayer).Message((MessageType)2, "$pw_permit_no_match".Localize(text), 0, (Sprite)null);
				}
			}
			else
			{
				RequestUpdate(wardID, PermittedPlayerAction.Add, 0L, text);
			}
		}

		private static void RequestRemovePlayer(long playerID)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			RequestUpdate(s_wardID, PermittedPlayerAction.Remove, playerID, "");
		}

		private static void RequestUpdate(ZDOID wardID, PermittedPlayerAction action, long targetPlayerID, string query)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Expected O, but got Unknown
			//IL_002a: 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_0086: Expected O, but got Unknown
			Player localPlayer = Player.m_localPlayer;
			if (!((Object)(object)localPlayer == (Object)null) && !((ZDOID)(ref wardID)).IsNone())
			{
				ZPackage val = new ZPackage();
				val.Write(wardID);
				val.Write(localPlayer.GetPlayerID());
				val.Write((int)action);
				val.Write(targetPlayerID);
				val.Write(query ?? "");
				ZNet instance = ZNet.instance;
				if (instance != null && instance.IsServer())
				{
					RPC_UpdatePermittedPlayersServer(0L, new ZPackage(val.GetArray()));
				}
				else if (ZRoutedRpc.instance != null)
				{
					ZRoutedRpc.instance.InvokeRoutedRPC("PW_UpdatePermittedPlayers", new object[1] { val });
				}
			}
		}

		private static void RegisterRPCs()
		{
			if (!s_rpcRegistered && ZRoutedRpc.instance != null)
			{
				ZRoutedRpc.instance.Register<ZPackage>("PW_UpdatePermittedPlayersResult", (Action<long, ZPackage>)RPC_UpdatePermittedPlayersResultClient);
				ZNet instance = ZNet.instance;
				if (instance != null && instance.IsServer())
				{
					ZRoutedRpc.instance.Register<ZPackage>("PW_UpdatePermittedPlayers", (Action<long, ZPackage>)RPC_UpdatePermittedPlayersServer);
				}
				s_rpcRegistered = true;
			}
		}

		private static void ResetRPCRegistration()
		{
			s_rpcRegistered = false;
		}

		private static void RPC_UpdatePermittedPlayersServer(long sender, ZPackage package)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: 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)
			//IL_01e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a4: Unknown result type (might be due to invalid IL or missing references)
			ZDOID val = package.ReadZDOID();
			long claimedPlayerID = package.ReadLong();
			PermittedPlayerAction permittedPlayerAction = (PermittedPlayerAction)package.ReadInt();
			long playerID = package.ReadLong();
			string text = (package.ReadString() ?? "").Trim();
			if (text.Length > 64)
			{
				text = text.Substring(0, 64);
			}
			if (!ProtectiveWards.TryGetRoutedPlayer(sender, claimedPlayerID, out var player))
			{
				return;
			}
			if (!WardZdoUtils.TryGetWard(val, out var zdo))
			{
				SendResult(sender, val, permittedPlayerAction, PermittedPlayerResult.Unavailable, "", null);
				return;
			}
			if (!ProtectiveWards.CanApplyWardSettings(zdo, player.PlayerID))
			{
				SendResult(sender, val, permittedPlayerAction, PermittedPlayerResult.NotAuthorized, "", zdo);
				return;
			}
			string playerName = "";
			PermittedPlayerResult result = PermittedPlayerResult.Success;
			if (permittedPlayerAction < PermittedPlayerAction.Refresh || permittedPlayerAction > PermittedPlayerAction.Remove)
			{
				result = PermittedPlayerResult.Unavailable;
			}
			else
			{
				switch (permittedPlayerAction)
				{
				case PermittedPlayerAction.Add:
				{
					List<Player> list = FindOnlinePlayers(text);
					if (list.Count == 0)
					{
						result = PermittedPlayerResult.NoMatch;
						playerName = text;
						break;
					}
					if (list.Count > 1)
					{
						result = PermittedPlayerResult.MultipleMatches;
						playerName = string.Join(", ", list.Select((Player val3) => val3.GetPlayerName()).ToArray());
						break;
					}
					Player val2 = list[0];
					playerID = val2.GetPlayerID();
					playerName = val2.GetPlayerName();
					if (WardZdoUtils.IsExplicitlyPermitted(zdo, playerID))
					{
						result = PermittedPlayerResult.AlreadyPermitted;
						break;
					}
					WardZdoUtils.AddPermitted(zdo, playerID, playerName);
					ProtectiveWards.LogInfo($"Added {playerName} to ward {val} permitted list from ward settings");
					break;
				}
				case PermittedPlayerAction.Remove:
					if (!WardZdoUtils.RemovePermitted(zdo, playerID, out playerName))
					{
						result = PermittedPlayerResult.NotPermitted;
					}
					else
					{
						ProtectiveWards.LogInfo($"Removed {playerName} from ward {val} permitted list from ward settings");
					}
					break;
				}
			}
			SendResult(sender, val, permittedPlayerAction, result, playerName, zdo);
		}

		private static List<Player> FindOnlinePlayers(string query)
		{
			string normalized = (query ?? "").Trim();
			if (normalized.Length == 0)
			{
				return new List<Player>();
			}
			List<Player> source = (from player in Player.GetAllPlayers()
				where (Object)(object)player != (Object)null
				select player).ToList();
			List<Player> list = source.Where((Player player) => string.Equals(player.GetPlayerName(), normalized, StringComparison.OrdinalIgnoreCase)).ToList();
			if (list.Count > 0)
			{
				return list;
			}
			return source.Where((Player player) => player.GetPlayerName().IndexOf(normalized, StringComparison.OrdinalIgnoreCase) >= 0).ToList();
		}

		private static void SendResult(long targetPeerID, ZDOID wardID, PermittedPlayerAction action, PermittedPlayerResult result, string detail, ZDO zdo)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			//IL_0008: 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_00e4: Expected O, but got Unknown
			ZPackage val = new ZPackage();
			val.Write(wardID);
			val.Write((int)action);
			val.Write((int)result);
			val.Write(detail ?? "");
			List<KeyValuePair<long, string>> list = WardZdoUtils.GetPermittedPlayers(zdo).OrderBy<KeyValuePair<long, string>, string>((KeyValuePair<long, string> player) => player.Value, StringComparer.OrdinalIgnoreCase).ToList();
			val.Write(list.Count);
			foreach (KeyValuePair<long, string> item in list)
			{
				val.Write(item.Key);
				val.Write(item.Value ?? "");
			}
			if (targetPeerID == 0)
			{
				RPC_UpdatePermittedPlayersResultClient(0L, new ZPackage(val.GetArray()));
			}
			else if (ZRoutedRpc.instance != null)
			{
				ZRoutedRpc.instance.InvokeRoutedRPC(targetPeerID, "PW_UpdatePermittedPlayersResult", new object[1] { val });
			}
		}

		private static void RPC_UpdatePermittedPlayersResultClient(long _, ZPackage package)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: 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)
			ZDOID val = package.ReadZDOID();
			PermittedPlayerAction permittedPlayerAction = (PermittedPlayerAction)package.ReadInt();
			PermittedPlayerResult permittedPlayerResult = (PermittedPlayerResult)package.ReadInt();
			string detail = package.ReadString();
			int num = package.ReadInt();
			List<KeyValuePair<long, string>> list = new List<KeyValuePair<long, string>>(num);
			for (int i = 0; i < num; i++)
			{
				list.Add(new KeyValuePair<long, string>(package.ReadLong(), package.ReadString()));
			}
			if (((ZDOID)(ref s_wardID)).Equals(val))
			{
				s_permittedPlayers.Clear();
				s_permittedPlayers.AddRange(list);
				s_page = Mathf.Clamp(s_page, 0, GetPageCount() - 1);
				if ((Object)(object)s_panel != (Object)null)
				{
					CreatePanel();
				}
			}
			if (permittedPlayerResult == PermittedPlayerResult.Success && permittedPlayerAction == PermittedPlayerAction.Add)
			{
				WardSettingsUI.HandlePermittedPlayerAdded(val);
			}
			ShowResultMessage(permittedPlayerAction, permittedPlayerResult, detail);
		}

		private static void ShowResultMessage(PermittedPlayerAction action, PermittedPlayerResult result, string detail)
		{
			if (action == PermittedPlayerAction.Refresh && result == PermittedPlayerResult.Success)
			{
				return;
			}
			Player localPlayer = Player.m_localPlayer;
			if (!((Object)(object)localPlayer == (Object)null))
			{
				switch (result)
				{
				case PermittedPlayerResult.Success:
					((Character)localPlayer).Message((MessageType)2, (action == PermittedPlayerAction.Add) ? "$pw_permit_added".Localize(detail) : "$pw_ward_permitted_removed".Localize(detail), 0, (Sprite)null);
					break;
				case PermittedPlayerResult.NoMatch:
					((Character)localPlayer).Message((MessageType)2, "$pw_permit_no_match".Localize(detail), 0, (Sprite)null);
					break;
				case PermittedPlayerResult.MultipleMatches:
					((Character)localPlayer).Message((MessageType)2, "$pw_permit_multiple".Localize(detail), 0, (Sprite)null);
					break;
				case PermittedPlayerResult.AlreadyPermitted:
					((Character)localPlayer).Message((MessageType)2, "$pw_permit_already".Localize(), 0, (Sprite)null);
					break;
				case PermittedPlayerResult.NotPermitted:
					((Character)localPlayer).Message((MessageType)2, "$pw_ward_permitted_not_found".Localize(), 0, (Sprite)null);
					break;
				case PermittedPlayerResult.NotAuthorized:
					((Character)localPlayer).Message((MessageType)2, "$msg_privatezone", 0, (Sprite)null);
					break;
				case PermittedPlayerResult.TooFar:
					((Character)localPlayer).Message((MessageType)2, "$pw_ward_guild_too_far", 0, (Sprite)null);
					break;
				default:
					((Character)localPlayer).Message((MessageType)2, "$pw_ward_permitted_unavailable", 0, (Sprite)null);
					break;
				}
			}
		}

		private static void BackToWardSettings()
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			PrivateArea val = WardZdoUtils.FindLoadedWard(s_wardID);
			Close();
			if ((Object)(object)val != (Object)null)
			{
				WardSettingsUI.Open(val);
			}
		}
	}
	internal static class WardPasswordProtection
	{
		private enum PasswordEntryResult
		{
			Success,
			IncorrectPassword,
			Unavailable,
			AlreadyPermitted,
			TooFar
		}

		internal enum PasswordSettingsResult
		{
			Success,
			MissingPassword,
			NotAuthorized,
			Unavailable,
			TooFar,
			PasswordTooLong
		}

		[HarmonyPatch(typeof(Player), "Update")]
		private static class Player_Update_ClosePasswordPrompt
		{
			private static void Postfix()
			{
				if (!((Object)(object)s_panel == (Object)null))
				{
					if (ZInput.GetKeyDown((KeyCode)27, true))
					{
						ClosePrompt();
					}
					else if (ZInput.GetKeyDown((KeyCode)13, true) || ZInput.GetKeyDown((KeyCode)271, true))
					{
						SubmitPassword();
					}
				}
			}
		}

		[HarmonyPatch(typeof(ZoneSystem), "Start")]
		private static class ZoneSystem_Start_RegisterPasswordRPCs
		{
			private static void Postfix()
			{
				RegisterRPCs();
			}
		}

		[HarmonyPatch(typeof(ZoneSystem), "OnDestroy")]
		private static class ZoneSystem_OnDestroy_ResetPasswordRPCs
		{
			private static void Postfix()
			{
				ResetRPCRegistration();
			}
		}

		[CompilerGenerated]
		private static class <>O
		{
			public static Action<long, ZPackage> <0>__RPC_SubmitWardPasswordResultClient;

			public static Action<long, ZPackage> <1>__RPC_UpdateWardPasswordResultClient;

			public static Action<long, ZPackage> <2>__RPC_SubmitWardPasswordServer;

			public static Action<long, ZPackage> <3>__RPC_UpdateWardPasswordServer;

			public static UnityAction <4>__SubmitPassword;

			public static UnityAction <5>__ClosePrompt;
		}

		private const string RPC_SubmitWardPassword = "PW_SubmitWardPassword";

		private const string RPC_SubmitWardPasswordResult = "PW_SubmitWardPasswordResult";

		private const string RPC_UpdateWardPassword = "PW_UpdateWardPassword";

		private const string RPC_UpdateWardPasswordResult = "PW_UpdateWardPasswordResult";

		internal const int PasswordCharacterLimit = 64;

		private const int PasswordHashIterations = 10000;

		internal static readonly int s_passwordProtectionEnabled = StringExtensionMethods.GetStableHashCode("pw_password_enabled");

		internal static readonly int s_passwordHash = StringExtensionMethods.GetStableHashCode("pw_password_hash");

		internal static readonly int s_passwordSalt = StringExtensionMethods.GetStableHashCode("pw_password_salt");

		internal static readonly int s_passwordPlaintext = StringExtensionMethods.GetStableHashCode("pw_password_plaintext");

		private static bool s_rpcRegistered;

		private static GameObject s_panel;

		private static InputField s_passwordInput;

		private static Button s_submitButton;

		private static ZDOID s_promptWardID = ZDOID.None;

		private static bool s_inputBlocked;

		internal static void RegisterRPCs()
		{
			if (!s_rpcRegistered && ZRoutedRpc.instance != null)
			{
				ZRoutedRpc.instance.Register<ZPackage>("PW_SubmitWardPasswordResult", (Action<long, ZPackage>)RPC_SubmitWardPasswordResultClient);
				ZRoutedRpc.instance.Register<ZPackage>("PW_UpdateWardPasswordResult", (Action<long, ZPackage>)RPC_UpdateWardPasswordResultClient);
				ZNet instance = ZNet.instance;
				if (instance != null && instance.IsServer())
				{
					ZRoutedRpc.instance.Register<ZPackage>("PW_SubmitWardPassword", (Action<long, ZPackage>)RPC_SubmitWardPasswordServer);
					ZRoutedRpc.instance.Register<ZPackage>("PW_UpdateWardPassword", (Action<long, ZPackage>)RPC_UpdateWardPasswordServer);
					HandlePasswordFieldModeChanged();
				}
				s_rpcRegistered = true;
			}
		}

		internal static void ResetRPCRegistration()
		{
			s_rpcRegistered = false;
			ClosePrompt();
		}

		internal static bool IsPasswordProtectionActive(PrivateArea ward)
		{
			if (ward != null)
			{
				ZNetView nview = ward.m_nview;
				if (((nview != null) ? new bool?(nview.IsValid()) : ((bool?)null)) == true)
				{
					return IsPasswordProtectionActive(ward.m_nview.GetZDO());
				}
			}
			return false;
		}

		internal static bool IsPasswordProtectionActive(ZDO zdo)
		{
			return ProtectiveWards.ArePerWardSettingsEnabled() && zdo != null && zdo.GetBool(s_passwordProtectionEnabled, false) && HasPassword(zdo);
		}

		internal static bool HasPassword(ZDO zdo)
		{
			if (zdo == null)
			{
				return false;
			}
			string value = zdo.GetString(s_passwordHash, "");
			string value2 = zdo.GetString(s_passwordSalt, "");
			if (!string.IsNullOrEmpty(value) && !string.IsNullOrEmpty(value2))
			{
				return true;
			}
			return !string.IsNullOrEmpty(zdo.GetString(s_passwordPlaintext, ""));
		}

		internal static string GetEditablePassword(ZDO zdo)
		{
			if (zdo == null || ProtectiveWards.wardPasswordFieldMode.Value != ProtectiveWards.WardPasswordFieldMode.EditablePassword)
			{
				return "";
			}
			return zdo.GetString(s_passwordPlaintext, "");
		}

		internal static bool CanChangePassword(PrivateArea ward, Player player)
		{
			return (Object)(object)player != (Object)null && CanChangePassword(ward, player.GetPlayerID());
		}

		internal static bool CanChangePassword(PrivateArea ward, long playerID)
		{
			if (!ProtectiveWards.ArePerWardSettingsEnabled() || (Object)(object)ward == (Object)null || playerID == 0)
			{
				return false;
			}
			if (ProtectiveWards.HasWardManagementAccess(ward, playerID))
			{
				return true;
			}
			if (ProtectiveWards.ShouldBlockInactiveWardAccess(ward, playerID) || (Object)(object)ward.m_piece == (Object)null)
			{
				return false;
			}
			if (ward.m_piece.GetCreator() == playerID)
			{
				return true;
			}
			if (ProtectiveWards.wardPasswordChangeAccess.Value != ProtectiveWards.WardPasswordChangeAccess.CreatorAndPermitted)
			{
				return false;
			}
			return ProtectiveWards.HasDirectAccessToWard(ward, playerID);
		}

		internal static bool CanChangePassword(ZDO zdo, long playerID)
		{
			if (!ProtectiveWards.ArePerWardSettingsEnabled() || !WardZdoUtils.IsWard(zdo) || playerID == 0)
			{
				return false;
			}
			if (ProtectiveWards.HasWardManagementAccess(zdo, playerID))
			{
				return true;
			}
			if (ProtectiveWards.ShouldBlockInactiveWardAccess(zdo, playerID))
			{
				return false;
			}
			if (zdo.IsCreator(playerID))
			{
				return true;
			}
			if (ProtectiveWards.wardPasswordChangeAccess.Value != ProtectiveWards.WardPasswordChangeAccess.CreatorAndPermitted)
			{
				return false;
			}
			return WardZdoUtils.HasDirectAccessToWardZdo(zdo, playerID);
		}

		internal static bool AppendPasswordHoverAction(PrivateArea ward, StringBuilder text)
		{
			if (text == null || !ShouldOfferPasswordEntry(ward, Player.m_localPlayer))
			{
				return false;
			}
			int num = text.ToString().LastIndexOf("$piece_guardstone_add", StringComparison.Ordinal);
			if (num >= 0)
			{
				text.Remove(num, "$piece_guardstone_add".Length);
				text.Insert(num, "$pw_ward_password_enter");
			}
			else
			{
				text.Append("\n[<color=yellow><b>$KEY_Use</b></color>] $pw_ward_password_enter");
			}
			return true;
		}

		internal static bool TryHandleInteraction(PrivateArea ward, Player player)
		{
			if (!ShouldOfferPasswordEntry(ward, player))
			{
				return false;
			}
			OpenPrompt(ward);
			return true;
		}

		private static bool ShouldOfferPasswordEntry(PrivateArea ward, Player player)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Invalid comparison between Unknown and I4
			if ((Object)(object)ward == (Object)null || (Object)(object)player == (Object)null || (int)ward.m_ownerFaction > 0)
			{
				return false;
			}
			if (!IsPasswordProtectionActive(ward))
			{
				return false;
			}
			long playerID = player.GetPlayerID();
			if (playerID == 0)
			{
				return false;
			}
			return !ProtectiveWards.HasDirectAccessToWard(ward, playerID);
		}

		private static void OpenPrompt(PrivateArea ward)
		{
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: 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_0114: Unknown result type (might be due to invalid IL or missing references)
			//IL_0139: Unknown result type (might be due to invalid IL or missing references)
			//IL_0148: 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_01db: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0267: Unknown result type (might be due to invalid IL or missing references)
			//IL_0276: Unknown result type (might be due to invalid IL or missing references)
			//IL_0285: Unknown result type (might be due to invalid IL or missing references)
			//IL_0233: Unknown result type (might be due to invalid IL or missing references)
			//IL_0238: Unknown result type (might be due to invalid IL or missing references)
			//IL_023e: Expected O, but got Unknown
			//IL_02b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c0: Expected O, but got Unknown
			if (ward == null)
			{
				return;
			}
			ZNetView nview = ward.m_nview;
			if (((nview != null) ? new bool?(nview.IsValid()) : ((bool?)null)) != true)
			{
				return;
			}
			ClosePrompt();
			WardSettingsUI.Close();
			if (GUIManager.Instance == null || (Object)(object)GUIManager.CustomGUIFront == (Object)null)
			{
				Player localPlayer = Player.m_localPlayer;
				if (localPlayer != null)
				{
					((Character)localPlayer).Message((MessageType)2, "$pw_ward_password_unavailable", 0, (Sprite)null);
				}
				return;
			}
			s_promptWardID = ward.m_nview.GetZDO().m_uid;
			s_panel = GUIManager.Instance.CreateWoodpanel(GUIManager.CustomGUIFront.transform, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), Vector2.zero, 520f, 270f, true);
			s_panel.SetActive(true);
			CreatePromptText("$pw_ward_password_prompt_title".Localize(), new Vector2(0f, 92f), 28, 450f, 44f, GUIManager.Instance.ValheimOrange, (FontStyle)1);
			GameObject val = GUIManager.Instance.CreateInputField(s_panel.transform, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), new Vector2(0f, 20f), (ContentType)7, "$pw_ward_password_placeholder".Localize(), 18, 390f, 38f);
			s_passwordInput = val.GetComponent<InputField>();
			s_passwordInput.characterLimit = 64;
			if ((Object)(object)s_passwordInput.textComponent != (Object)null)
			{
				s_passwordInput.textComponent.alignment = (TextAnchor)3;
			}
			GameObject val2 = GUIManager.Instance.CreateButton("$pw_ward_password_submit".Localize(), s_panel.transform, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), new Vector2(-105f, -72f), 180f, 48f);
			s_submitButton = val2.GetComponent<Button>();
			ButtonClickedEvent onClick = s_submitButton.onClick;
			object obj = <>O.<4>__SubmitPassword;
			if (obj == null)
			{
				UnityAction val3 = SubmitPassword;
				<>O.<4>__SubmitPassword = val3;
				obj = (object)val3;
			}
			((UnityEvent)onClick).AddListener((UnityAction)obj);
			GameObject val4 = GUIManager.Instance.CreateButton("$pw_ward_settings_cancel".Localize(), s_panel.transform, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), new Vector2(115f, -72f), 180f, 48f);
			ButtonClickedEvent onClick2 = val4.GetComponent<Button>().onClick;
			object obj2 = <>O.<5>__ClosePrompt;
			if (obj2 == null)
			{
				UnityAction val5 = ClosePrompt;
				<>O.<5>__ClosePrompt = val5;
				obj2 = (object)val5;
			}
			((UnityEvent)onClick2).AddListener((UnityAction)obj2);
			SetPromptInputBlocked(blocked: true);
			s_passwordInput.ActivateInputField();
		}

		private static void CreatePromptText(string value, Vector2 position, int fontSize, float width, float height, Color color, FontStyle style)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: 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_003e: 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)
			GameObject val = GUIManager.Instance.CreateText(value, s_panel.transform, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), position, GUIManager.Instance.AveriaSerif, fontSize, color, true, Color.black, width, height, false);
			Text component = val.GetComponent<Text>();
			if ((Object)(object)component != (Object)null)
			{
				component.alignment = (TextAnchor)4;
				component.fontStyle = style;
			}
		}

		private static void SubmitPassword()
		{
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Expected O, but got Unknown
			//IL_00de: 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_0127: Expected O, but got Unknown
			//IL_0154: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)s_submitButton != (Object)null && !((Selectable)s_submitButton).interactable)
			{
				return;
			}
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null || ((ZDOID)(ref s_promptWardID)).IsNone())
			{
				ClosePrompt();
				return;
			}
			string text = (((Object)(object)s_passwordInput != (Object)null) ? s_passwordInput.text : "");
			if (string.IsNullOrEmpty(text))
			{
				((Character)localPlayer).Message((MessageType)2, "$pw_ward_password_required", 0, (Sprite)null);
				return;
			}
			if (text.Length > 64)
			{
				((Character)localPlayer).Message((MessageType)2, "$pw_ward_password_too_long", 0, (Sprite)null);
				return;
			}
			if ((Object)(object)s_submitButton != (Object)null)
			{
				((Selectable)s_submitButton).interactable = false;
			}
			ZPackage val = new ZPackage();
			val.Write(s_promptWardID);
			val.Write(localPlayer.GetPlayerID());
			val.Write(text);
			ZNet instance = ZNet.instance;
			if (instance != null && instance.IsServer())
			{
				RPC_SubmitWardPasswordServer(0L, new ZPackage(val.GetArray()));
			}
			else if (ZRoutedRpc.instance != null)
			{
				ZRoutedRpc.instance.InvokeRoutedRPC("PW_SubmitWardPassword", new object[1] { val });
			}
			else
			{
				HandlePasswordEntryResult(s_promptWardID, PasswordEntryResult.Unavailable);
			}
		}

		private static void RPC_SubmitWardPasswordServer(long sender, ZPackage package)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: 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_00cd: 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_00a4: Unknown result type (might be due to invalid IL or missing references)
			ZDOID val = package.ReadZDOID();
			long claimedPlayerID = package.ReadLong();
			string password = package.ReadString() ?? "";
			if (ProtectiveWards.TryGetRoutedPlayer(sender, claimedPlayerID, out var player))
			{
				if (!WardZdoUtils.TryGetWard(val, out var zdo))
				{
					SendPasswordEntryResult(sender, val, PasswordEntryResult.Unavailable);
					return;
				}
				if (WardZdoUtils.HasDirectAccessToWardZdo(zdo, player.PlayerID))
				{
					SendPasswordEntryResult(sender, val, PasswordEntryResult.AlreadyPermitted);
					return;
				}
				if (!IsPasswordProtectionActive(zdo))
				{
					SendPasswordEntryResult(sender, val, PasswordEntryResult.Unavailable);
					return;
				}
				if (!VerifyPassword(zdo, password))
				{
					SendPasswordEntryResult(sender, val, PasswordEntryResult.IncorrectPassword);
					return;
				}
				WardZdoUtils.AddPermitted(zdo, player.PlayerID, player.PlayerName);
				ProtectiveWards.LogInfo($"Added {player.PlayerName} to ward {val} permitted list by password");
				SendPasswordEntryResult(sender, val, PasswordEntryResult.Success);
			}
		}

		private static void SendPasswordEntryResult(long peerID, ZDOID wardID, PasswordEntryResult result)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			//IL_0008: 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_006c: Expected O, but got Unknown
			ZPackage val = new ZPackage();
			val.Write(wardID);
			val.Write((int)result);
			ZNet instance = ZNet.instance;
			if (instance != null && instance.IsServer() && ZRoutedRpc.instance != null && peerID != 0)
			{
				ZRoutedRpc.instance.InvokeRoutedRPC(peerID, "PW_SubmitWardPasswordResult", new object[1] { val });
			}
			else
			{
				RPC_SubmitWardPasswordResultClient(0L, new ZPackage(val.GetArray()));
			}
		}

		private static void RPC_SubmitWardPasswordResultClient(long _, ZPackage package)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			ZDOID wardID = package.ReadZDOID();
			PasswordEntryResult result = (PasswordEntryResult)package.ReadInt();
			HandlePasswordEntryResult(wardID, result);
		}

		private static void HandlePasswordEntryResult(ZDOID wardID, PasswordEntryResult result)
		{
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null)
			{
				return;
			}
			switch (result)
			{
			case PasswordEntryResult.Success:
				((Character)localPlayer).Message((MessageType)2, "$pw_ward_password_accepted", 0, (Sprite)null);
				ClosePrompt();
				break;
			case PasswordEntryResult.IncorrectPassword:
				((Character)localPlayer).Message((MessageType)2, "$pw_ward_password_incorrect", 0, (Sprite)null);
				if (((ZDOID)(ref s_promptWardID)).Equals(wardID) && (Object)(object)s_passwordInput != (Object)null)
				{
					s_passwordInput.text = "";
					s_passwordInput.ActivateInputField();
				}
				if ((Object)(object)s_submitButton != (Object)null)
				{
					((Selectable)s_submitButton).interactable = true;
				}
				break;
			case PasswordEntryResult.AlreadyPermitted:
				((Character)localPlayer).Message((MessageType)2, "$pw_ward_password_already_permitted", 0, (Sprite)null);
				ClosePrompt();
				break;
			case PasswordEntryResult.TooFar:
				((Character)localPlayer).Message((MessageType)2, "$pw_ward_password_too_far", 0, (Sprite)null);
				ClosePrompt();
				break;
			default:
				((Character)localPlayer).Message((MessageType)2, "$pw_ward_password_unavailable", 0, (Sprite)null);
				ClosePrompt();
				break;
			}
		}

		internal static void RequestSettingsUpdate(ZDOID wardID, bool enabled, bool replacePassword, string password)
		{
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Expected O, but got Unknown
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Expected O, but got Unknown
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			Player localPlayer = Player.m_localPlayer;
			if (!((Object)(object)localPlayer == (Object)null) && !((ZDOID)(ref wardID)).IsNone())
			{
				password = (replacePassword ? (password ?? "") : "");
				ZPackage val = new ZPackage();
				val.Write(wardID);
				val.Write(localPlayer.GetPlayerID());
				val.Write(enabled);
				val.Write(replacePassword);
				val.Write(password);
				ZNet instance = ZNet.instance;
				if (instance != null && instance.IsServer())
				{
					RPC_UpdateWardPasswordServer(0L, new ZPackage(val.GetArray()));
				}
				else if (ZRoutedRpc.instance != null)
				{
					ZRoutedRpc.instance.InvokeRoutedRPC("PW_UpdateWardPassword", new object[1] { val });
				}
				else
				{
					WardSettingsUI.OnPasswordSettingsResult(wardID, PasswordSettingsResult.Unavailable, enabled: false, hasPassword: false);
				}
			}
		}

		private static void RPC_UpdateWardPasswordServer(long sender, ZPackage package)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: 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_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_0135: Unknown result type (might be due to invalid IL or missing references)
			ZDOID val = package.ReadZDOID();
			long claimedPlayerID = package.ReadLong();
			bool flag = package.ReadBool();
			bool flag2 = package.ReadBool();
			string text = package.ReadString() ?? "";
			if (!ProtectiveWards.TryGetRoutedPlayer(sender, claimedPlayerID, out var player))
			{
				return;
			}
			if (!WardZdoUtils.TryGetWard(val, out var zdo))
			{
				SendPasswordSettingsResult(sender, val, PasswordSettingsResult.Unavailable, enabled: false, hasPassword: false);
				return;
			}
			if (!CanChangePassword(zdo, player.PlayerID))
			{
				SendPasswordSettingsResult(sender, val, PasswordSettingsResult.NotAuthorized, enabled: false, hasPassword: false);
				return;
			}
			if (flag2 && text.Length > 64)
			{
				SendPasswordSettingsResult(sender, val, PasswordSettingsResult.PasswordTooLong, enabled: false, hasPassword: false);
				return;
			}
			if (flag2)
			{
				StorePassword(zdo, text);
				if (string.IsNullOrEmpty(text))
				{
					flag = false;
				}
			}
			bool flag3 = HasPassword(zdo);
			if (flag && !flag3)
			{
				SendPasswordSettingsResult(sender, val, PasswordSettingsResult.MissingPassword, enabled: false, hasPassword: false);
				return;
			}
			zdo.Set(s_passwordProtectionEnabled, flag);
			ProtectiveWards.LogInfo(string.Format("Ward password protection {0} for {1}", flag ? "enabled" : "disabled", val));
			SendPasswordSettingsResult(sender, val, PasswordSettingsResult.Success, flag, flag3);
		}

		private static void SendPasswordSettingsResult(long peerID, ZDOID wardID, PasswordSettingsResult result, bool enabled, bool hasPassword)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Expected O, but got Unknown
			ZPackage val = new ZPackage();
			val.Write(wardID);
			val.Write((int)result);
			val.Write(enabled);
			val.Write(hasPassword);
			ZNet instance = ZNet.instance;
			if (instance != null && instance.IsServer() && ZRoutedRpc.instance != null && peerID != 0)
			{
				ZRoutedRpc.instance.InvokeRoutedRPC(peerID, "PW_UpdateWardPasswordResult", new object[1] { val });
			}
			else
			{
				RPC_UpdateWardPasswordResultClient(0L, new ZPackage(val.GetArray()));
			}
		}

		private static void RPC_UpdateWardPasswordResultClient(long _, ZPackage package)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			ZDOID wardID = package.ReadZDOID();
			PasswordSettingsResult result = (PasswordSettingsResult)package.ReadInt();
			bool enabled = package.ReadBool();
			bool hasPassword = package.ReadBool();
			WardSettingsUI.OnPasswordSettingsResult(wardID, result, enabled, hasPassword);
		}

		private static void StorePassword(ZDO zdo, string password)
		{
			if (zdo == null)
			{
				return;
			}
			if (string.IsNullOrEmpty(password))
			{
				ProtectiveWards.RemoveZdoString(zdo, s_passwordHash);
				ProtectiveWards.RemoveZdoString(zdo, s_passwordSalt);
				ProtectiveWards.RemoveZdoString(zdo, s_passwordPlaintext);
				return;
			}
			byte[] array = new byte[16];
			using (RandomNumberGenerator randomNumberGenerator = RandomNumberGenerator.Create())
			{
				randomNumberGenerator.GetBytes(array);
			}
			byte[] bytes;
			using (Rfc2898DeriveBytes rfc2898DeriveBytes = new Rfc2898DeriveBytes(password, array, 10000))
			{
				bytes = rfc2898DeriveBytes.GetBytes(32);
			}
			zdo.Set(s_passwordSalt, Convert.ToBase64String(array));
			zdo.Set(s_passwordHash, Convert.ToBase64String(bytes));
			if (ProtectiveWards.wardPasswordFieldMode.Value == ProtectiveWards.WardPasswordFieldMode.EditablePassword)
			{
				zdo.Set(s_passwordPlaintext, password);
			}
			else
			{
				ProtectiveWards.RemoveZdoString(zdo, s_passwordPlaintext);
			}
		}

		private static bool VerifyPassword(ZDO zdo, string password)
		{
			if (zdo == null || password == null)
			{
				return false;
			}
			string text = zdo.GetString(s_passwordSalt, "");
			string text2 = zdo.GetString(s_passwordHash, "");
			if (!string.IsNullOrEmpty(text) && !string.IsNullOrEmpty(text2))
			{
				try
				{
					byte[] salt = Convert.FromBase64String(text);
					byte[] array = Convert.FromBase64String(text2);
					byte[] bytes;
					using (Rfc2898DeriveBytes rfc2898DeriveBytes = new Rfc2898DeriveBytes(password, salt, 10000))
					{
						bytes = rfc2898DeriveBytes.GetBytes(array.Length);
					}
					return FixedTimeEquals(array, bytes);
				}
				catch (FormatException)
				{
				}
				catch (ArgumentException)
				{
				}
				catch (CryptographicException)
				{
				}
			}
			return string.Equals(zdo.GetString(s_passwordPlaintext, ""), password, StringComparison.Ordinal);
		}

		private static bool FixedTimeEquals(byte[] left, byte[] right)
		{
			if (left == null || right == null || left.Length != right.Length)
			{
				return false;
			}
			int num = 0;
			for (int i = 0; i < left.Length; i++)
			{
				num |= left[i] ^ right[i];
			}
			return num == 0;
		}

		internal static void HandleSettingsModeChanged()
		{
			if (!ProtectiveWards.ArePerWardSettingsEnabled())
			{
				ClosePrompt();
			}
		}

		internal static void HandlePasswordFieldModeChanged()
		{
			if (ProtectiveWards.wardPasswordFieldMode.Value != ProtectiveWards.WardPasswordFieldMode.SetNewPasswordOnly)
			{
				return;
			}
			ZNet instance = ZNet.instance;
			if (instance == null || !instance.IsServer())
			{
				return;
			}
			foreach (ZDO allWard in WardZdoUtils.GetAllWards())
			{
				ProtectiveWards.RemoveZdoString(allWard, s_passwordPlaintext);
			}
		}

		private static void ClosePrompt()
		{
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)s_panel != (Object)null)
			{
				Object.Destroy((Object)(object)s_panel);
			}
			s_panel = null;
			s_passwordInput = null;
			s_submitButton = null;
			s_promptWardID = ZDOID.None;
			SetPromptInputBlocked(blocked: false);
		}

		private static void SetPromptInputBlocked(bool blocked)
		{
			if (s_inputBlocked != blocked)
			{
				GUIManager.BlockInput(blocked);
				s_inputBlocked = blocked;
			}
		}
	}
	internal static class WardExpiration
	{
		private sealed class RefreshingPlayer
		{
			internal long PlayerID { get; private set; }

			internal string PlayerName { get; private set; }

			internal static RefreshingPlayer FromCharacterZdo(ZDO characterZdo, long playerID)
			{
				Player player = Player.GetPlayer(playerID);
				return new RefreshingPlayer
				{
					PlayerID = playerID,
					PlayerName = (((Object)(object)player != (Object)null) ? player.GetPlayerName() : characterZdo.GetString(ZDOVars.s_playerName, ""))
				};
			}
		}

		[HarmonyPatch(typeof(ZoneSystem), "Start")]
		private static class ZoneSystem_Start_ResetExpirationCheckTime
		{
			private static void Postfix()
			{
				ResetNextCheckTime();
			}
		}

		[HarmonyPatch(typeof(ZoneSystem), "OnDestroy")]
		private static class ZoneSystem_OnDestroy_ResetExpirationCheckTime
		{
			private static void Postfix()
			{
				ResetNextCheckTime();
			}
		}

		[HarmonyPatch(typeof(PrivateArea), "IsEnabled")]
		private static class PrivateArea_IsEnabled_Expiration
		{
			private static bool Prefix(PrivateArea __instance, ref bool __result)
			{
				if (ProtectiveWards.wardExpirationMinutes.Value <= 0 || ProtectiveWards.IsPermitEveryone(__instance) || !IsExpired(__instance))
				{
					return true;
				}
				__result = false;
				return false;
			}
		}

		[HarmonyPatch(typeof(PrivateArea), "Interact")]
		private static class PrivateArea_Interact_ReactivateExpiredWard
		{
			private static bool Prefix(PrivateArea __instance, Humanoid human, bool hold, ref bool __result)
			{
				if (hold || ProtectiveWards.wardExpirationMinutes.Value <= 0 || ProtectiveWards.IsPermitEveryone(__instance) || ProtectiveWards.wardExpirationReactivationMode.Value != ProtectiveWards.WardExpirationReactivationMode.ManualInteraction)
				{
					return true;
				}
				if (!IsExpired(__instance))
				{
					return true;
				}
				Player val = (Player)(object)((human is Player) ? human : null);
				if (!CanReactivate(__instance, val))
				{
					return true;
				}
				ZDO zDO = __instance.m_nview.GetZDO();
				Reactivate(zDO, val, DateTimeOffset.UtcNow.ToUnixTimeSeconds());
				ProtectiveWards.ActivateConnectedLoadedWards(__instance, val.GetPlayerID(), val.GetPlayerName());
				((Character)val).Message((MessageType)2, "$pw_ward_expiration_reactivated", 0, (Sprite)null);
				__result = true;
				return false;
			}
		}

		[HarmonyPatch(typeof(PrivateArea), "AddUserList")]
		private static class PrivateArea_AddUserList_ExpirationHover
		{
			private static void Postfix(PrivateArea __instance, StringBuilder text)
			{
				if (ProtectiveWards.wardExpirationMinutes.Value <= 0 || ProtectiveWards.IsPermitEveryone(__instance) || !IsExpired(__instance))
				{
					return;
				}
				text.Append("\n<color=orange>$pw_ward_expiration_expired</color>");
				text.Append("\n$pw_ward_expiration_hint");
				Player localPlayer = Player.m_localPlayer;
				long playerID = ((localPlayer != null) ? localPlayer.GetPlayerID() : 0);
				if (ProtectiveWards.wardExpirationAdminHover.Value && ProtectiveWards.HasWardManagementAccess(__instance, playerID))
				{
					ZDO zDO = __instance.m_nview.GetZDO();
					if (zDO != null)
					{
						long num = zDO.GetLong(s_expirationLastActiveUnix, 0L);
						long num2 = zDO.GetLong(s_expirationExpiredUnix, 0L);
						string arg = zDO.GetString(s_expirationLastPlayerName, "");
						text.Append($"\nLast active: {num}; Expired: {num2}; Last player: {arg}");
					}
				}
			}
		}

		internal static readonly int s_expirationLastActiveUnix = StringExtensionMethods.GetStableHashCode("pw_expiration_last_active_unix");

		internal static readonly int s_expirationExpired = StringExtensionMethods.GetStableHashCode("pw_expiration_expired");

		internal static readonly int s_expirationLastPlayerId = StringExtensionMethods.GetStableHashCode("pw_expiration_last_player_id");

		internal static readonly int s_expirationLastPlayerName = StringExtensionMethods.GetStableHashCode("pw_expiration_last_player_name");

		internal static readonly int s_expirationExpiredUnix = StringExtensionMethods.GetStableHashCode("pw_expiration_expired_unix");

		internal static readonly int s_expirationExpiredReason = StringExtensionMethods.GetStableHashCode("pw_expiration_expired_reason");

		private static float s_nextCheckTime;

		internal static void ResetNextCheckTime()
		{
			s_nextCheckTime = 0f;
		}

		internal static void SetExpired(ZDO zdo, bool expired, long playerID, string playerName)
		{
			if (zdo != null)
			{
				long num = DateTimeOffset.UtcNow.ToUnixTimeSeconds();
				zdo.Set(s_expirationExpired, expired);
				if (expired)
				{
					zdo.Set(s_expirationExpiredUnix, num);
					zdo.Set(s_expirationExpiredReason, "admin_command");
				}
				else
				{
					zdo.Set(s_expirationLastActiveUnix, num);
					zdo.Set(s_expirationExpiredReason, "admin_command_reactivated");
				}
				if (playerID != 0)
				{
					zdo.Set(s_expirationLastPlayerId, playerID);
					zdo.Set(s_expirationLastPlayerName, playerName ?? "");
				}
			}
		}

		internal static void Update()
		{
			if (ProtectiveWards.wardExpirationMinutes.Value > 0 && !((Object)(object)ZNet.instance == (Object)null) && ZNet.instance.IsServer() && !ZNet.IsSinglePlayer)
			{
				List<ZDO> allCharacterZDOS = ZNet.instance.GetAllCharacterZDOS();
				if (allCharacterZDOS.Count != 0 && !(Time.time < s_nextCheckTime))
				{
					s_nextCheckTime = Time.time + GetCheckIntervalSeconds();
					CheckTrackedWards(allCharacterZDOS);
				}
			}
		}

		private static float GetCheckIntervalSeconds()
		{
			int num = Math.Max(ProtectiveWards.wardExpirationMinutes.Value, 1);
			if (num < 10)
			{
				return 60f;
			}
			return Mathf.Clamp((float)num / 10f, 10f, 60f) * 60f;
		}

		private static void CheckTrackedWards(List<ZDO> characterZdos)
		{
			long num = DateTimeOffset.UtcNow.ToUnixTimeSeconds();
			long num2 = (long)Math.Max(ProtectiveWards.wardExpirationMinutes.Value, 1) * 60L;
			foreach (ZDO allWard in WardZdoUtils.GetAllWards())
			{
				if (allWard == null || ProtectiveWards.IsPermitEveryone(allWard))
				{
					continue;
				}
				if (allWard.GetLong(s_expirationLastActiveUnix, 0L) == 0)
				{
					allWard.Set(s_expirationLastActiveUnix, num);
				}
				RefreshingPlayer refreshingPlayer = FindRefreshingPlayer(allWard, characterZdos);
				if (refreshingPlayer != null)
				{
					RefreshActivity(allWard, refreshingPlayer, num);
					if (IsExpired(allWard) && ProtectiveWards.wardExpirationReactivationMode.Value == ProtectiveWards.WardExpirationReactivationMode.AutomaticOnLogin)
					{
						Reactivate(allWard, refreshingPlayer, num);
						ProtectiveWards.ActivateConnectedWardZdos(allWard, refreshingPlayer.PlayerID, refreshingPlayer.PlayerName);
					}
				}
				else if (!IsExpired(allWard))
				{
					long num3 = allWard.GetLong(s_expirationLastActiveUnix, num);
					if (num - num3 >= num2)
					{
						Expire(allWard, num);
					}
				}
			}
		}

		private static RefreshingPlayer FindRefreshingPlayer(ZDO zdo, List<ZDO> characterZdos)
		{
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			if (zdo == null || characterZdos == null)
			{
				return null;
			}
			ProtectiveWards.WardConnectedAccessMode mode = ProtectiveWards.wardExpirationConnectedAccessMode?.Value ?? ProtectiveWards.WardConnectedAccessMode.Off;
			foreach (ZDO characterZdo in characterZdos)
			{
				if (characterZdo == null)
				{
					continue;
				}
				long num = characterZdo.GetLong(ZDOVars.s_playerID, 0L);
				if (num == 0)
				{
					continue;
				}
				Vector3 position = characterZdo.GetPosition();
				switch (ProtectiveWards.wardExpirationRefreshMode.Value)
				{
				case ProtectiveWards.WardExpirationRefreshMode.DirectPermitted:
					if (ProtectiveWards.IsPointInsideWardArea(zdo, position) && zdo.HasDirectWardAccess(num))
					{
						return RefreshingPlayer.FromCharacterZdo(characterZdo, num);
					}
					break;
				default:
					if (IsInsideExpirationRefreshArea(zdo, mode, position) && zdo.HasConnectedWardAccess(num, mode, IsActiveForExpirationConnectedAccess))
					{
						return RefreshingPlayer.FromCharacterZdo(characterZdo, num);
					}
					break;
				}
			}
			return null;
		}

		private static bool IsInsideExpirationRefreshArea(ZDO rootWard, ProtectiveWards.WardConnectedAccessMode mode, Vector3 playerPosition)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			if (ProtectiveWards.IsPointInsideWardArea(rootWard, playerPosition))
			{
				return true;
			}
			if (mode == ProtectiveWards.WardConnectedAccessMode.Off)
			{
				return false;
			}
			foreach (ZDO item in WardZdoUtils.ConnectedAccessWardZdos(rootWard, mode, IsActiveForExpirationConnectedAccess))
			{
				if (item == null || ((ZDOID)(ref item.m_uid)).Equals(rootWard.m_uid) || !ProtectiveWards.IsPointInsideWardArea(item, playerPosition))
				{
					continue;
				}
				return true;
			}
			return false;
		}

		private static bool IsActiveForExpirationConnectedAccess(ZDO zdo)
		{
			return zdo.IsWard() && zdo.GetBool(ZDOVars.s_enabled, false) && !IsExpired(zdo);
		}

		private static void RefreshActivity(ZDO zdo, Player player, long now)
		{
			zdo.Set(s_expirationLastActiveUnix, now);
			zdo.Set(s_expirationLastPlayerId, player.GetPlayerID());
			zdo.Set(s_expirationLastPlayerName, player.GetPlayerName());
		}

		private static void RefreshActivity(ZDO zdo, RefreshingPlayer player, long now)
		{
			zdo.Set(s_expirationLastActiveUnix, now);
			zdo.Set(s_expirationLastPlayerId, player.PlayerID);
			zdo.Set(s_expirationLastPlayerName, player.PlayerName);
		}

		private static void Expire(ZDO zdo, long now)
		{
			zdo.Set(s_expirationExpired, true);
			zdo.Set(s_expirationExpiredUnix, now);
			zdo.Set(s_expirationExpiredReason, "inactivity");
		}

		private static void Reactivate(ZDO zdo, Player player, long now)
		{
			zdo.Set(s_expirationExpired, false);
			RefreshActivity(zdo, player, now);
		}

		private static void Reactivate(ZDO zdo, RefreshingPlayer player, long now)
		{
			zdo.Set(s_expirationExpired, false);
			RefreshActivity(zdo, player, now);
		}

		internal static bool IsExpired(PrivateArea ward)
		{
			if ((Object)(object)ward == (Object)null || (Object)(object)ward.m_nview == (Object)null || !ward.m_nview.IsValid())
			{
				return false;
			}
			return IsExpired(ward.m_nview.GetZDO());
		}

		internal static bool IsExpired(ZDO zdo)
		{
			return zdo != null && zdo.GetBool(s_expirationExpired, false);
		}

		private static bool CanReactivate(PrivateArea ward, Player player)
		{
			if ((Object)(object)ward == (Object)null || (Object)(object)player == (Object)null || (Object)(object)ward.m_nview == (Object)null || !ward.m_nview.IsValid())
			{
				return false;
			}
			ZDO zDO = ward.m_nview.GetZDO();
			long playerID = player.GetPlayerID();
			ProtectiveWards.WardConnectedAccessMode mode = ProtectiveWards.wardExpirationConnectedAccessMode?.Value ?? ProtectiveWards.WardConnectedAccessMode.Off;
			return (ProtectiveWards.wardExpirationRefreshMode.Value == ProtectiveWards.WardExpirationRefreshMode.DirectPermitted) ? zDO.HasDirectWardAccess(playerID) : zDO.HasConnectedWardAccess(playerID, mode, IsActiveForExpirationConnectedAccess);
		}

		internal static void TryReactivateFromNearbyPlayer(PrivateArea ward)
		{
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			if (ProtectiveWards.wardExpirationMinutes.Value <= 0 || ProtectiveWards.IsPermitEveryone(ward) || ProtectiveWards.wardExpirationReactivationMode.Value != ProtectiveWards.WardExpirationReactivationMode.AutomaticOnLogin || !IsExpired(ward) || (Object)(object)ward == (Object)null || (Object)(object)ward.m_nview == (Object)null || !ward.m_nview.IsValid())
			{
				return;
			}
			List<Player> list = new List<Player>();
			Player.GetPlayersInRange(((Component)ward).transform.position, Math.Max(ward.m_radius, 0f), list);
			foreach (Player item in list)
			{
				if (!CanReactivate(ward, item))
				{
					continue;
				}
				Reactivate(ward.m_nview.GetZDO(), item, DateTimeOffset.UtcNow.ToUnixTimeSeconds());
				ProtectiveWards.ActivateConnectedLoadedWards(ward, item.GetPlayerID(), item.GetPlayerName());
				break;
			}
		}
	}
	[BepInPlugin("shudnal.ProtectiveWards", "Protective Wards", "2.0.6")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[NetworkCompatibility(/*Could not decode attribute arguments.*/)]
	public class ProtectiveWards : BaseUnityPlugin
	{
		private sealed class WardEmissionDefaults
		{
			public ParticleSystem[] ParticleSystems;

			public MinMaxGradient[] ParticleStartColors;

			public Light Light;

			public Color LightColor;

			public LightFlicker Flicker;

			public bool HadFlicker;

			public bool FlickerEnabled;
		}

		public enum ShipDamageType
		{
			Off,
			WaterDamage,
			AnyButPlayerDamage,
			AnyDamage
		}

		public enum WardConnectedAccessMode
		{
			Off,
			SameCreatorOnly,
			MutualTrust,
			AnyConnected
		}

		public enum WardAreaShape
		{
			Cylinder,
			Sphere
		}

		public enum WardSettingsMode
		{
			PerWard,
			ServerControlled
		}

		public enum WardPortalAccessMode
		{
			AllowAll,
			AllowTeleportOnly,
			BlockAll
		}

		public enum WardItemPickupMode
		{
			AllowAll,
			AllowNonPlayerDropped,
			BlockAll
		}

		public enum WardBackgroundPresenceMode
		{
			PermittedNearProtectedArea,
			PermittedInsideConnectedArea,
			PermittedOnline
		}

		public enum WardBackgroundStructureProtectionMode
		{
			Off,
			BlockNonPermittedPlayerDamage,
			BlockAllDamageWhenNoPermittedNearby
		}

		public enum WardBackgroundTamePacifyMode
		{
			Off,
			WhenNoPermittedNearby
		}

		public enum WardAdminAccessMode
		{
			Off,
			Admins,
			AdminsInGodMode
		}

		public enum WardPasswordFieldMode
		{
			SetNewPasswordOnly,
			EditablePassword
		}

		public enum WardPasswordChangeAccess
		{
			CreatorOnly,
			CreatorAndPermitted
		}

		public enum WardExpirationRefreshMode
		{
			DirectPermitted,
			EffectiveAccess
		}

		public enum WardExpirationReactivationMode
		{
			ManualInteraction,
			AutomaticOnLogin
		}

		public enum WardTaxiExistingFlightMode
		{
			RejectNewPassage,
			StopActivePassage
		}

		internal readonly struct RoutedPlayerContext
		{
			public readonly long PlayerID;

			public readonly string PlayerName;

			public readonly ZDOID CharacterID;

			public readonly Vector3 Position;

			public readonly bool HasPosition;

			public readonly long Sender;

			public RoutedPlayerContext(long playerID, string playerName, ZDOID characterID, Vector3 position, bool hasPosition, long sender)
			{
				//IL_0019: 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_0020: Unknown result type (might be due to invalid IL or missing references)
				//IL_0022: Unknown result type (might be due to invalid IL or missing references)
				PlayerID = playerID;
				PlayerName = playerName ?? "";
				CharacterID = characterID;
				Position = position;
				HasPosition = hasPosition;
				Sender = sender;
			}
		}

		[HarmonyPatch(typeof(CircleProjector), "CreateSegments")]
		public static class CircleProjector_CreateSegments_InitState
		{
			public static void Prefix(CircleProjector __instance, ref bool __state)
			{
				PrivateArea component = ((Component)((Component)__instance).transform.root).GetComponent<PrivateArea>();
				if (IsPlayerWardPrefab(component) && !((Object)(object)component.m_nview == (Object)null) && component.m_nview.IsValid())
				{
					ZDO zDO = component.m_nview.GetZDO();
					if (zDO != null && GetWardBoolSetting(zDO, s_circleEnabled, wardAreaMarkerPatch.Value))
					{
						float wardFloatSetting = GetWardFloatSetting(zDO, s_circleAmount, wardAreaMarkerAmount.Value);
						__instance.m_nrOfSegments = (int)(80f * wardFloatSetting * (__instance.m_radius / 32f));
						__state = (!__instance.m_sliceLines && __instance.m_segments.Count == __instance.m_nrOfSegments) || (__instance.m_sliceLines && __instance.m_calcStart == __instance.m_start && __instance.m_calcTurns == __instance.m_turns);
					}
				}
			}

			public static void Postfix(CircleProjector __instance, bool __state)
			{
				if (__state)
				{
					return;
				}
				PrivateArea component = ((Component)((Component)__instance).transform.root).GetComponent<PrivateArea>();
				if (!IsPlayerWardPrefab(component))
				{
					return;
				}
				ZNetView componentZNetView = ((Component)(object)__instance).GetComponentZNetView();
				if (Object.op_Implicit((Object)(object)componentZNetView) && componentZNetView.IsValid())
				{
					ZDO zDO = componentZNetView.GetZDO();
					if (zDO != null)
					{
						InitCircleProjectorState(__instance, componentZNetView);
					}
				}
			}
		}

		[HarmonyPatch(typeof(Door), "Interact")]
		public static class Door_SetState_AutoClose
		{
			public static void Postfix(Door __instance, ZNetView ___m_nview, bool __result)
			{
				//IL_005f: Unknown result type (might be due to invalid IL or missing references)
				if (autoCloseDoorsTime.Value == 0 || autoCloseDoorsIgnorePrefabs.Value.IndexOf(Utils.GetPrefabName(((Component)__instance).gameObject)) > -1 || !___m_nview.IsValid() || !__result || !InsideEnabledPlayersArea(((Component)__instance).transform.position, out var area, checkCache: true))
				{
					return;
				}
				if (!doorsToClose.TryGetValue(area, out var value))
				{
					value = new List<Door>();
				}
				int num = ___m_nview.GetZDO().GetInt(ZDOVars.s_state, 0);
				if (num == 0)
				{
					value.Remove(__instance);
				}
				else if (!value.Contains(__instance))
				{
					value.Add(__instance);
				}
				if (value.Count == 0)
				{
					wardIsClosing.Remove(area);
					doorsToClose.Remove(area);
				}
				else if (num != 0)
				{
					doorsToClose[area] = value;
					LogInfo(value.Count);
					if (wardIsClosing.ContainsKey(area))
					{
						wardIsClosing[area] = Math.Max(autoCloseDoorsTime.Value, 2);
						LogInfo($"Doors closing reset to {wardIsClosing[area]} seconds");
					}
					else
					{
						wardIsClosing[area] = Math.Max(autoCloseDoorsTime.Value, 2);
						((MonoBehaviour)area).StartCoroutine(AutoClosingDoors(area));
						LogInfo("Doors closing started");
					}
				}
			}
		}

		[HarmonyPatch(typeof(TextsDialog), "UpdateTextsList")]
		public static class TextsDialog_UpdateTextsList_AddWardSacrifices
		{
			private static void Postfix(TextsDialog __instance)
			{
				//IL_010e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0115: Expected O, but got Unknown
				if (__instance?.m_texts == null)
				{
					return;
				}
				string guardstoneTopic = Localization.instance.Localize("$tutorial_guardstone_label");
				int num = __instance.m_texts.FindIndex((TextInfo text) => text.m_topic == guardstoneTopic);
				if (num >= 0 && !__instance.m_texts[num].m_text.Contains("$pw_tutorial_guardstone_extra"))
				{
					TextInfo obj = __instance.m_texts[num];
					obj.m_text += "\n\n$pw_tutorial_guardstone_extra";
				}
				if (!showOfferingsInHover.Value)
				{
					return;
				}
				bool hasTaxiOffering;
				List<string> list = BuildAvailableOfferingList(out hasTaxiOffering);
				if (list.Count == 0)
				{
					return;
				}
				string offeringsTopic = Localization.instance.Localize("$pw_ward_offerings_compendium_topic");
				if (__instance.m_texts.Any((TextInfo text) => text.m_topic == offeringsTopic))
				{
					return;
				}
				TextInfo item = new TextInfo("$pw_ward_offerings_compendium_topic", BuildWardSacrificesCompendiumText(list, hasTaxiOffering));
				if (num >= 0)
				{
					__instance.m_texts.Insert(num + 1, item);
					return;
				}
				Player localPlayer = Player.m_localPlayer;
				if (localPlayer != null && localPlayer.IsRecipeKnown("$piece_guardstone"))
				{
					__instance.m_texts.Add(item);
				}
			}
		}

		[HarmonyPatch(typeof(Location), "OnDestroy")]
		public static class Location_OnDestroy_ClearDungeonEntranceCache
		{
			private static void Prefix(Location __instance)
			{
				if ((Object)(object)__instance != (Object)null)
				{
					dungeonEntranceCache.Remove(__instance);
				}
			}
		}

		[HarmonyPatch(typeof(PrivateArea), "IsInside")]
		public static class PrivateArea_IsInside_UseConfiguredAreaShape
		{
			private static bool Prefix(PrivateArea __instance, Vector3 point, float radius, ref bool __result)
			{
				//IL_000b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0011: Invalid comparison between Unknown and I4
				//IL_0020: Unknown result type (might be due to invalid IL or missing references)
				if ((Object)(object)__instance == (Object)null || (int)__instance.m_ownerFaction > 0)
				{
					return true;
				}
				__result = IsPointInsideWardArea(__instance, point, radius);
				return false;
			}
		}

		[HarmonyPatch(typeof(PrivateArea), "OnDestroy")]
		public static class PrivateArea_OnDestroy_ClearStatus
		{
			public static void Prefix(PrivateArea __instance)
			{
				areaCache.Clear();
				wardIsHealing.Remove(__instance);
				wardIsRepairing.Remove(__instance);
				wardIsClosing.Remove(__instance);
				s_wardDefaultRanges.Remove(__instance);
				s_wardEmissionDefaults.Remove(__instance);
			}
		}

		[HarmonyPatch(typeof(PrivateArea), "HideMarker")]
		public static class PrivateArea_HideMarker_ShowAreaMarker
		{
			public static bool Prefix()
			{
				return !showAreaMarker.Value;
			}
		}

		[HarmonyPatch(typeof(PrivateArea), "AddUserList")]
		public static class PrivateArea_AddUserList_WardAltActionCaption
		{
			public static void Prefix(PrivateArea __instance, StringBuilder text)
			{
				if (WardPasswordProtection.AppendPasswordHoverAction(__instance, text) || !__instance.HaveLocalAccess())
				{
					return;
				}
				bool flag = __instance.IsEnabled();
				if (!flag && !CanEditWardSettings(__instance, Player.m_localPlayer) && !WardPasswordProtection.CanChangePassword(__instance, Player.m_localPlayer))
				{
					return;
				}
				if (!flag)
				{
					if (ArePerWardSettingsEnabled())
					{
						if (!ZInput.IsNonClassicFunctionality() || !ZInput.IsGamepadActive())
						{
							text.Append("\n[<color=yellow><b>$KEY_AltPlace + $KEY_Use</b></color>] $pw_ward_open_settings");
						}
						else
						{
							text.Append("\n[<color=yellow><b>$KEY_JoyAltKeys + $KEY_Use</b></color>] $pw_ward_open_settings");
						}
					}
					return;
				}
				List<string> list = new List<string>();
				if (wardIsRepairing.TryGetValue(__instance, out var value))
				{
					list.Add($"$hud_repair {value}");
				}
				else if (wardPassiveRepair.Value)
				{
					if (!ZInput.IsNonClassicFunctionality() || !ZInput.IsGamepadActive())
					{
						text.Append("\n[<color=yellow><b>$KEY_AltPlace + $KEY_Use</b></color>] $pw_ward_start_repair");
					}
					else
					{
						text.Append("\n[<color=yellow><b>$KEY_JoyAltKeys + $KEY_Use</b></color>] $pw_ward_start_repair");
					}
				}
				if (wardIsHealing.TryGetValue(__instance, out var value2))
				{
					list.Add($"$item_food_regen {TimeSpan.FromSeconds(value2):m\\:ss}");
				}
				if (list.Count > 0)
				{
					text.Append("\n$guardianstone_hook_power_activate: ");
					text.Append(string.Join(", ", list.ToArray()));
				}
				if (showOfferingsInHover.Value && BuildAvailableOfferingList(out var _).Count > 0)
				{
					text.Append("\n[<color=yellow><b>1-8</b></color>] $piece_offerbowl_offeritem\n$pw_ward_offerings_compendium_hint");
				}
			}

			[HarmonyPriority(0)]
			public static void Postfix(PrivateArea __instance, StringBuilder text)
			{
				ReplaceWardPermittedHoverStatus(__instance, text);
			}
		}

		[HarmonyPatch(typeof(PrivateArea), "IsPermitted")]
		public static class PrivateArea_IsPermitted_AdditionalAccess
		{
			public static bool Prefix(PrivateArea __instance, long playerID, ref bool __result)
			{
				if (!HasWardManagementAccess(__instance, playerID) && !GuildsCompat.HasWardGuildAccess(__instance, playerID))
				{
					return true;
				}
				__result = true;
				return false;
			}
		}

		[HarmonyPatch(typeof(PrivateArea), "Interact")]
		public static class PrivateArea_Interact_PassiveEffectWardRepair
		{
			private static bool Prefix(PrivateArea __instance, Humanoid human, bool hold, bool alt, Faction ___m_ownerFaction, ref bool __result)
			{
				//IL_000d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0010: Invalid comparison between Unknown and I4
				if (hold)
				{
					return true;
				}
				if ((int)___m_ownerFaction > 0)
				{
					return true;
				}
				Player val = (Player)(object)((human is Player) ? human : null);
				if (WardPasswordProtection.TryHandleInteraction(__instance, val))
				{
					__result = true;
					return false;
				}
				if (!alt)
				{
					return true;
				}
				if (!__instance.HaveLocalAccess())
				{
					return true;
				}
				areaCache.Clear();
				if (__instance.IsEnabled() && wardPassiveRepair.Value)
				{
					__result = true;
					if (wardIsRepairing.ContainsKey(__instance))
					{
						return false;
					}
					LogInfo("Passive repairing begins");
					((MonoBehaviour)instance).StartCoroutine(PassiveRepairEffect(__instance, val));
					return false;
				}
				if (!__instance.IsEnabled() && (CanEditWardSettings(__instance, val) || WardPasswordProtection.CanChangePassword(__instance, val)))
				{
					__result = true;
					WardSettingsUI.Open(__instance);
					return false;
				}
				return true;
			}
		}

		[HarmonyPatch(typeof(PrivateArea), "Awake")]
		public static class PrivateArea_Awake_SetWardRange
		{
			private static void Postfix(PrivateArea __instance, ZNetView ___m_nview)
			{
				if (!((Object)(object)___m_nview == (Object)null) && ___m_nview.IsValid() && IsPlayerWardPrefab(__instance))
				{
					CacheWardDefaultRange(__instance);
					PatchRange(__instance);
					WardExpiration.TryReactivateFromNearbyPlayer(__instance);
					if (showAreaMarker.Value)
					{
						((Component)__instance.m_areaMarker).gameObject.SetActive(true);
					}
					InitBubbleState(__instance, EnsureWardBubble(__instance), ___m_nview);
					InitDemisterState(__instance, EnsureWardDemister(__instance), ___m_nview);
					InitEmissionColor(__instance);
					ProtectiveWards instance = ProtectiveWards.instance;
					if (instance != null)
					{
						((MonoBehaviour)instance).StartCoroutine(DelayedRefreshWardVisuals(__instance));
					}
				}
			}
		}

		[HarmonyPatch(typeof(PrivateArea), "RPC_FlashShield")]
		public static class PrivateArea_RPC_FlashShield_StopFlashShield
		{
			private static bool Prefix(PrivateArea __instance)
			{
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				//IL_0008: Invalid comparison between Unknown and I4
				if ((int)__instance.m_ownerFaction == 0)
				{
					return !disableFlash.Value;
				}
				return true;
			}
		}

		[HarmonyPatch(typeof(ZoneSystem), "Start")]
		public static class ZoneSystem_Start_InitWardBubble
		{
			private static void Postfix(ZoneSystem __instance)
			{
				//IL_004f: 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_00b1: Expected O, but got Unknown
				ZoneLocation val = __instance.m_locations.Find((ZoneLocation loc) => loc.m_prefabName == "Vendor_BlackForest");
				if (val != null && val.m_prefab.IsValid)
				{
					val.m_prefab.Load();
					Transform obj = val.m_prefab.Asset.transform.Find("ForceField");
					forceField = Object.Instantiate<GameObject>((obj != null) ? ((Component)obj).gameObject : null);
					((Object)forceField).name = "ProtectiveWards_bubble";
					MeshRenderer component = forceField.GetComponent<MeshRenderer>();
					((Renderer)component).sharedMaterial = new Material(((Renderer)component).sharedMaterial);
					Material sharedMaterial = ((Renderer)component).sharedMaterial;
					int renderQueue = sharedMaterial.renderQueue;
					sharedMaterial.renderQueue = renderQueue + 1;
					val.m_prefab.Release();
					RefreshAllLoadedWardVisuals();
				}
			}
		}

		[HarmonyPatch(typeof(ZoneSystem), "OnDestroy")]
		public static class ZoneSystem_OnDestroy_DestroyWardBubble
		{
			private static void Postfix()
			{
				Object.Destroy((Object)(object)forceField);
				forceField = null;
				forceFieldDemister = null;
				lightningAOE = null;
				preLightning = null;
			}
		}

		[HarmonyPatch(typeof(ZNetScene), "Awake")]
		internal static class ZNetScene_Awake_DemisterForceField
		{
			private static void Postfix(ZNetScene __instance)
			{
				GameObject prefab = __instance.GetPrefab("Demister");
				object forceFieldDemister;
				if (prefab == null)
				{
					forceFieldDemister = null;
				}
				else
				{
					Transform obj = prefab.transform.Find("Particle System Force Field");
					forceFieldDemister = ((obj != null) ? ((Component)obj).gameObject : null);
				}
				ProtectiveWards.forceFieldDemister = (GameObject)forceFieldDemister;
			}
		}

		[HarmonyPatch(typeof(PrivateArea), "RPC_ToggleEnabled")]
		public static class PrivateArea_RPC_ToggleEnabled_InitWardBubble
		{
			private static void Postfix(PrivateArea __instance, ZNetView ___m_nview, long playerID)
			{
				if (!((Object)(object)___m_nview == (Object)null) && ___m_nview.IsValid() && IsPlayerWardPrefab(__instance))
				{
					CacheWardDefaultRange(__instance);
					PatchRange(__instance);
					InitEmissionColor(__instance);
					Transform obj = ((Component)__instance).transform.Find("ForceField");
					InitBubbleState(__instance, (obj != null) ? ((Component)obj).gameObject : null, ___m_nview);
					Transform obj2 = ((Component)__instance).transform.Find("Particle System Force Field");
					InitDemisterState(__instance, (obj2 != null) ? ((Component)obj2).gameObject : null, ___m_nview);
					InitCircleProjectorState(__instance.m_areaMarker, ___m_nview);
					if (__instance.IsEnabled())
					{
						Player player = Player.GetPlayer(playerID);
						ActivateConnectedLoadedWards(__instance, playerID, ((player != null) ? player.GetPlayerName() : null) ?? "");
					}
				}
			}
		}

		public const string pluginID = "shudnal.ProtectiveWards";

		public const string pluginName = "Protective Wards";

		public const string pluginVersion = "2.0.6";

		private static Harmony _harmony;

		public static ConfigEntry<bool> disableFlash;

		public static ConfigEntry<bool> showAreaMarker;

		public static ConfigEntry<bool> loggingEnabled;

		public static ConfigEntry<int> refreshingTime;

		public static ConfigEntry<bool> showOfferingsInHover;

		public static ConfigEntry<float> maxTaxiSpeed;

		public static ConfigEntry<bool> addLightMovement;

		public static ConfigEntry<WardSettingsMode> wardSettingsMode;

		public static ConfigEntry<bool> wardSettingsUseDefaultsForAllWards;

		public static ConfigEntry<bool> wardSettingsRequireCreator;

		public static ConfigEntry<bool> wardSettingsAllowAdminEdit;

		public static ConfigEntry<WardPasswordFieldMode> wardPasswordFieldMode;

		public static ConfigEntry<WardPasswordChangeAccess> wardPasswordChangeAccess;

		public static ConfigEntry<bool> offeringActiveRepair;

		public static ConfigEntry<bool> offeringAugmenting;

		public static ConfigEntry<bool> offeringFood;

		public static ConfigEntry<bool> offeringMead;

		public static ConfigEntry<bool> offeringThundertone;

		public static ConfigEntry<bool> offeringTrophy;

		public static ConfigEntry<bool> offeringYmirRemains;

		public static ConfigEntry<bool> offeringEitr;

		public static ConfigEntry<bool> offeringDragonEgg;

		public static ConfigEntry<bool> offeringTaxi;

		public static ConfigEntry<bool> offeringProtectFromNonPermitted;

		public static ConfigEntry<bool> offeringTaxiStartTempleEnabled;

		public static ConfigEntry<bool> offeringTaxiStartTempleConsumeItem;

		public static ConfigEntry<bool> offeringTaxiHaldorEnabled;

		public static ConfigEntry<string> offeringTaxiPriceHaldorItem;

		public static ConfigEntry<int> offeringTaxiPriceHaldorUndiscovered;

		public static ConfigEntry<int> offeringTaxiPriceHaldorDiscovered;

		public static ConfigEntry<bool> offeringTaxiHaldorConsumeItem;

		public static ConfigEntry<bool> offeringTaxiHildirEnabled;

		public static ConfigEntry<bool> offeringTaxiHildirChestsEnabled;

		public static ConfigEntry<string> offeringTaxiPriceHildirItem;

		public static ConfigEntry<int> offeringTaxiPriceHildirAmount;

		public static ConfigEntry<bool> offeringTaxiHildirConsumeItem;

		public static ConfigEntry<bool> offeringTaxiBogWitchEnabled;

		public static ConfigEntry<string> offeringTaxiPriceBogWitchItem;

		public static ConfigEntry<int> offeringTaxiPriceBogWitchAmount;

		public static ConfigEntry<bool> offeringTaxiBogWitchConsumeItem;

		public static ConfigEntry<int> offeringTaxiSecondsToFlyBack;

		public static ConfigEntry<int> offeringTaxiReturnWaitLimitSeconds;

		public static ConfigEntry<WardTaxiExistingFlightMode> offeringTaxiExistingFlightMode;

		public static ConfigEntry<bool> offeringTaxiEikthyrAltarEnabled;

		public static ConfigEntry<string> offeringTaxiEikthyrAltarItem;

		public static ConfigEntry<int> offeringTaxiEikthyrAltarAmount;

		public static ConfigEntry<bool> offeringTaxiEikthyrAltarConsumeItem;

		public static ConfigEntry<bool> offeringTaxiElderAltarEnabled;

		public static ConfigEntry<string> offeringTaxiElderAltarItem;

		public static ConfigEntry<int> offeringTaxiElderAltarAmount;

		public static ConfigEntry<bool> offeringTaxiElderAltarConsumeItem;

		public static ConfigEntry<bool> offeringTaxiBonemassAltarEnabled;

		public static ConfigEntry<string> offeringTaxiBonemassAltarItem;

		public static ConfigEntry<int> offeringTaxiBonemassAltarAmount;

		public static ConfigEntry<bool> offeringTaxiBonemassAltarConsumeItem;

		public static ConfigEntry<bool> offeringTaxiModerAltarEnabled;

		public static ConfigEntry<string> offeringTaxiModerAltarItem;

		public static ConfigEntry<int> offeringTaxiModerAltarAmount;

		public static ConfigEntry<bool> offeringTaxiModerAltarConsumeItem;

		public static ConfigEntry<bool> offeringTaxiYagluthAltarEnabled;

		public static ConfigEntry<string> offeringTaxiYagluthAltarItem;

		public static ConfigEntry<int> offeringTaxiYagluthAltarAmount;

		public static ConfigEntry<bool> offeringTaxiYagluthAltarConsumeItem;

		public static ConfigEntry<bool> offeringTaxiQueenAltarEnabled;

		public static ConfigEntry<string> offeringTaxiQueenAltarItem;

		public static ConfigEntry<int> offeringTaxiQueenAltarAmount;

		public static ConfigEntry<bool> offeringTaxiQueenAltarConsumeItem;

		public static ConfigEntry<bool> offeringTaxiFaderAltarEnabled;

		public static ConfigEntry<string> offeringTaxiFaderAltarItem;

		public static ConfigEntry<int> offeringTaxiFaderAltarAmount;

		public static ConfigEntry<bool> offeringTaxiFaderAltarConsumeItem;

		public static ConfigEntry<bool> wardPassiveRepair;

		public static ConfigEntry<bool> wardPassiveRepairNonPlayer;

		public static ConfigEntry<bool> wardPassiveRepairRequireStation;

		public static ConfigEntry<int> autoCloseDoorsTime;

		public static ConfigEntry<string> autoCloseDoorsIgnorePrefabs;

		public static ConfigEntry<bool> setWardRange;

		public static ConfigEntry<float> wardRange;

		public static ConfigEntry<WardAreaShape> wardAreaShape;

		public static ConfigEntry<bool> wardProtectDungeonInteriors;

		public static ConfigEntry<bool> supressSpawnInRange;

		public static ConfigEntry<bool> permitEveryone;

		public static ConfigEntry<float> playerDamageDealtMultiplier;

		public static ConfigEntry<float> playerDamageTakenMultiplier;

		public static ConfigEntry<float> tamedDamageTakenMultiplier;

		public static ConfigEntry<float> structureDamageTakenMultiplier;

		public static ConfigEntry<float> fallDamageTakenMultiplier;

		public static ConfigEntry<float> turretFireRateMultiplier;

		public static ConfigEntry<float> foodDrainMultiplier;

		public static ConfigEntry<float> staminaDrainMultiplier;

		public static ConfigEntry<float> skillsDrainMultiplier;

		public static ConfigEntry<float> fireplaceDrainMultiplier;

		public static ConfigEntry<float> hammerDurabilityDrainMultiplier;

		public static ConfigEntry<float> smeltingSpeedMultiplier;

		public static ConfigEntry<float> cookingSpeedMultiplier;

		public static ConfigEntry<float> fermentingSpeedMultiplier;

		public static ConfigEntry<float> sapCollectingSpeedMultiplier;

		public static ConfigEntry<bool> wardBubbleShow;

		public static ConfigEntry<Color> wardBubbleColor;

		public static ConfigEntry<float> wardBubbleRefractionIntensity;

		public static ConfigEntry<float> wardBubbleWaveIntensity;

		public static ConfigEntry<float> wardBubbleGlossiness;

		public static ConfigEntry<float> wardBubbleMetallic;

		public static ConfigEntry<float> wardBubbleNormalScale;

		public static ConfigEntry<float> wardBubbleDepthFade;

		public static ConfigEntry<bool> wardAreaMarkerPatch;

		public static ConfigEntry<float> wardAreaMarkerSpeed;

		public static ConfigEntry<Color> wardAreaMarkerStartColor;

		public static ConfigEntry<Color> wardAreaMarkerEndColor;

		public static ConfigEntry<float> wardAreaMarkerLength;

		public static ConfigEntry<float> wardAreaMarkerWidth;

		public static ConfigEntry<float> wardAreaMarkerAmount;

		public static ConfigEntry<bool> wardEmissionColorEnabled;

		public static ConfigEntry<Color> wardEmissionColor;

		public static ConfigEntry<float> wardEmissionColorMultiplier;

		public static ConfigEntry<bool> wardLightColorEnabled;

		public static ConfigEntry<bool> wardDemisterEnabled;

		public static ConfigEntry<bool> boarsHensProtection;

		public static ConfigEntry<bool> wardRainProtection;

		public static ConfigEntry<ShipDamageType> wardShipProtection;

		public static ConfigEntry<bool> wardPlantProtection;

		public static ConfigEntry<bool> fireplaceProtection;

		public static ConfigEntry<bool> sittingRaidProtection;

		public static ConfigEntry<bool> wardTrapProtection;

		public static ConfigEntry<string> wardPlantProtectionList;

		public static ConfigEntry<string> boarsHensProtectionGroupList;

		public static ConfigEntry<bool> wardAccessProtectChests;

		public static ConfigEntry<bool> wardAccessProtectDoors;

		public static ConfigEntry<bool> wardAccessProtectPlants;

		public static ConfigEntry<bool> wardAccessProtectBoats;

		public static ConfigEntry<bool> wardAccessProtectTames;

		public static ConfigEntry<bool> wardAccessProtectProductionStations;

		public static ConfigEntry<bool> wardAccessProtectItemStands;

		public static ConfigEntry<bool> wardAccessProtectCarts;

		public static ConfigEntry<WardPortalAccessMode> wardAccessProtectPortals;

		public static ConfigEntry<bool> wardAccessProtectFood;

		public static ConfigEntry<WardItemPickupMode> wardAccessProtectItemPickupMode;

		public static ConfigEntry<bool> wardAccessProtectMapTables;

		public static ConfigEntry<bool> wardAccessProtectFireplaces;

		public static ConfigEntry<bool> wardAccessProtectShieldGenerators;

		public static ConfigEntry<bool> wardAccessProtectIncinerators;

		public static ConfigEntry<bool> wardAccessProtectTurrets;

		public static ConfigEntry<bool> wardAccessProtectCraftingStations;

		public static ConfigEntry<bool> wardAccessProtectBeds;

		public static ConfigEntry<bool> wardAccessProtectCatapults;

		public static ConfigEntry<bool> wardAccessProtectArcheryTargets;

		public static ConfigEntry<bool> wardAccessProtectBarbers;

		public static ConfigEntry<bool> wardAccessProtectInactiveWards;

		public static ConfigEntry<WardConnectedAccessMode> wardAccessConnectedAccessMode;

		public static ConfigEntry<bool> wardAccessProtectInteractables;

		public static ConfigEntry<bool> wardBackgroundTamesPreventDamageToStructures;

		public static ConfigEntry<float> wardBackgroundPresenceRadius;

		public static ConfigEntry<WardBackgroundPresenceMode> wardBackgroundPresenceMode;

		public static ConfigEntry<WardConnectedAccessMode> wardBackgroundConnectedAccessMode;

		public static ConfigEntry<int> wardBackgroundProtectedBaseMinPieces;

		public static ConfigEntry<WardBackgroundStructureProtectionMode> wardBackgroundStructureProtection;

		public static ConfigEntry<bool> wardBackgroundProtectFire;

		public static ConfigEntry<bool> wardBackgroundProtectTames;

		public static ConfigEntry<bool> wardBackgroundProtectBoats;

		public static ConfigEntry<bool> wardBackgroundProtectCarts;

		public static ConfigEntry<WardBackgroundTamePacifyMode> wardBackgroundTamePacify;

		public static ConfigEntry<bool> wardBackgroundPreventBuildingAndDemolishing;

		public static ConfigEntry<WardAdminAccessMode> wardAdminAccess;

		public static ConfigEntry<bool> wardExternalControlCommandsEnabled;

		public static ConfigEntry<float> wardExternalControlCommandRange;

		public static ConfigEntry<int> wardBuildLimitPerPlayer;

		public static ConfigEntry<int> wardExpirationMinutes;

		public static ConfigEntry<WardExpirationRefreshMode> wardExpirationRefreshMode;

		public static ConfigEntry<WardConnectedAccessMode> wardExpirationConnectedAccessMode;

		public static ConfigEntry<WardExpirationReactivationMode> wardExpirationReactivationMode;

		public static ConfigEntry<bool> wardExpirationAdminHover;

		internal static ProtectiveWards instance;

		internal static long startTimeCached;

		internal static Dictionary<Vector3, PrivateArea> areaCache = new Dictionary<Vector3, PrivateArea>();

		private static readonly Dictionary<Location, Teleport> dungeonEntranceCache = new Dictionary<Location, Teleport>();

		internal static Dictionary<PrivateArea, int> wardIsRepairing = new Dictionary<PrivateArea, int>();

		internal static Dictionary<PrivateArea, int> wardIsHealing = new Dictionary<PrivateArea, int>();

		internal static Dictionary<PrivateArea, int> wardIsClosing = new Dictionary<PrivateArea, int>();

		internal static Dictionary<PrivateArea, List<Door>> doorsToClose = new Dictionary<PrivateArea, List<Door>>();

		internal static GameObject lightningAOE;

		internal static EffectList preLightning;

		internal static List<TrophyTarget> trophyTargets;

		internal static int baseValueProtected = 999;

		internal static GameObject forceField;

		internal const string forceFieldName = "ForceField";

		internal static GameObject forceFieldDemister;

		internal const string forceFieldDemisterName = "Particle System Force Field";

		internal static HashSet<string> _wardPlantProtectionList;

		internal static HashSet<string> _boarsHensProtectionGroupList;

		public static readonly int s_customRange = StringExtensionMethods.GetStableHashCode("ward_useRange");

		public static readonly int s_range = StringExtensionMethods.GetStableHashCode("ward_range");

		public static readonly int s_customColor = StringExtensionMethods.GetStableHashCode("ward_useColor");

		public static readonly int s_color = StringExtensionMethods.GetStableHashCode("ward_color");

		public static readonly int s_colorMultiplier = StringExtensionMethods.GetStableHashCode("ward_colorMultiplier");

		public static readonly int s_circleEnabled = StringExtensionMethods.GetStableHashCode("circle_enabled");

		public static readonly int s_circleStartColor = StringExtensionMethods.GetStableHashCode("circle_startColor");

		public static readonly int s_circleEndColor = StringExtensionMethods.GetStableHashCode("circle_endColor");

		public static readonly int s_circleSpeed = StringExtensionMethods.GetStableHashCode("circle_speed");

		public static readonly int s_circleLength = StringExtensionMethods.GetStableHashCode("circle_length");

		public static readonly int s_circleWidth = StringExtensionMethods.GetStableHashCode("circle_width");

		public static readonly int s_circleAmount = StringExtensionMethods.GetStableHashCode("circle_amount");

		public static readonly int s_bubbleEnabled = StringExtensionMethods.GetStableHashCode("bubble_enabled");

		public static readonly int s_bubbleColor = StringExtensionMethods.GetStableHashCode("bubble_color");

		public static readonly int s_bubbleColorAlpha = StringExtensionMethods.GetStableHashCode("bubble_color_alpha");

		public static readonly int s_bubbleWaveVel = StringExtensionMethods.GetStableHashCode("bubble_wave");

		public static readonly int s_bubbleRefractionIntensity = StringExtensionMethods.GetStableHashCode("bubble_refraction");

		public static readonly int s_bubbleGlossiness = StringExtensionMethods.GetStableHashCode("bubble_glossiness");

		public static readonly int s_bubbleMetallic = StringExtensionMethods.GetStableHashCode("bubble_metallic");

		public static readonly int s_bubbleNormalScale = StringExtensionMethods.GetStableHashCode("bubble_normalscale");

		public static readonly int s_bubbleDepthFade = StringExtensionMethods.GetStableHashCode("bubble_depthfade");

		public static readonly int s_lastSaddleUser = StringExtensionMethods.GetStableHashCode("pw_last_saddle_user");

		public static readonly int s_lastVehicleController = StringExtensionMethods.GetStableHashCode("pw_last_vehicle_controller");

		public static readonly int s_permitEveryone = StringExtensionMethods.GetStableHashCode("pw_permit_everyone");

		private static readonly MaterialPropertyBlock s_matBlock = new MaterialPropertyBlock();

		private static readonly Dictionary<PrivateArea, float> s_wardDefaultRanges = new Dictionary<PrivateArea, float>();

		private static readonly Dictionary<PrivateArea, WardEmissionDefaults> s_wardEmissionDefaults = new Dictionary<PrivateArea, WardEmissionDefaults>();

		private static float offeringsTimer = 0f;

		private const int WardHoverPermittedNamesLengthLimit = 30;

		private static bool s_activatingConnectedWards;

		private static bool s_activatingConnectedWardZdos;

		private void Awake()
		{
			instance = this;
			ConfigInit();
			CompatibilityHelper.CheckForCompatibility();
			_harmony = Harmony.CreateAndPatchAll(Assembly.GetExecutingAssembly(), "shudnal.ProtectiveWards");
			((MonoBehaviour)this).StartCoroutine(Localizer.Load());
		}

		private void Start()
		{
			FullProtection.PatchLoadedInteractables(_harmony);
		}

		private void FixedUpdate()
		{
			if (offeringsTimer > 0f)
			{
				offeringsTimer -= Time.fixedDeltaTime;
			}
			WardExpiration.Update();
		}

		private void OnDestroy()
		{
			((BaseUnityPlugin)this).Config.Save();
			Harmony harmony = _harmony;
			if (harmony != null)
			{
				harmony.UnpatchSelf();
			}
			FullProtection.ResetDynamicPatchState();
			CompatibilityHelper.ResetRuntimeState();
		}

		public static void LogInfo(object data)
		{
			if (loggingEnabled.Value)
			{
				((BaseUnityPlugin)instance).Logger.LogInfo(data);
			}
		}

		private void ConfigInit()
		{
			//IL_0af4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0c3b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0c5b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0dca: Unknown result type (might be due to invalid IL or missing references)
			wardSettingsMode = config("Ward settings", "Ward settings mode", WardSettingsMode.PerWard, "Controls whether individual wards may use and edit settings stored in their ZDO.\nPerWard: authorized players can open the ward settings window and saved per-ward overrides are applied.\nServerControlled: the ward settings action and window are disabled, saved per-ward overrides remain stored but are ignored, and global config values are used.");
			wardSettingsUseDefaultsForAllWards = config("Ward settings", "Use default values for wards without custom settings", defaultValue: true, "If enabled, wards without per-ward ZDO overrides use the default values from this config. If disabled, only values explicitly saved on a ward are applied. This setting is ignored when Ward settings mode is ServerControlled.");
			wardSettingsRequireCreator = config("Ward settings", "Only creator can edit ward settings", defaultValue: true, "If enabled, only the ward creator can open and apply the per-ward settings window. If disabled, any player with ward access can edit these settings. Ignored when Ward settings mode is ServerControlled.");
			wardSettingsAllowAdminEdit = config("Ward settings", "Admins can edit ward settings", defaultValue: true, "If enabled, players allowed by Ward admin access or the ward's effective Permit everyone value can open and apply the per-ward settings window regardless of ward creator/access checks. Ignored when Ward settings mode is ServerControlled.");
			wardAreaShape = config("Ward settings", "Protected area shape", WardAreaShape.Cylinder, "Controls normal active player ward range checks and connected ward overlap.\nCylinder: uses horizontal XZ distance and ignores height.\nSphere: uses full 3D distance from the ward.\nBackground protection keeps horizontal XZ checks for movable objects.");
			wardProtectDungeonInteriors = config("Ward settings", "Protect dungeon interiors through warded entrances", defaultValue: true, "When enabled, an interior inherits ward protection when its outside entrance is inside an active ward. All enabled protection rules then apply throughout that interior. When disabled, outside wards do not protect dungeon interiors.");
			disableFlash = config("Misc", "Disable flash", defaultValue: false, "Disable flash on hit [Not Synced with Server]", synchronizedSetting: false);
			showAreaMarker = config("Misc", "Always show radius", defaultValue: false, "Always show ward radius. Hover the ward for changes to take effect. [Not Synced with Server]", synchronizedSetting: false);
			refreshingTime = config("Misc", "Ward protected status check time", 30, "Set how many seconds the \"inside the protected zone\" status is reset. [Not Synced with Server]\nSetting more seconds can be helpful for fps for base with many objects and static untoggled wards. \nDoesn't affect moving objects.", synchronizedSetting: false);
			loggingEnabled = config("Misc", "Enable logging", defaultValue: false, "Enable logging for ward events. [Not Synced with Server]", synchronizedSetting: false);
			showOfferingsInHover = config("Misc", "Show offerings in hover", defaultValue: true, "Show a short ward hover hint pointing to the Valheim Compendium offerings entry and add the ward offerings topic to known texts. [Not Synced with Server]", synchronizedSetting: false);
			maxTaxiSpeed = config("Misc", "Maximum taxi speed", 60f, "Reduce maximum taxi speed if it is laggy. [Not Synced with Server]", synchronizedSetting: false);
			addLightMovement = config("Misc", "Add movement to light emitted by ward", defaultValue: true, "Adds little lavalamp effect on light emitted by ward. Applied only if ward emission color was changed. Reactivate ward after config change. [Not Synced with Server]", synchronizedSetting: false);
			playerDamageDealtMultiplier = config("Modifiers damage", "Creatures damage taken multiplier", 1f, "Basically it means damage dealt by any creatures (players and tames included) to any creatures (players and tames excluded)");
			playerDamageTakenMultiplier = config("Modifiers damage", "Player damage taken multiplier", 1f, "Damage taken by players from creatures");
			fallDamageTakenMultiplier = config("Modifiers damage", "Player fall damage taken multiplier", 1f, "Player fall damage taken");
			structureDamageTakenMultiplier = config("Modifiers damage", "Structure damage taken multiplier", 1f, "Structures (and ships) damage taken");
			tamedDamageTakenMultiplier = config("Modifiers damage", "Tamed damage taken multiplier", 1f, "Damage taken by tamed from creatures (players included)");
			turretFireRateMultiplier = config("Modifiers damage", "Turret fire rate multiplier", 1f, "Basically time between shots");
			foodDrainMultiplier = config("Modifiers drain", "Food drain multiplier", 1f, "Speed of food drain, more - faster, less - slower");
			staminaDrainMultiplier = config("Modifiers drain", "Stamina drain multiplier", 1f, "Multiplier of stamina needed for actions");
			skillsDrainMultiplier = config("Modifiers drain", "Skills drain on death multiplier", 1f, "Multiplier of how much skill points you lose on death. Accumulated scale will be lost anyway");
			fireplaceDrainMultiplier = config("Modifiers drain", "Fireplace fuel drain multiplier", 1f, "Speed of fuel spent for fireplaces (including bathtub, torches and braziers)");
			hammerDurabilityDrainMultiplier = config("Modifiers drain", "Hammer durability drain multiplier", 1f, "Multiplier of how much hammer's durability will be spent on building and repairing");
			smeltingSpeedMultiplier = config("Modifiers speed", "Smelting speed multiplier", 1f, "Speed of smelting for all smelting stations (excluding bathtub)");
			cookingSpeedMultiplier = config("Modifiers speed", "Cooking speed multiplier", 1f, "Speed of cooking for all cooking stations (that also means faster burn)");
			fermentingSpeedMultiplier = config("Modifiers speed", "Fermenting speed multiplier", 1f, "Speed of fermenting");
			sapCollectingSpeedMultiplier = config("Modifiers speed", "Sap collecting speed multiplier", 1f, "Speed of sap collecting");
			offeringActiveRepair = config("Offerings", "1 - Repair all pieces by surtling core offering", defaultValue: true, "Offer surtling core to ward to instantly repair all pieces in all connected areas\nCore will NOT be wasted if there is no piece to repair");
			offeringAugmenting = config("Offerings", "2 - Augment all pieces by black core offering", defaultValue: true, "Offer black core to ward to double the health of every structural piece in all connected areas\nCore will NOT be wasted if there is no piece to repair");
			offeringFood = config("Offerings", "3 - Heal all allies for 3 min by food offering", defaultValue: true, "Offer food to ward to activate healing for 3 minutes in all connected areas. Better food means better heal.\nYou can offer one food to one ward until 3 minutes are gone. But nothing stops you from offering food to several wards.");
			offeringMead = config("Offerings", "4 - Share mead effect to all players by mead offering", defaultValue: true, "Offer mead to ward to share the effect to all players in all connected areas. \nMead will NOT be wasted if no one can have effect.");
			offeringThundertone = config("Offerings", "5 - Call the wrath of the Thor upon your enemies by thunderstone offering", defaultValue: true, "Offer thunderstone to ward to call the Thor's wrath upon your enemies in all connected areas\nThunderstone WILL be wasted even if no one gets hurt");
			offeringTrophy = config("Offerings", "6 - Kill all enemies of the same type by trophy offering", defaultValue: true, "Offer trophy to ward to kill all enemies with type of the offered trophy in all connected areas\nTrophy will NOT be wasted if no one gets hurt");
			offeringYmirRemains = config("Offerings", "7 - Grow all plants by Ymir flesh offering", defaultValue: true, "Offer Ymir flesh to instantly grow every plant in all connected areas\nYmir flesh will NOT be wasted if there is no plant to grow");
			offeringEitr = config("Offerings", "8 - Grow all plants regardless the requirements by Eitr x5 offering", defaultValue: true, "Offer 5 Eitr to instantly grow every plant regardless the requirements in all connected areas\nEitr will NOT be wasted if there is no plant to grow");
			offeringDragonEgg = config("Offerings", "9 - Activate Moder power by dragon egg offering", defaultValue: true, "Offer dragon egg to activate Moder power on all players in all connected areas.");
			offeringTaxi = config("Offerings", "10 - Fly back and forth to distant point by different items offering", defaultValue: true, "Enables all taxi offering logic. Individual taxi destinations can be enabled, disabled, priced, and configured in the Offerings - Taxi groups.\nSupported default destinations include Sacrificial Stones, Haldor, Hildir, and Bog Witch.\nOptional boss altar destinations are available in the Offerings - Taxi - Boss altars group and are disabled by default.");
			offeringProtectFromNonPermitted = config("Offerings", "Protect from non-permitted players", defaultValue: false, "Set whether active Ward offerings are allowed only for players with direct or connected ward access. Disabled by default so visitors can make offerings to active wards.");
			offeringTaxiStartTempleEnabled = config("Offerings - Taxi", "Sacrificial Stones taxi", defaultValue: true, "Allow boss trophy offerings to call a free taxi to the Sacrificial Stones.");
			offeringTaxiStartTempleConsumeItem = config("Offerings - Taxi", "Sacrificial Stones taxi consumes boss trophy", defaultValue: false, "Whether boss trophy taxi to the Sacrificial Stones consumes the offered boss trophy.");
			offeringTaxiHaldorEnabled = config("Offerings - Taxi", "Haldor taxi", defaultValue: true, "Allow configured item offerings to call a taxi to Haldor.");
			offeringTaxiPriceHaldorItem = config("Offerings - Taxi", "Item to travel to Haldor", "Coins", "A prefab name of the item required to travel to Haldor. Example: Coins.");
			offeringTaxiPriceHaldorUndiscovered = config("Offerings - Taxi", "Price to undiscovered Haldor", 2000, "Configured Haldor taxi item amount required to discover and travel to nearest Haldor.");
			offeringTaxiPriceHaldorDiscovered = config("Offerings - Taxi", "Price to discovered Haldor", 500, "Configured Haldor taxi item amount required to travel to already discovered Haldor.");
			offeringTaxiHaldorConsumeItem = config("Offerings - Taxi", "Haldor taxi consumes item", defaultValue: true, "Whether Haldor taxi consumes the configured item amount.");
			offeringTaxiHildirEnabled = config("Offerings - Taxi", "Hildir taxi", defaultValue: true, "Allow Hildir chest or configured item offerings to call a taxi to Hildir.");
			offeringTaxiHildirChestsEnabled = config("Offerings - Taxi", "Hildir chest taxi", defaultValue: true, "Allow Hildir chest offerings to call a free taxi to Hildir. Hildir chests are never consumed.");
			offeringTaxiPriceHildirItem = config("Offerings - Taxi", "Item to travel to Hildir", "LinenThread", "A prefab name of the item required to travel to Hildir when not using a Hildir chest. Example: LinenThread.");
			offeringTaxiPriceHildirAmount = config("Offerings - Taxi", "Item to travel to Hildir amount", 50, "An amount of configured items required to travel to Hildir when not using a Hildir chest.");
			offeringTaxiHildirConsumeItem = config("Offerings - Taxi", "Hildir taxi consumes item", defaultValue: true, "Whether Hildir taxi consumes the configured non-chest item amount.");
			offeringTaxiBogWitchEnabled = config("Offerings - Taxi", "Bog Witch taxi", defaultValue: true, "Allow configured item offerings to call a taxi to Bog Witch.");
			offeringTaxiPriceBogWitchItem = config("Offerings - Taxi", "Item to travel to Bog Witch", "Pukeberries", "A prefab name of the item required to travel to Bog Witch. Example: Pukeberries.");
			offeringTaxiPriceBogWitchAmount = config("Offerings - Taxi", "Item to travel to Bog Witch amount", 20, "An amount of configured items required to travel to Bog Witch.");
			offeringTaxiBogWitchConsumeItem = config("Offerings - Taxi", "Bog Witch taxi consumes item", defaultValue: true, "Whether Bog Witch taxi consumes the configured item amount.");
			offeringTaxiSecondsToFlyBack = config("Offerings - Taxi", "Seconds to fly back", 120, "Seconds before the Valkyrie carries the player back after reaching the destination. 0 disables the return flight.");
			offeringTaxiReturnWaitLimitSeconds = config("Offerings - Taxi", "Seconds to wait for return flight", 600, "Maximum seconds the Valkyrie waits for the player to become ready for the return flight. 0 disables this timeout.");
			offeringTaxiExistingFlightMode = config("Offerings - Taxi", "Active passage handling", WardTaxiExistingFlightMode.RejectNewPassage, "Controls what happens when a player makes a taxi offering while a Valkyrie passage is already active. RejectNewPassage shows an error and keeps the current passage. StopActivePassage stops the current passage without starting a new one; make the offering again to start a new passage.");
			offeringTaxiEikthyrAltarEnabled = config("Offerings - Taxi - Boss altars", "Allow taxi to Eikthyr altar", defaultValue: false, "Allow configured item offerings to call a taxi to the Eikthyr altar.");
			offeringTaxiEikthyrAltarItem = config("Offerings - Taxi - Boss altars", "Allow taxi to Eikthyr altar item", "TrophyDeer", "A prefab name of the item required to travel to the Eikthyr altar. Example: TrophyDeer.");
			offeringTaxiEikthyrAltarAmount = config("Offerings - Taxi - Boss altars", "Allow taxi to Eikthyr altar item amount", 10, "An amount of configured items required to travel to the Eikthyr altar.");
			offeringTaxiEikthyrAltarConsumeItem = config("Offerings - Taxi - Boss altars", "Allow taxi to Eikthyr altar item consumed", defaultValue: true, "Whether the configured item amount required to travel to the Eikthyr altar is consumed.");
			offeringTaxiElderAltarEnabled = config("Offerings - Taxi - Boss altars", "Allow taxi to Elder altar", defaultValue: false, "Allow configured item offerings to call a taxi to the Elder altar.");
			offeringTaxiElderAltarItem = config("Offerings - Taxi - Boss altars", "Allow taxi to Elder altar item", "AncientSeed", "A prefab name of the item required to travel to the Elder altar. Example: AncientSeed.");
			offeringTaxiElderAltarAmount = config("Offerings - Taxi - Boss altars", "Allow taxi to Elder altar item amount", 6, "An amount of configured items required to travel to the Elder altar.");
			offeringTaxiElderAltarConsumeItem = config("Offerings - Taxi - Boss altars", "Allow taxi to Elder altar item consumed", defaultValue: true, "Whether the configured item amount required to travel to the Elder altar is consumed.");
			offeringTaxiBonemassAltarEnabled = config("Offerings - Taxi - Boss altars", "Allow taxi to Bonemass altar", defaultValue: false, "Allow configured item offerings to call a taxi to the Bonemass altar.");
			offeringTaxiBonemassAltarItem = config("Offerings - Taxi - Boss altars", "Allow taxi to Bonemass altar item", "WitheredBone", "A prefab name of the item required to travel to the Bonemass altar. Example: WitheredBone.");
			offeringTaxiBonemassAltarAmount = config("Offerings - Taxi - Boss altars", "Allow taxi to Bonemass altar item amount", 30, "An amount of configured items required to travel to the Bonemass altar.");
			offeringTaxiBonemassAltarConsumeItem = config("Offerings - Taxi - Boss altars", "Allow taxi to Bonemass altar item consumed", defaultValue: true, "Whether the configured item amount required to travel to the Bonemass altar is consumed.");
			offeringTaxiModerAltarEnabled = config("Offerings - Taxi - Boss altars", "Allow taxi to Moder altar", defaultValue: false, "Allow configured item offerings to call a taxi to the Moder altar.");
			offeringTaxiModerAltarItem = config("Offerings - Taxi - Boss altars", "Allow taxi to Moder altar item", "FreezeGland", "A prefab name of the item required to travel to the Moder altar. Example: FreezeGland.");
			offeringTaxiModerAltarAmount = config("Offerings - Taxi - Boss altars", "Allow taxi to Moder altar item amount", 50, "An amount of configured items required to travel to the Moder altar.");
			offeringTaxiModerAltarConsumeItem = config("Offerings - Taxi - Boss altars", "Allow taxi to Moder altar item consumed", defaultValue: true, "Whether the configured item amount required to travel to the Moder altar is consumed.");
			offeringTaxiYagluthAltarEnabled = config("Offerings - Taxi - Boss altars", "Allow taxi to Yagluth altar", defaultValue: false, "Allow configured item offerings to call a taxi to the Yagluth altar.");
			offeringTaxiYagluthAltarItem = config("Offerings - Taxi - Boss altars", "Allow taxi to Yagluth altar item", "GoblinTotem", "A prefab name of the item required to travel to the Yagluth altar. Example: GoblinTotem.");
			offeringTaxiYagluthAltarAmount = config("Offerings - Taxi - Boss altars", "Allow taxi to Yagluth altar item amount", 10, "An amount of configured items required to travel to the Yagluth altar.");
			offeringTaxiYagluthAltarConsumeItem = config("Offerings - Taxi - Boss altars", "Allow taxi to Yagluth altar item consumed", defaultValue: true, "Whether the configured item amount required to travel to the Yagluth altar is consumed.");
			offeringTaxiQueenAltarEnabled = config("Offerings - Taxi - Boss altars", "Allow taxi to Queen altar", defaultValue: false, "Allow configured item offerings to call a taxi to the Queen altar.");
			offeringTaxiQueenAltarItem = config("Offerings - Taxi - Boss altars", "Allow taxi to Queen altar item", "DvergrKey", "A prefab name of the item required to travel to the Queen altar. Example: DvergrKey.");
			offeringTaxiQueenAltarAmount = config("Offerings - Taxi - Boss altars", "Allow taxi to Queen altar item amount", 1, "An amount of configured items required to travel to the Queen altar.");
			offeringTaxiQueenAltarConsumeItem = config("Offerings - Taxi - Boss altars", "Allow taxi to Queen altar item consumed", defaultValue: true, "Whether the configured item amount required to travel to the Queen altar is consumed.");
			offeringTaxiFaderAltarEnabled = config("Offerings - Taxi - Boss altars", "Allow taxi to Fader altar", defaultValue: false, "Allow configured item offerings to call a taxi to the Fader altar.");
			offeringTaxiFaderAltarItem = config("Offerings - Taxi - Boss altars", "Allow taxi to Fader altar item", "Bell", "A prefab name of the item required to travel to the Fader altar. Example: Bell.");
			offeringTaxiFaderAltarAmount = config("Offerings - Taxi - Boss altars", "Allow taxi to Fader altar item amount", 1, "An amount of configured items required to travel to the Fader altar.");
			offeringTaxiFaderAltarConsumeItem = config("Offerings - Taxi - Boss altars", "Allow taxi to Fader altar item consumed", defaultValue: true, "Whether the configured item amount required to travel to the Fader altar is consumed.");
			wardPassiveRepair = config("Passive", "Activatable passive repair", defaultValue: true, "Interact with a ward to start passive repair process of all pieces in all connected areas\nWard will repair one piece every 10 seconds until all pieces are healthy. Then the process will stop.");
			wardPassiveRepairNonPlayer = config("Passive", "Passive repair non player structures", defaultValue: false, "If enabled - ward will repair structures from locations not initially placed by players. Like ruins, dverger outposts, infested mines and so on.");
			wardPassiveRepairRequireStation = config("Passive", "Passive repair requires crafting station", defaultValue: false, "If enabled - piece can be repaired only if there is corresponding crafting station near the ward.");
			autoCloseDoorsTime = config("Passive", "Auto close doors after", 0, "Automatically close doors after a specified number of seconds. 0 to disable. 5 recommended");
			autoCloseDoorsIgnorePrefabs = config("Passive", "Auto close doors ignore prefabs", "", "Comma-separated list of prefab names which should not be auto closed.");
			setWardRange = config("Range", "Change Ward range", defaultValue: false, "Default value for whether wards without per-ward range override should use a custom range. Each disabled ward can be configured separately from its settings window.");
			wardRange = config("Range", "Ward range", 32f, "Default ward range used for wards without per-ward range override. Each disabled ward can be configured separately from its settings window. Toggle ward protection for changes to take effect");
			supressSpawnInRange = config("Range", "Supress spawn in ward area", defaultValue: true, "Vanilla behavior is true. Set false if you want creatures and raids spawn in ward radius. Toggle ward protection for changes to take effect");
			wardBubbleShow = config("Ward Bubble", "Show bubble", defaultValue: false, "Default value for wards without per-ward bubble override. Each disabled ward can be configured separately from its settings window. Show ward bubble like trader's one [Not Synced with Server]", synchronizedSetting: false);
			wardBubbleColor = config<Color>("Ward Bubble", "Bubble color", Color.black, "Default bubble color for wards without per-ward bubble color override. Each disabled ward can be configured separately from its settings window. Toggle ward protection to change color [Not Synced with Server]", synchronizedSetting: false);
			wardBubbleRefractionIntensity = config("Ward Bubble", "Refraction intensity", 0.005f, "Intensity of light refraction caused by bubble. Toggle ward protection for changes to take effect [Not Synced with Server]", synchronizedSetting: false);
			wardBubbleWaveIntensity = config("Ward Bubble", "Wave intensity", 40f, "Bubble light distortion speed. Toggle ward protection for changes to take effect [Not Synced with Server]", synchronizedSetting: false);
			wardBubbleGlossiness = config("Ward Bubble", "Glossiness", 0f, "Bubble glossiness. 1 to soap bubble effect. Toggle ward protection for changes to take effect [Not Synced with Server]", synchronizedSetting: false);
			wardBubbleMetallic = config("Ward Bubble", "Metallic", 1f, "Toggle ward protection for changes to take effect [Not Synced with Server]", synchronizedSetting: false);
			wardBubbleNormalScale = config("Ward Bubble", "Normal scale", 15f, "Density of distortion effect. Toggle ward protection for changes to take effect [Not Synced with Server]", synchronizedSetting: false);
			wardBubbleDepthFade = config("Ward Bubble", "Depth fade", 1f, "Toggle ward protection for changes to take effect [Not Synced with Server]", synchronizedSetting: false);
			wardDemisterEnabled = config("Ward Demister", "Enable demister", defaultValue: false, "Ward will push out the mist");
			wardAreaMarkerPatch = config("Ward Circle", "Patch circle", defaultValue: false, "Default value for whether wards without per-ward circle override should use custom area marker parameters. Each disabled ward can be configured separately from its settings window. Toggle ward protection for changes to take effect [Not Synced with Server]", synchronizedSetting: false);
			wardAreaMarkerSpeed = config("Ward Circle", "Speed", 0.1f, "Speed of lines movement. Toggle ward protection for changes to take effect [Not Synced with Server]", synchronizedSetting: false);
			wardAreaMarkerStartColor = config<Color>("Ward Circle", "Color start", new Color(0.8f, 0.8f, 0.8f), "Starting color. Toggle ward protection for changes to take effect [Not Synced with Server]", synchronizedSetting: false);
			wardAreaMarkerEndColor = config<Color>("Ward Circle", "Color end", Color.clear, "End color (if set color of lines will change gradually). Toggle ward protection for changes to take effect [Not Synced with Server]", synchronizedSetting: false);
			wardAreaMarkerLength = config("Ward Circle", "Length multiplier", 1f, "Change area marker circle projector parameters. Toggle ward protection for changes to take effect [Not Synced with Server]", synchronizedSetting: false);
			wardAreaMarkerWidth = config("Ward Circle", "Width multiplier", 1f, "Change area marker circle projector parameters. Toggle ward protection for changes to take effect [Not Synced with Server]", synchronizedSetting: false);
			wardAreaMarkerAmount = config("Ward Circle", "Lines amount multiplier", 1f, "Change area marker circle projector parameters. Toggle ward protection for changes to take effect [Not Synced with Server]", synchronizedSetting: false);
			boarsHensProtection = config("Ward protects", "Boars and hens from damage", defaultValue: true, "Set whether an active Ward will protect nearby boars and hens from taken damage (players excluded)");
			wardRainProtection = config("Ward protects", "Structures from rain damage", defaultValue: true, "Set whether an active Ward will protect nearby structures from rain and water damage");
			wardShipProtection = config("Ward protects", "Ship from damage", ShipDamageType.WaterDamage, "Set whether an active Ward will protect nearby ships from damage (waves and upsidedown for water damage option or any structural damage)");
			wardPlantProtection = config("Ward protects", "Plants from any damage", defaultValue: true, "Set whether an active Ward will protect nearby plants from taking damage");
			fireplaceProtection = config("Ward protects", "Fireplace from step damage", defaultValue: true, "Set whether an active Ward will protect nearby fire sources from taking damage from stepping on them");
			wardTrapProtection = config("Ward protects", "Players from their traps", defaultValue: true, "Set whether an active Ward will protect players from stepping on traps");
			sittingRaidProtection = config("Ward protects", "Players from raids when sitting on something near the fire (not floor)", defaultValue: true, "Set whether an active Ward will protect nearby players from raids when sitting next to an active fire\nDo you want to go AFK in your base? Find a warm chair, bench, stool, throne whatever to sit on and go\nIf the fire does not burn - you are vulnerable");
			wardEmissionColorEnabled = config("Ward Color", "Change emission color", defaultValue: false, "Default value for whether wards without per-ward color override should use a custom emission color. Each disabled ward can be configured separately from its settings window. World restart required to apply changes. [Not Synced with Server]", synchronizedSetting: false);
			wardEmissionColor = config<Color>("Ward Color", "Color", new Color(0.967f, 0.508f, 0.092f), "Default ward emission color for wards without per-ward color override. Each disabled ward can be configured separately from its settings window. Toggle ward protection for changes to take effect [Not Synced with Server]", synchronizedSetting: false);
			wardEmissionColorMultiplier = config("Ward Color", "Color multiplier", 2f, "Default ward emission color multiplier for wards without per-ward color multiplier override. Each disabled ward can be configured separately from its settings window. Makes color more bright and intense. Toggle ward protection for changes to take effect [Not Synced with Server]", synchronizedSetting: false);
			wardLightColorEnabled = config("Ward Color", "Change flare and light accordingly", defaultValue: true, "Flare and emitted light color will fit ward color. Toggle ward protection for changes to take effect [Not Synced with Server]", synchronizedSetting: false);
			wardPlantProtectionList = config("Ward protects", "Plants from list", "Carrot, Turnip, Onion, CarrotSeeds, TurnipSeeds, OnionSeeds, MushroomJotunPuffs, MushroomMagecap", "List of plant prefab names to be protected from damage.");
			boarsHensProtectionGroupList = config("Ward protects", "Boars and hens from list", "boar, chicken", "List of tamed groups to be protected from damage");
			permitEveryone = config("Ward access", "Permit everyone", defaultValue: false, "Default access policy for wards without a per-ward Permit everyone override. When effective for a ward, every player passes that ward's access checks while its permitted list remains stored. A ward can override this value from its settings window when Ward settings mode is PerWard.");
			wardAccessProtectChests = config("Ward access from non-permitted players", "Chests", defaultValue: true, "Set whether an active Ward blocks non-permitted players from opening nearby chests and containers");
			wardAccessProtectDoors = config("Ward access from non-permitted players", "Doors", defaultValue: true, "Set whether an active Ward blocks non-permitted players from opening nearby doors");
			wardAccessProtectPlants = config("Ward access from non-permitted players", "Plant picking", defaultValue: true, "Set whether an active Ward blocks non-permitted players from picking nearby plants and pickables");
			wardAccessProtectBoats = config("Ward access from non-permitted players", "Boat mounting", defaultValue: true, "Set whether an active Ward blocks non-permitted players from mounting or controlling nearby boats");
			wardAccessProtectTames = config("Ward access from non-permitted players", "Tame mounting", defaultValue: true, "Set whether an active Ward blocks non-permitted players from mounting nearby tamed creatures");
			wardAccessProtectProductionStations = config("Ward access from non-permitted players", "Production stations", defaultValue: true, "Set whether an active Ward blocks non-permitted players from using nearby production stations such as smelters, kilns, ovens, cooking stations, fermenters, windmills, beehives and sap collectors.");
			wardAccessProtectItemStands = config("Ward access from non-permitted players", "Item stands", defaultValue: true, "Set whether an active Ward blocks non-permitted players from taking, placing, or changing items and equipment on nearby item stands and armor stands.");
			wardAccessProtectCarts = config("Ward access from non-permitted players", "Carts", defaultValue: true, "Set whether an active Ward blocks non-permitted players from dragging nearby carts and wagons.");
			wardAccessProtectPortals = config("Ward access from non-permitted players", "Portal access mode", WardPortalAccessMode.AllowTeleportOnly, "Controls how an active Ward protects nearby portals from non-permitted players.\nAllowAll: non-permitted players can use and rename portals as usual.\nAllowTeleportOnly: non-permitted players can teleport through portals but cannot rename/change portal tags.\nBlockAll: non-permitted players cannot teleport through or rename nearby portals.");
			wardAccessProtectFood = config("Ward access from non-permitted players", "Food and feasts", defaultValue: true, "Set whether an active Ward blocks non-permitted players from eating nearby feasts and placed consumable item pieces.");
			wardAccessProtectItemPickupMode = config("Ward access from non-permitted players", "Item pickup mode", WardItemPickupMode.AllowNonPlayerDropped, "Controls whether an active Ward blocks non-permitted players from picking up nearby non-consumable item drops.\nAllowAll: non-permitted players can pick up all non-consumable item drops.\nAllowNonPlayerDropped: non-permitted players can pick up normal loot/world drops, but not items dropped by players.\nBlockAll: non-permitted players cannot pick up any non-consumable item drops inside protected ward areas.");
			wardAccessProtectMapTables = config("Ward access from non-permitted players", "Map tables", defaultValue: true, "Set whether an active Ward blocks non-permitted players from reading from or writing to nearby map tables.");
			wardAccessProtectFireplaces = config("Ward access from non-permitted players", "Fireplaces", defaultValue: false, "Set whether an active Ward blocks non-permitted players from interacting with nearby fireplaces. Disabled by default so visitors can add fuel to fires.");
			wardAccessProtectShieldGenerators = config("Ward access from non-permitted players", "Shield generator fuel", defaultValue: true, "Set whether an active Ward blocks non-permitted players from adding fuel to nearby shield generators.");
			wardAccessProtectIncinerators = config("Ward access from non-permitted players", "Incinerator lever", defaultValue: true, "Set whether an active Ward blocks non-permitted players from pulling nearby obliterator/incinerator levers.");
			wardAccessProtectTurrets = config("Ward access from non-permitted players", "Turrets", defaultValue: true, "Set whether an active Ward blocks non-permitted players from interacting with nearby turrets, including changing targets or adding ammo.");
			wardAccessProtectCraftingStations = config("Ward access from non-permitted players", "Crafting stations", defaultValue: true, "Set whether an active Ward blocks non-permitted players from using or discovering nearby crafting stations.");
			wardAccessProtectBeds = config("Ward access from non-permitted players", "Beds", defaultValue: true, "Set whether an active Ward blocks non-permitted players from sleeping in nearby beds, even if another mod allows it.");
			wardAccessProtectCatapults = config("Ward access from non-permitted players", "Catapults", defaultValue: true, "Set whether an active Ward blocks non-permitted players from using nearby catapults.");
			wardAccessProtectArcheryTargets = config("Ward access from non-permitted players", "Archery target", defaultValue: true, "Set whether an active Ward blocks non-permitted players from interacting with nearby archery targets.");
			wardAccessProtectBarbers = config("Ward access from non-permitted players", "Barber station", defaultValue: true, "Set whether an active Ward blocks non-permitted players from using nearby barber stations.");
			wardAccessProtectInactiveWards = config("Ward access from non-permitted players", "Inactive ward inside another ward", defaultValue: true, "Set whether an active Ward blocks non-permitted players from interacting with nearby inactive wards inside its protected area.");
			wardAccessConnectedAccessMode = config("Ward access from non-permitted players", "Connected ward access mode", WardConnectedAccessMode.Off, "Controls whether overlapping active player wards can share access for protected interactions.\nOff: only direct access to the ward covering the object is accepted.\nSameCreatorOnly: access may be shared only between overlapping wards created by the same player.\nMutualTrust: access may be shared only between overlapping wards whose creators are mutually trusted/permitted by the protected/root ward, not by transitive chain trust.\nAnyConnected: access to any overlapping ward can grant access to the whole connected group. Intended for single-party servers where all players share one ward network.");
			wardAccessProtectInteractables = config("Ward access from non-permitted players", "Generic interactables", defaultValue: false, "Set whether an active Ward blocks non-permitted players from using generic nearby interactable objects. This is a broad compatibility layer for vanilla and modded interactables. Ownership-sensitive objects and special cases are excluded or handled separately.");
			wardBackgroundTamesPreventDamageToStructures = config("Ward without permitted players nearby", "Tames prevent damage to structures", defaultValue: true, "Set whether tamed creatures inside a protected ward network prevent their own damage to player-built structures when no permitted/effective-access player is nearby.");
			wardBackgroundPresenceRadius = config("Ward without permitted players nearby", "Permitted player presence radius", 64f, "Horizontal radius used to detect a permitted/effective-access player for background protection checks.");
			wardBackgroundPresenceMode = config("Ward without permitted players nearby", "Permitted player presence mode", WardBackgroundPresenceMode.PermittedNearProtectedArea, "Controls how player presence disables background protection.\nPermittedNearProtectedArea: a permitted/effective player must be near the protected object.\nPermittedInsideConnectedArea: a permitted/effective player anywhere inside the connected ward network disables background protection.\nPermittedOnline: any permitted/effective online player disables background protection.");
			wardBackgroundConnectedAccessMode = config("Ward without permitted players nearby", "Connected ward access mode", WardConnectedAccessMode.Off, "Controls which overlapping wards are treated as one protected network for background protection.");
			wardBackgroundProtectedBaseMinPieces = config("Ward without permitted players nearby", "Protected base minimum player pieces", 80, "Minimum number of player-built pieces inside the connected ward network required for broad background protection. 0 disables this qualification check.");
			wardBackgroundStructureProtection = config("Ward without permitted players nearby", "Background protection mode", WardBackgroundStructureProtectionMode.BlockNonPermittedPlayerDamage, "Off: no broad structure background protection.\nBlockNonPermittedPlayerDamage: blocks direct damage from non-permitted players.\nBlockAllDamageWhenNoPermittedNearby: blocks all damage to player-built structures while no permitted/effective player is nearby.");
			wardBackgroundProtectFire = config("Ward without permitted players nearby", "Prevent structure fire damage", defaultValue: true, "Blocks fire/burning damage to player-built structures in a protected ward network while no permitted/effective player is nearby.");
			wardBackgroundProtectTames = config("Ward without permitted players nearby", "Protect tames", defaultValue: true, "Blocks damage to tamed creatures inside a protected ward network while no permitted/effective player is nearby.");
			wardBackgroundProtectBoats = config("Ward without permitted players nearby", "Protect boats", defaultValue: true, "Blocks damage to boats inside a protected ward network while no permitted/effective player is nearby.");
			wardBackgroundProtectCarts = config("Ward without permitted players nearby", "Protect carts", defaultValue: true, "Blocks damage to carts/wagons inside a protected ward network while no permitted/effective player is nearby.");
			wardBackgroundTamePacify = config("Ward without permitted players nearby", "Tame pacify", WardBackgroundTamePacifyMode.WhenNoPermittedNearby, "When enabled, tamed creatures inside a protected ward network drop creature/static targets and do not acquire new combat targets while no permitted/effective player is nearby.");
			wardBackgroundPreventBuildingAndDemolishing = config("Ward without permitted players nearby", "Prevent building and demolishing", defaultValue: true, "Blocks non-permitted players from placing new pieces or demolishing other players' pieces inside a protected ward network while no permitted/effective player is nearby. Players can always demolish their own pieces.");
			wardAdminAccess = config("Ward admin", "Ward admin access", WardAdminAccessMode.AdminsInGodMode, "Controls global admin bypass behavior used by ward settings, permit command bypass, admin-only expiration commands, and admin-only expiration hover details. Per-ward Permit everyone access is evaluated separately.\nOff: admins do not bypass ward access checks.\nAdmins: server admins and host bypass ward access checks.\nAdminsInGodMode: server admins and host bypass ward access checks only while god mode is enabled.");
			wardExternalControlCommandsEnabled = config("Ward admin", "Enable external ward control commands", defaultValue: true, "Enables external ward management console commands and aliases for changing nearby wards, including permitted-list, enabled-state, and expiration-state commands.");
			wardExternalControlCommandRange = config("Ward admin", "External ward control command range", 5f, "Maximum horizontal distance from the player to the ward used by external ward management commands.");
			wardBuildLimitPerPlayer = config("Ward admin", "Ward build limit per player", 0, "Maximum number of wards each player can have in the world. 0 disables the limit. Existing wards are never removed; if the limit is exceeded after building a new ward, only the newly built ward is destroyed.");
			wardPasswordFieldMode = config("Ward password protection", "Password field mode", WardPasswordFieldMode.SetNewPasswordOnly, "Controls how passwords are edited in the per-ward settings UI. Ignored when Ward settings mode is ServerControlled.\nSetNewPasswordOnly: the current password is never shown. A new password is applied only with the dedicated Set new password button. Passwords are stored as a salted hash.\nEditablePassword: the current password is shown and saved together with the other ward settings. This mode also stores the readable password in the ward ZDO.");
			wardPasswordChangeAccess = config("Ward password protection", "Password change access", WardPasswordChangeAccess.CreatorOnly, "Controls who may change a ward password. Ward admins and players covered by the ward's effective Permit everyone value may always change it. Ignored when Ward settings mode is ServerControlled.\nCreatorOnly: only the ward creator may change it.\nCreatorAndPermitted: the creator and players with direct permitted-equivalent access, including bound guild members, may change it.");
			wardExpirationMinutes = config("Ward expiration", "Expiration minutes", 0, "0 disables inactive ward expiration. This is a multiplayer/server-side abandonment mechanic and is ignored in singleplayer. It is skipped for wards whose effective Permit everyone value is enabled. When greater than 0, the server periodically checks tracked ward ZDOs while player character ZDOs are online. A ward expires after this many real-time minutes without nearby activity from a player who can refresh it. Old wards are initialized with the current server time, so enabling this option does not expire existing wards immediately.");
			wardExpirationRefreshMode = config("Ward expiration", "Expiration refresh mode", WardExpirationRefreshMode.EffectiveAccess, "Controls which nearby players can refresh the inactive ward timer and reactivate expired wards. The player must be within the ward's current radius. DirectPermitted accepts the ward creator, directly permitted players, bound guild members, and the effective admin or Permit everyone bypass. EffectiveAccess also accepts access through overlapping connected wards according to Expiration connected access mode.");
			wardExpirationConnectedAccessMode = config("Ward expiration", "Expiration connected access mode", WardConnectedAccessMode.Off, "Controls connected ward access only for expiration refresh and reactivation when Expiration refresh mode is EffectiveAccess. Off requires direct access to this ward. SameCreatorOnly, MutualTrust, and AnyConnected can let an overlapping active connected ward keep this ward alive or reactivate it. Expired wards are not treated as active connected access sources for this check.");
			wardExpirationReactivationMode = config("Ward expiration", "Expiration reactivation mode", WardExpirationReactivationMode.ManualInteraction, "Controls how expired wards become active again. ManualInteraction keeps expired wards inactive until a player with refresh access interacts with the ward. AutomaticOnLogin reactivates an expired ward when a player with refresh access is nearby during a server check, or when an expired loaded ward wakes up near such a player. Reactivation also refreshes the last-active timestamp.");
			wardExpirationAdminHover = config("Ward expiration", "Show expiration admin hover details", defaultValue: false, "Shows additional expiration debug details in ward hover text for players allowed by Ward admin access. The extra lines are intended for server administration and include raw Unix timestamps and the last player recorded as refreshing or reactivating the ward.", synchronizedSetting: false);
			wardExpirationMinutes.SettingChanged += delegate
			{
				WardExpiration.ResetNextCheckTime();
			};
			wardSettingsMode.SettingChanged += delegate
			{
				areaCache.Clear();
				WardSettingsUI.HandleSettingsModeChanged();
				WardPasswordProtection.HandleSettingsModeChanged();
				RefreshAllLoadedWardVisuals();
			};
			wardAreaShape.SettingChanged += delegate
			{
				areaCache.Clear();
			};
			wardProtectDungeonInteriors.SettingChanged += delegate
			{
				areaCache.Clear();
			};
			wardPasswordFieldMode.SettingChanged += delegate
			{
				WardPasswordProtection.HandlePasswordFieldModeChanged();
			};
			wardPlantProtectionList.SettingChanged += delegate
			{
				FillWardProtectionLists();
			};
			boarsHensProtectionGroupList.SettingChanged += delegate
			{
				FillWardProtectionLists();
			};
			FillWardProtectionLists();
		}

		private ConfigEntry<T> config<T>(string group, string name, T defaultValue, ConfigDescription description, bool synchronizedSetting = true)
		{
			return ((BaseUnityPlugin)this).Config.Bind<T>(group, name, defaultValue, WithJotunnSync(description, synchronizedSetting));
		}

		private ConfigEntry<T> config<T>(string group, string name, T defaultValue, string description, bool synchronizedSetting = true)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Expected O, but got Unknown
			return config(group, name, defaultValue, new ConfigDescription(description, (AcceptableValueBase)null, Array.Empty<object>()), synchronizedSetting);
		}

		private static ConfigDescription WithJotunnSync(ConfigDescription description, bool synchronizedSetting)
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Expected O, but got Unknown
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Expected O, but got Unknown
			if (!synchronizedSetting)
			{
				return description;
			}
			List<object> list = description.Tags?.ToList() ?? new List<object>();
			list.Add((object)new ConfigurationManagerAttributes
			{
				IsAdminOnly = true
			});
			return new ConfigDescription(description.Description, description.AcceptableValues, list.ToArray());
		}

		internal static void UpdateCache()
		{
			DateTime time = ZNet.instance.GetTime();
			if (startTimeCached == 0)
			{
				startTimeCached = time.Ticks;
			}
			if ((time - new DateTime(startTimeCached)).TotalSeconds > (double)refreshingTime.Value)
			{
				areaCache.Clear();
				startTimeCached = time.Ticks;
			}
		}

		public static bool InsideEnabledPlayersArea(Vector3 point, bool checkCache = false)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			PrivateArea area;
			return InsideEnabledPlayersArea(point, out area, checkCache);
		}

		public static bool InsideEnabledPlayersArea(Vector3 point, out PrivateArea area, bool checkCache = false)
		{
			//IL_0004: 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_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: 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_0105: 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)
			area = null;
			if (!TryResolveWardCheckPoint(point, out var resolvedPoint))
			{
				return false;
			}
			if (checkCache)
			{
				UpdateCache();
				if (areaCache.TryGetValue(resolvedPoint, out area))
				{
					if (Object.op_Implicit((Object)(object)area) && ((Behaviour)area).isActiveAndEnabled && area.IsEnabled())
					{
						return true;
					}
					areaCache.Remove(resolvedPoint);
				}
			}
			foreach (PrivateArea allArea in PrivateArea.m_allAreas)
			{
				if (allArea.IsEnabled() && (int)allArea.m_ownerFaction == 0 && IsWorldPointInsideWardArea(((Component)allArea).transform.position, allArea.m_radius, resolvedPoint))
				{
					area = allArea;
					if (checkCache)
					{
						areaCache.Add(resolvedPoint, area);
					}
					return true;
				}
			}
			if (checkCache)
			{
				areaCache.Add(resolvedPoint, area);
			}
			return false;
		}

		public static bool IsActivePlayerWard(PrivateArea ward)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Invalid comparison between Unknown and I4
			return (Object)(object)ward != (Object)null && ward.IsEnabled() && (int)ward.m_ownerFaction == 0;
		}

		private static bool IsPlayerWardPrefab(PrivateArea ward)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			return (Object)(object)ward != (Object)null && (int)ward.m_ownerFaction == 0 && WardZdoUtils.IsWardPrefab(((Component)ward).gameObject);
		}

		private static bool AreWardsOverlapping(PrivateArea ward, PrivateArea candidate)
		{
			//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)
			return (Object)(object)ward != (Object)null && (Object)(object)candidate != (Object)null && GetConfiguredWardDistance(((Component)ward).transform.position, ((Component)candidate).transform.position) <= ward.m_radius + candidate.m_radius;
		}

		internal static bool TryResolveWardCheckPoint(Vector3 point, out Vector3 resolvedPoint)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: 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_0063: Unknown result type (might be due to invalid IL or missing references)
			resolvedPoint = point;
			if (!Character.InInterior(point))
			{
				return true;
			}
			ConfigEntry<bool> obj = wardProtectDungeonInteriors;
			if (obj == null || !obj.Value)
			{
				return false;
			}
			Location location = Location.GetLocation(point, true);
			Teleport val = FindDungeonEntranceTeleport(location);
			if ((Object)(object)val == (Object)null)
			{
				return false;
			}
			resolvedPoint = ((Component)val).transform.position;
			return true;
		}

		private static Teleport FindDungeonEntranceTeleport(Location location)
		{
			if ((Object)(object)location == (Object)null || !location.m_hasInterior)
			{
				return null;
			}
			if (dungeonEntranceCache.TryGetValue(location, out var value))
			{
				if ((Object)(object)value != (Object)null)
				{
					return value;
				}
				dungeonEntranceCache.Remove(location);
			}
			Transform transform = ((Component)location).transform;
			Transform interiorTransform = location.m_interiorTransform;
			Transform root = transform.Find("Gateway");
			Teleport val = FindTeleportInHierarchy(root);
			if ((Object)(object)val != (Object)null)
			{
				return CacheDungeonEntrance(location, val);
			}
			for (int i = 0; i < transform.childCount; i++)
			{
				Transform child = transform.GetChild(i);
				if (!((Object)(object)child == (Object)(object)interiorTransform))
				{
					val = FindTeleportInHierarchy(child, interiorTransform);
					if ((Object)(object)val != (Object)null)
					{
						return CacheDungeonEntrance(location, val);
					}
				}
			}
			return null;
		}

		private static Teleport FindTeleportInHierarchy(Transform root, Transform excludedRoot = null)
		{
			if ((Object)(object)root == (Object)null || (Object)(object)root == (Object)(object)excludedRoot)
			{
				return null;
			}
			Teleport component = ((Component)root).GetComponent<Teleport>();
			if ((Object)(object)component != (Object)null)
			{
				return component;
			}
			for (int i = 0; i < root.childCount; i++)
			{
				component = FindTeleportInHierarchy(root.GetChild(i), excludedRoot);
				if ((Object)(object)component != (Object)null)
				{
					return component;
				}
			}
			return null;
		}

		private static Teleport CacheDungeonEntrance(Location location, Teleport entrance)
		{
			dungeonEntranceCache[location] = entrance;
			return entrance;
		}

		internal static float GetConfiguredWardDistance(Vector3 firstPoint, Vector3 secondPoint)
		{
			//IL_0020: 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_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)
			WardAreaShape wardAreaShape = ProtectiveWards.wardAreaShape?.Value ?? WardAreaShape.Cylinder;
			return (wardAreaShape == WardAreaShape.Sphere) ? Vector3.Distance(firstPoint, secondPoint) : Utils.DistanceXZ(firstPoint, secondPoint);
		}

		internal static bool IsWorldPointInsideWardArea(Vector3 wardPosition, float wardRadius, Vector3 point, float radius = 0f)
		{
			//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)
			float num = wardRadius + radius;
			return num > 0f && GetConfiguredWardDistance(wardPosition, point) < num;
		}

		public static bool IsPointInsideWardArea(PrivateArea ward, Vector3 point, float radius = 0f)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)ward == (Object)null || !TryResolveWardCheckPoint(point, out var resolvedPoint))
			{
				return false;
			}
			return IsWorldPointInsideWardArea(((Component)ward).transform.position, ward.m_radius, resolvedPoint, radius);
		}

		public static bool IsPointInsideWardArea(ZDO ward, Vector3 point, float radius = 0f)
		{
			//IL_0004: 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)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			if (ward == null || !TryResolveWardCheckPoint(point, out var resolvedPoint))
			{
				return false;
			}
			return IsWorldPointInsideWardArea(ward.GetPosition(), ward.GetWardRadius(), resolvedPoint, radius);
		}

		public static bool IsInsideWardXZ(PrivateArea ward, Vector3 point, float radius = 0f)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			return (Object)(object)ward != (Object)null && Utils.DistanceXZ(((Component)ward).transform.position, point) <= ward.m_radius + radius;
		}

		public static bool IsInsideWardXZ(ZDO ward, Vector3 point, float radius = 0f)
		{
			//IL_0009: 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 WardZdoUtils.IsWard(ward) && Utils.DistanceXZ(ward.GetPosition(), point) <= ward.GetWardRadius() + radius;
		}

		public static bool ArePerWardSettingsEnabled()
		{
			return wardSettingsMode == null || wardSettingsMode.Value == WardSettingsMode.PerWard;
		}

		public static bool IsPermitEveryone(PrivateArea ward)
		{
			if (ward != null)
			{
				ZNetView nview = ward.m_nview;
				if (((nview != null) ? new bool?(nview.IsValid()) : ((bool?)null)) == true)
				{
					return IsPermitEveryone(ward.m_nview.GetZDO());
				}
			}
			return permitEveryone?.Value ?? false;
		}

		public static bool IsPermitEveryone(ZDO zdo)
		{
			bool flag = permitEveryone?.Value ?? false;
			if (!ArePerWardSettingsEnabled())
			{
				return flag;
			}
			return (zdo != null) ? zdo.GetBool(s_permitEveryone, flag) : flag;
		}

		private static void ReplaceWardPermittedHoverStatus(PrivateArea ward, StringBuilder text)
		{
			if ((Object)(object)ward == (Object)null || text == null)
			{
				return;
			}
			string text2 = text.ToString();
			int num = FindWardPermittedHoverStart(text2);
			if (num >= 0)
			{
				int num2 = text2.IndexOf('\n', num);
				if (num2 < 0)
				{
					num2 = text2.Length;
				}
				text.Remove(num, num2 - num);
				text.Insert(num, BuildWardPermittedHoverStatus(ward));
			}
		}

		private static int FindWardPermittedHoverStart(string hoverText)
		{
			string[] array = new string[2] { "$piece_guardstone_additional", "$piece_guardstone_permitted" };
			string[] array2 = array;
			foreach (string text in array2)
			{
				int num = hoverText.LastIndexOf(text, StringComparison.Ordinal);
				if (num >= 0)
				{
					return num;
				}
				string value = text.Localize();
				if (!string.IsNullOrEmpty(value))
				{
					num = hoverText.LastIndexOf(value, StringComparison.Ordinal);
					if (num >= 0)
					{
						return num;
					}
				}
			}
			return -1;
		}

		private static string BuildWardPermittedHoverStatus(PrivateArea ward)
		{
			string text = "$pw_ward_hover_permitted".Localize();
			if (IsPermitEveryone(ward))
			{
				string text2 = "$pw_ward_hover_everyone".Localize();
				return text + " " + text2 + ".";
			}
			List<string> list = new List<string>();
			List<string> list2 = (from player in ward.GetPermittedPlayers()
				select CensorShittyWords.FilterUGC(player.Value, (UGCType)2, ward.m_piece.GetCreator()) into name
				where !string.IsNullOrWhiteSpace(name)
				select name).ToList();
			string text3 = string.Join(", ", list2.ToArray());
			if (text3.Length > 30)
			{
				string text4 = ((list2.Count == 1) ? "$pw_ward_hover_player" : "$pw_ward_hover_players");
				list.Add(text4.Localize(list2.Count.ToString()));
			}
			else if (text3.Length > 0)
			{
				list.Add(text3);
			}
			ZNetView nview = ward.m_nview;
			ZDO zdo = ((nview != null && nview.IsValid()) ? ward.m_nview.GetZDO() : null);
			if (GuildsCompat.IsEnabled && GuildsCompat.IsGuildAccessEnabled(zdo))
			{
				list.Add("$pw_ward_hover_guild_access".Localize());
			}
			if (WardPasswordProtection.IsPasswordProtectionActive(zdo))
			{
				list.Add("$pw_ward_hover_password_access".Localize());
			}
			if (list.Count == 0)
			{
				list.Add("$pw_ward_hover_none".Localize());
			}
			return text + " " + string.Join(", ", list.ToArray()) + ".";
		}

		public static bool HasWardManagementAccess(PrivateArea ward, long playerID)
		{
			return playerID != 0L && (HasWardAdminAccess(playerID) || IsPermitEveryone(ward));
		}

		public static bool HasWardManagementAccess(ZDO zdo, long playerID)
		{
			return playerID != 0L && (HasWardAdminAccess(playerID) || IsPermitEveryone(zdo));
		}

		public static bool HasDirectAccessToWard(PrivateArea ward, Player player)
		{
			if ((Object)(object)ward == (Object)null || (Object)(object)player == (Object)null)
			{
				return true;
			}
			return HasDirectAccessToWard(ward, player.GetPlayerID());
		}

		public static bool HasDirectAccessToWard(PrivateArea ward, long playerID)
		{
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Invalid comparison between Unknown and I4
			if ((Object)(object)ward == (Object)null)
			{
				return true;
			}
			if (playerID == 0)
			{
				return false;
			}
			if ((int)ward.m_ownerFaction > 0)
			{
				return false;
			}
			if (HasWardManagementAccess(ward, playerID))
			{
				return true;
			}
			if ((Object)(object)ward.m_piece != (Object)null && ward.m_piece.GetCreator() == playerID)
			{
				return true;
			}
			if (ward.GetPermittedPlayers().Any((KeyValuePair<long, string> entry) => entry.Key == playerID))
			{
				return true;
			}
			return GuildsCompat.HasWardGuildAccess(ward, playerID);
		}

		public static bool HasAccessToWard(PrivateArea ward, Player player)
		{
			return HasDirectAccessToWard(ward, player);
		}

		private static long GetCreatorId(PrivateArea ward)
		{
			return ((Object)(object)ward?.m_piece != (Object)null) ? ward.m_piece.GetCreator() : 0;
		}

		public static bool CanShareConnectedAccess(PrivateArea protectedWard, PrivateArea candidateWard, WardConnectedAccessMode mode)
		{
			if (mode == WardConnectedAccessMode.Off)
			{
				return false;
			}
			if (!IsActivePlayerWard(protectedWard) || !IsActivePlayerWard(candidateWard))
			{
				return false;
			}
			if ((Object)(object)protectedWard == (Object)(object)candidateWard)
			{
				return true;
			}
			switch (mode)
			{
			case WardConnectedAccessMode.SameCreatorOnly:
			{
				long creatorId = GetCreatorId(protectedWard);
				long creatorId2 = GetCreatorId(candidateWard);
				return creatorId != 0L && creatorId == creatorId2;
			}
			case WardConnectedAccessMode.MutualTrust:
			{
				long creatorId = GetCreatorId(protectedWard);
				long creatorId2 = GetCreatorId(candidateWard);
				return creatorId != 0L && creatorId2 != 0L && HasDirectAccessToWard(protectedWard, creatorId2) && HasDirectAccessToWard(candidateWard, creatorId);
			}
			case WardConnectedAccessMode.AnyConnected:
				return true;
			default:
				return false;
			}
		}

		public static IEnumerable<PrivateArea> ConnectedAccessAreas(PrivateArea ward, WardConnectedAccessMode mode)
		{
			if (!IsActivePlayerWard(ward))
			{
				yield break;
			}
			HashSet<PrivateArea> visited = new HashSet<PrivateArea>();
			List<PrivateArea> queue = new List<PrivateArea>();
			int queueIndex = 0;
			visited.Add(ward);
			queue.Add(ward);
			while (queueIndex < queue.Count)
			{
				PrivateArea current = queue[queueIndex++];
				yield return current;
				if (mode == WardConnectedAccessMode.Off)
				{
					continue;
				}
				foreach (PrivateArea candidate in PrivateArea.m_allAreas)
				{
					if (!visited.Contains(candidate) && IsActivePlayerWard(candidate) && AreWardsOverlapping(current, candidate) && CanShareConnectedAccess(ward, candidate, mode))
					{
						visited.Add(candidate);
						queue.Add(candidate);
					}
				}
			}
		}

		public static bool HasAccessToWardOrConnectedWard(PrivateArea ward, Player player)
		{
			if (wardAccessConnectedAccessMode == null)
			{
				return HasDirectAccessToWard(ward, player);
			}
			return HasAccessToWardOrConnectedWard(ward, player, wardAccessConnectedAccessMode.Value);
		}

		public static bool HasAccessToWardOrConnectedWard(PrivateArea ward, Player player, WardConnectedAccessMode mode)
		{
			if ((Object)(object)ward == (Object)null || (Object)(object)player == (Object)null)
			{
				return true;
			}
			return HasAccessToWardOrConnectedWard(ward, player.GetPlayerID(), mode);
		}

		public static bool HasAccessToWardOrConnectedWard(PrivateArea ward, long playerID, WardConnectedAccessMode mode)
		{
			if (HasDirectAccessToWard(ward, playerID))
			{
				return true;
			}
			if (mode == WardConnectedAccessMode.Off)
			{
				return false;
			}
			return ConnectedAccessAreas(ward, mode).Any((PrivateArea area) => (Object)(object)area != (Object)(object)ward && HasDirectAccessToWard(area, playerID));
		}

		public static PrivateArea FindProtectedWard(Vector3 point)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			foreach (PrivateArea allArea in PrivateArea.m_allAreas)
			{
				if (IsActivePlayerWard(allArea) && IsPointInsideWardArea(allArea, point))
				{
					return allArea;
				}
			}
			return null;
		}

		public static bool IsPointInsideWardNetwork(Vector3 point, PrivateArea ward, WardConnectedAccessMode mode)
		{
			//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)
			return ConnectedAccessAreas(ward, mode).Any((PrivateArea area) => IsPointInsideWardArea(area, point));
		}

		public static bool IsPointInsideWardNetworkXZ(Vector3 point, PrivateArea ward, WardConnectedAccessMode mode)
		{
			//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)
			return ConnectedAccessAreas(ward, mode).Any((PrivateArea area) => IsInsideWardXZ(area, point));
		}

		public static bool TryFindProtectedWardNetwork(Vector3 sourcePoint, Vector3 targetPoint, out PrivateArea ward)
		{
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			ward = null;
			WardConnectedAccessMode mode = ((wardAccessConnectedAccessMode != null) ? wardAccessConnectedAccessMode.Value : WardConnectedAccessMode.Off);
			foreach (PrivateArea allArea in PrivateArea.m_allAreas)
			{
				if (!IsActivePlayerWard(allArea) || !IsPointInsideWardArea(allArea, sourcePoint) || !IsPointInsideWardNetwork(targetPoint, allArea, mode))
				{
					continue;
				}
				ward = allArea;
				return true;
			}
			return false;
		}

		public static bool TryFindProtectedWardNetworkXZ(Vector3 sourcePoint, Vector3 targetPoint, out PrivateArea ward)
		{
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			ward = null;
			WardConnectedAccessMode mode = ((wardAccessConnectedAccessMode != null) ? wardAccessConnectedAccessMode.Value : WardConnectedAccessMode.Off);
			foreach (PrivateArea allArea in PrivateArea.m_allAreas)
			{
				if (!IsActivePlayerWard(allArea) || !IsInsideWardXZ(allArea, sourcePoint) || !IsPointInsideWardNetworkXZ(targetPoint, allArea, mode))
				{
					continue;
				}
				ward = allArea;
				return true;
			}
			return false;
		}

		public static bool TryGetObjectCreatorId(Component component, out long creatorId)
		{
			creatorId = 0L;
			if ((Object)(object)component == (Object)null)
			{
				return false;
			}
			TombStone componentInParent = component.GetComponentInParent<TombStone>();
			if ((Object)(object)componentInParent != (Object)null)
			{
				creatorId = componentInParent.GetOwner();
			}
			if (creatorId == 0)
			{
				Bed componentInParent2 = component.GetComponentInParent<Bed>();
				if ((Object)(object)componentInParent2 != (Object)null)
				{
					creatorId = componentInParent2.GetOwner();
				}
			}
			if (creatorId == 0)
			{
				Tameable componentInParent3 = component.GetComponentInParent<Tameable>();
				if ((Object)(object)componentInParent3 != (Object)null && (Object)(object)componentInParent3.m_piece != (Object)null)
				{
					creatorId = componentInParent3.m_piece.GetCreator();
				}
			}
			if (creatorId == 0)
			{
				ShipControlls componentInParent4 = component.GetComponentInParent<ShipControlls>();
				Piece val = (((Object)(object)componentInParent4 != (Object)null && (Object)(object)componentInParent4.m_ship != (Object)null) ? ((Component)componentInParent4.m_ship).GetComponent<Piece>() : null);
				if ((Object)(object)val != (Object)null)
				{
					creatorId = val.GetCreator();
				}
			}
			if (creatorId == 0)
			{
				Piece componentInParent5 = component.GetComponentInParent<Piece>();
				if ((Object)(object)componentInParent5 != (Object)null)
				{
					creatorId = componentInParent5.GetCreator();
				}
			}
			if (creatorId == 0)
			{
				object obj;
				if (component == null)
				{
					obj = null;
				}
				else
				{
					ZNetView componentZNetView = component.GetComponentZNetView();
					obj = ((componentZNetView != null) ? componentZNetView.GetZDO() : null);
				}
				ZDO val2 = (ZDO)obj;
				if (val2 != null)
				{
					creatorId = val2.GetLong(ZDOVars.s_creator, 0L);
				}
			}
			return creatorId != 0;
		}

		public static bool TryGetObjectCreatorName(Component component, out string creatorName)
		{
			creatorName = "";
			if ((Object)(object)component == (Object)null)
			{
				return false;
			}
			TombStone componentInParent = component.GetComponentInParent<TombStone>();
			if ((Object)(object)componentInParent != (Object)null)
			{
				creatorName = componentInParent.GetOwnerName();
			}
			if (string.IsNullOrWhiteSpace(creatorName))
			{
				Bed componentInParent2 = component.GetComponentInParent<Bed>();
				if ((Object)(object)componentInParent2 != (Object)null)
				{
					creatorName = componentInParent2.GetOwnerName();
				}
			}
			if (string.IsNullOrWhiteSpace(creatorName))
			{
				PrivateArea componentInParent3 = component.GetComponentInParent<PrivateArea>();
				if ((Object)(object)componentInParent3 != (Object)null)
				{
					creatorName = componentInParent3.GetCreatorName();
				}
			}
			if (string.IsNullOrWhiteSpace(creatorName))
			{
				object obj;
				if (component == null)
				{
					obj = null;
				}
				else
				{
					ZNetView componentZNetView = component.GetComponentZNetView();
					obj = ((componentZNetView != null) ? componentZNetView.GetZDO() : null);
				}
				ZDO val = (ZDO)obj;
				if (val != null)
				{
					creatorName = val.GetString(ZDOVars.s_creatorName, "");
				}
			}
			if (string.IsNullOrWhiteSpace(creatorName) && TryGetObjectCreatorId(component, out var creatorId))
			{
				Player player = Player.GetPlayer(creatorId);
				if ((Object)(object)player != (Object)null)
				{
					creatorName = player.GetPlayerName();
				}
			}
			return !string.IsNullOrWhiteSpace(creatorName);
		}

		private static bool IsOwnershipSensitiveObject(Component component)
		{
			if ((Object)(object)component == (Object)null)
			{
				return false;
			}
			return (Object)(object)component.GetComponentInParent<Ship>() != (Object)null || (Object)(object)component.GetComponentInParent<ShipControlls>() != (Object)null || (Object)(object)component.GetComponentInParent<Vagon>() != (Object)null || (Object)(object)component.GetComponentInParent<TombStone>() != (Object)null || (Object)(object)component.GetComponentInParent<Ladder>() != (Object)null || (Object)(object)component.GetComponentInParent<TeleportWorld>() != (Object)null || (Object)(object)component.GetComponentInParent<ItemStand>() != (Object)null || (Object)(object)component.GetComponentInParent<ArmorStand>() != (Object)null || (Object)(object)component.GetComponentInParent<Sadle>() != (Object)null || (Object)(object)component.GetComponentInParent<Tameable>() != (Object)null || (Object)(object)component.GetComponentInParent<Pet>() != (Object)null || (Object)(object)component.GetComponentInParent<Petable>() != (Object)null;
		}

		public static bool IsObjectOwnedByPlayerWithWardAccess(Component component, Player interactingPlayer)
		{
			if (!IsOwnershipSensitiveObject(component) || (Object)(object)interactingPlayer == (Object)null)
			{
				return false;
			}
			if (WasPlayerLastSaddleUser(component, interactingPlayer))
			{
				return true;
			}
			if (IsVehicleControlObject(component))
			{
				return WasPlayerLastVehicleController(component, interactingPlayer);
			}
			if (!TryGetObjectCreatorId(component, out var creatorId))
			{
				return false;
			}
			return creatorId == interactingPlayer.GetPlayerID();
		}

		private static bool IsVehicleControlObject(Component component)
		{
			return (Object)(object)component != (Object)null && ((Object)(object)component.GetComponentInParent<Ship>() != (Object)null || (Object)(object)component.GetComponentInParent<ShipControlls>() != (Object)null || (Object)(object)component.GetComponentInParent<Vagon>() != (Object)null);
		}

		private static bool HasLastSaddleUser(ZNetView nview, long playerID)
		{
			ZDO val = (((Object)(object)nview != (Object)null && nview.IsValid()) ? nview.GetZDO() : null);
			return val != null && val.GetLong(s_lastSaddleUser, 0L) == playerID;
		}

		private static bool HasLastVehicleController(ZNetView nview, long playerID)
		{
			ZDO val = (((Object)(object)nview != (Object)null && nview.IsValid()) ? nview.GetZDO() : null);
			return val != null && val.GetLong(s_lastVehicleController, 0L) == playerID;
		}

		public static bool WasPlayerLastSaddleUser(Component component, Player player)
		{
			if ((Object)(object)component == (Object)null || (Object)(object)player == (Object)null)
			{
				return false;
			}
			long playerID = player.GetPlayerID();
			if (playerID == 0)
			{
				return false;
			}
			if (HasLastSaddleUser(component.GetComponentZNetView(), playerID))
			{
				return true;
			}
			Sadle val = component.GetComponentInParent<Sadle>() ?? component.GetComponentInChildren<Sadle>(true);
			if ((Object)(object)val == (Object)null)
			{
				return false;
			}
			if (HasLastSaddleUser(((Component)(object)val).GetComponentZNetView(), playerID))
			{
				return true;
			}
			if ((Object)(object)val.m_character != (Object)null && HasLastSaddleUser(((Component)(object)val.m_character).GetComponentZNetView(), playerID))
			{
				return true;
			}
			return false;
		}

		public static bool WasPlayerLastVehicleController(Component component, Player player)
		{
			if ((Object)(object)component == (Object)null || (Object)(object)player == (Object)null)
			{
				return false;
			}
			long playerID = player.GetPlayerID();
			if (playerID == 0)
			{
				return false;
			}
			ShipControlls componentInParent = component.GetComponentInParent<ShipControlls>();
			if ((Object)(object)componentInParent != (Object)null && (Object)(object)componentInParent.m_ship != (Object)null && HasLastVehicleController(((Component)(object)componentInParent.m_ship).GetComponentZNetView(), playerID))
			{
				return true;
			}
			Ship componentInParent2 = component.GetComponentInParent<Ship>();
			if ((Object)(object)componentInParent2 != (Object)null && HasLastVehicleController(((Component)(object)componentInParent2).GetComponentZNetView(), playerID))
			{
				return true;
			}
			Vagon componentInParent3 = component.GetComponentInParent<Vagon>();
			if ((Object)(object)componentInParent3 != (Object)null && HasLastVehicleController(((Component)(object)componentInParent3).GetComponentZNetView(), playerID))
			{
				return true;
			}
			return false;
		}

		public static bool ShouldBypassVanillaPrivateAreaCheck(Component component, Humanoid human)
		{
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)component == (Object)null)
			{
				return false;
			}
			Player val = (Player)(object)((human is Player) ? human : null);
			if ((Object)(object)val == (Object)null)
			{
				return false;
			}
			bool result = false;
			foreach (PrivateArea allArea in PrivateArea.m_allAreas)
			{
				if (!((Object)(object)allArea == (Object)null) && allArea.IsEnabled() && IsPointInsideWardArea(allArea, component.transform.position))
				{
					if (!IsActivePlayerWard(allArea))
					{
						return false;
					}
					result = true;
					if (!HasAccessToWardOrConnectedWard(allArea, val) && !IsObjectOwnedByPlayerWithWardAccess(component, val))
					{
						return false;
					}
				}
			}
			return result;
		}

		public static string GetWardOwnerName(PrivateArea ward)
		{
			string text = "";
			if ((Object)(object)ward != (Object)null)
			{
				text = ward.GetCreatorName();
			}
			return string.IsNullOrWhiteSpace(text) ? "Unknown" : text;
		}

		internal static string GetWardOwnerName(ZDO zdo)
		{
			if (zdo == null)
			{
				return "";
			}
			string text = zdo.GetString(ZDOVars.s_creatorName, "");
			long num = zdo.GetLong(ZDOVars.s_creator, 0L);
			return (!string.IsNullOrEmpty(text)) ? CensorShittyWords.FilterUGC(text, (UGCType)2, num) : ((num != 0L) ? num.ToString() : "");
		}

		public static string GetPrivateZoneDeniedMessage(PrivateArea ward)
		{
			return GetPrivateZoneDeniedMessage(GetWardOwnerName(ward));
		}

		public static string GetPrivateZoneDeniedMessage(string ownerName)
		{
			return "$msg_privatezone".Localize() + ". " + "$piece_guardstone_owner".Localize() + ": " + ownerName;
		}

		public static bool HasEffectiveAccessPlayerNearby(PrivateArea ward, Vector3 point, float radius)
		{
			//IL_0033: 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)
			WardConnectedAccessMode mode = ((wardAccessConnectedAccessMode != null) ? wardAccessConnectedAccessMode.Value : WardConnectedAccessMode.Off);
			foreach (Player allPlayer in Player.GetAllPlayers())
			{
				if (Utils.DistanceXZ(((Component)allPlayer).transform.position, point) > radius || !HasAccessToWardOrConnectedWard(ward, allPlayer, mode))
				{
					continue;
				}
				return true;
			}
			return false;
		}

		public static bool ShouldBlockUnauthorizedWardInteraction(Vector3 point, Humanoid human, bool flash, out PrivateArea ward)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			return ShouldBlockUnauthorizedWardInteraction(point, human, flash, out ward, null);
		}

		public static bool ShouldBlockUnauthorizedWardInteraction(Component component, Humanoid human, bool flash, out PrivateArea ward)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			ward = null;
			if ((Object)(object)component == (Object)null)
			{
				return false;
			}
			return ShouldBlockUnauthorizedWardInteraction(component.transform.position, human, flash, out ward, component);
		}

		public static bool BlockUnauthorizedWardInteraction(Vector3 point, Humanoid human, bool flash = true)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			PrivateArea ward;
			return ShouldBlockUnauthorizedWardInteraction(point, human, flash, out ward);
		}

		public static bool BlockUnauthorizedWardInteraction(Component component, Humanoid human, bool flash = true)
		{
			PrivateArea ward;
			return ShouldBlockUnauthorizedWardInteraction(component, human, flash, out ward);
		}

		private static bool ShouldBlockUnauthorizedWardInteraction(Vector3 point, Humanoid human, bool flash, out PrivateArea ward, Component component)
		{
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			ward = null;
			Player val = (Player)(object)((human is Player) ? human : null);
			if ((Object)(object)val == (Object)null)
			{
				return false;
			}
			foreach (PrivateArea allArea in PrivateArea.m_allAreas)
			{
				if (!IsActivePlayerWard(allArea) || !IsPointInsideWardArea(allArea, point) || HasAccessToWardOrConnectedWard(allArea, val) || ((Object)(object)component != (Object)null && IsObjectOwnedByPlayerWithWardAccess(component, val)))
				{
					continue;
				}
				if (flash)
				{
					allArea.FlashShield(false);
				}
				ward = allArea;
				((Character)val).Message((MessageType)2, GetPrivateZoneDeniedMessage(allArea), 0, (Sprite)null);
				return true;
			}
			return false;
		}

		private static bool IsDisabledForeignWard(PrivateArea ward, long playerID)
		{
			if ((Object)(object)ward == (Object)null || ward.IsEnabled() || playerID == 0L || (Object)(object)ward.m_piece == (Object)null)
			{
				return false;
			}
			return ward.m_piece.GetCreator() != playerID;
		}

		private static bool IsDisabledForeignWard(ZDO zdo, long playerID)
		{
			if (zdo == null || playerID == 0L || zdo.GetBool(ZDOVars.s_enabled, false))
			{
				return false;
			}
			return zdo.GetLong(ZDOVars.s_creator, 0L) != playerID;
		}

		public static bool ShouldBlockInactiveWardAccess(PrivateArea inactiveWard, Player player)
		{
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)inactiveWard == (Object)null || inactiveWard.IsEnabled() || (Object)(object)player == (Object)null)
			{
				return false;
			}
			if (wardAccessProtectInactiveWards == null || !wardAccessProtectInactiveWards.Value)
			{
				return false;
			}
			WardConnectedAccessMode mode = ((wardAccessConnectedAccessMode != null) ? wardAccessConnectedAccessMode.Value : WardConnectedAccessMode.Off);
			foreach (PrivateArea allArea in PrivateArea.m_allAreas)
			{
				if ((Object)(object)allArea == (Object)null || (Object)(object)allArea == (Object)(object)inactiveWard || !IsActivePlayerWard(allArea) || !IsPointInsideWardArea(allArea, ((Component)inactiveWard).transform.position) || HasAccessToWardOrConnectedWard(allArea, player, mode))
				{
					continue;
				}
				return true;
			}
			return false;
		}

		public static bool ShouldBlockInactiveWardAccess(PrivateArea inactiveWard, long playerID)
		{
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)inactiveWard == (Object)null || inactiveWard.IsEnabled() || playerID == 0)
			{
				return false;
			}
			if (wardAccessProtectInactiveWards == null || !wardAccessProtectInactiveWards.Value)
			{
				return false;
			}
			WardConnectedAccessMode mode = ((wardAccessConnectedAccessMode != null) ? wardAccessConnectedAccessMode.Value : WardConnectedAccessMode.Off);
			foreach (PrivateArea allArea in PrivateArea.m_allAreas)
			{
				if ((Object)(object)allArea == (Object)null || (Object)(object)allArea == (Object)(object)inactiveWard || !IsActivePlayerWard(allArea) || !IsPointInsideWardArea(allArea, ((Component)inactiveWard).transform.position) || HasAccessToWardOrConnectedWard(allArea, playerID, mode))
				{
					continue;
				}
				return true;
			}
			return false;
		}

		public static bool ShouldBlockInactiveWardAccess(ZDO inactiveWard, long playerID)
		{
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			if (!WardZdoUtils.IsWard(inactiveWard) || inactiveWard.GetBool(ZDOVars.s_enabled, false) || playerID == 0)
			{
				return false;
			}
			if (wardAccessProtectInactiveWards == null || !wardAccessProtectInactiveWards.Value)
			{
				return false;
			}
			WardConnectedAccessMode mode = ((wardAccessConnectedAccessMode != null) ? wardAccessConnectedAccessMode.Value : WardConnectedAccessMode.Off);
			foreach (ZDO allWard in WardZdoUtils.GetAllWards())
			{
				if (allWard == null || ((ZDOID)(ref allWard.m_uid)).Equals(inactiveWard.m_uid) || !IsActiveWardZdoForSettings(allWard) || !IsPointInsideWardArea(allWard, inactiveWard.GetPosition()) || allWard.HasConnectedWardAccess(playerID, mode, IsActiveWardZdoForSettings))
				{
					continue;
				}
				return true;
			}
			return false;
		}

		public static bool CanEditWardSettings(PrivateArea ward, Player player)
		{
			if (!ArePerWardSettingsEnabled() || (Object)(object)ward == (Object)null || (Object)(object)player == (Object)null)
			{
				return false;
			}
			if (wardSettingsAllowAdminEdit.Value && HasWardManagementAccess(ward, player.GetPlayerID()))
			{
				return true;
			}
			if (ShouldBlockInactiveWardAccess(ward, player))
			{
				return false;
			}
			if ((Object)(object)ward.m_piece == (Object)null)
			{
				return false;
			}
			if (wardSettingsRequireCreator.Value)
			{
				return !IsDisabledForeignWard(ward, player.GetPlayerID()) && ward.m_piece.IsCreator();
			}
			return ward.HaveLocalAccess();
		}

		public static bool CanApplyWardSettings(PrivateArea ward, long playerID)
		{
			if (!ArePerWardSettingsEnabled() || (Object)(object)ward == (Object)null || playerID == 0)
			{
				return false;
			}
			if (wardSettingsAllowAdminEdit.Value && HasWardManagementAccess(ward, playerID))
			{
				return true;
			}
			if (ShouldBlockInactiveWardAccess(ward, playerID))
			{
				return false;
			}
			if (wardSettingsRequireCreator.Value)
			{
				return !IsDisabledForeignWard(ward, playerID) && (Object)(object)ward.m_piece != (Object)null && ward.m_piece.GetCreator() == playerID;
			}
			WardConnectedAccessMode mode = ((wardAccessConnectedAccessMode != null) ? wardAccessConnectedAccessMode.Value : WardConnectedAccessMode.Off);
			return HasAccessToWardOrConnectedWard(ward, playerID, mode);
		}

		public static bool CanApplyWardSettings(ZDO zdo, long playerID)
		{
			if (!ArePerWardSettingsEnabled() || zdo == null || playerID == 0)
			{
				return false;
			}
			if (wardSettingsAllowAdminEdit.Value && HasWardManagementAccess(zdo, playerID))
			{
				return true;
			}
			if (ShouldBlockInactiveWardAccess(zdo, playerID))
			{
				return false;
			}
			if (wardSettingsRequireCreator.Value)
			{
				return !IsDisabledForeignWard(zdo, playerID) && zdo.IsCreator(playerID);
			}
			if (WardZdoUtils.HasDirectAccessToWardZdo(zdo, playerID))
			{
				return true;
			}
			if (!IsActiveWardZdoForSettings(zdo))
			{
				return false;
			}
			WardConnectedAccessMode mode = ((wardAccessConnectedAccessMode != null) ? wardAccessConnectedAccessMode.Value : WardConnectedAccessMode.Off);
			return zdo.HasConnectedWardAccess(playerID, mode, IsActiveWardZdoForSettings);
		}

		private static bool IsActiveWardZdoForSettings(ZDO zdo)
		{
			return zdo.IsWard() && zdo.GetBool(ZDOVars.s_enabled, false) && !zdo.GetBool(WardExpiration.s_expirationExpired, false);
		}

		public static bool HasLocalWardAdminAccess()
		{
			Player localPlayer = Player.m_localPlayer;
			return (Object)(object)localPlayer != (Object)null && HasWardAdminAccess(localPlayer.GetPlayerID());
		}

		public static bool HasWardAdminAccess(long playerID)
		{
			if (playerID == 0)
			{
				return false;
			}
			if (wardAdminAccess == null || wardAdminAccess.Value == WardAdminAccessMode.Off)
			{
				return false;
			}
			if (!IsPlayerServerAdminOrHost(playerID))
			{
				return false;
			}
			if (wardAdminAccess.Value == WardAdminAccessMode.Admins)
			{
				return true;
			}
			Player player = Player.GetPlayer(playerID);
			if ((Object)(object)player != (Object)null)
			{
				return ((Character)player).InGodMode();
			}
			Player localPlayer = Player.m_localPlayer;
			return (Object)(object)localPlayer != (Object)null && localPlayer.GetPlayerID() == playerID && ((Character)localPlayer).InGodMode();
		}

		public static bool IsPlayerServerAdminOrHost(long playerID)
		{
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			if (playerID == 0L || (Object)(object)ZNet.instance == (Object)null)
			{
				return false;
			}
			if (ZNet.IsSinglePlayer)
			{
				return true;
			}
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer != (Object)null && localPlayer.GetPlayerID() == playerID && ZNet.instance.LocalPlayerIsAdminOrHost())
			{
				return true;
			}
			PlayerInfo playerInfo;
			return TryFindPlayerInfo(playerID, out playerInfo) && ((PlatformUserID)(ref playerInfo.m_userInfo.m_id)).IsValid && ZNet.instance.PlayerIsAdmin(playerInfo.m_userInfo.m_id);
		}

		internal static bool TryGetRoutedPlayer(long sender, long claimedPlayerID, out RoutedPlayerContext player)
		{
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: 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)
			//IL_0107: 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)
			player = default(RoutedPlayerContext);
			if (claimedPlayerID == 0L || (Object)(object)ZNet.instance == (Object)null)
			{
				return false;
			}
			if (sender != 0L && ZRoutedRpc.instance != null && sender != ZRoutedRpc.instance.m_id)
			{
				return TryGetPeerRoutedPlayer(sender, claimedPlayerID, out player);
			}
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer != (Object)null && localPlayer.GetPlayerID() == claimedPlayerID)
			{
				player = new RoutedPlayerContext(claimedPlayerID, localPlayer.GetPlayerName(), ((Character)localPlayer).GetZDOID(), ((Component)localPlayer).transform.position, hasPosition: true, sender);
				return true;
			}
			Player player2 = Player.GetPlayer(claimedPlayerID);
			if ((Object)(object)player2 != (Object)null)
			{
				player = new RoutedPlayerContext(claimedPlayerID, player2.GetPlayerName(), ((Character)player2).GetZDOID(), ((Component)player2).transform.position, hasPosition: true, sender);
				return true;
			}
			if (TryFindPlayerCharacterZdo(claimedPlayerID, out var characterZdo))
			{
				player = new RoutedPlayerContext(claimedPlayerID, characterZdo.GetString(ZDOVars.s_playerName, ""), characterZdo.m_uid, characterZdo.GetPosition(), hasPosition: true, sender);
				return true;
			}
			return false;
		}

		internal static bool TryGetRoutedPlayer(long sender, out RoutedPlayerContext player)
		{
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			player = default(RoutedPlayerContext);
			if ((Object)(object)ZNet.instance == (Object)null)
			{
				return false;
			}
			if (sender != 0L && ZRoutedRpc.instance != null && sender != ZRoutedRpc.instance.m_id)
			{
				return TryGetPeerRoutedPlayer(sender, out player);
			}
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer != (Object)null)
			{
				player = new RoutedPlayerContext(localPlayer.GetPlayerID(), localPlayer.GetPlayerName(), ((Character)localPlayer).GetZDOID(), ((Component)localPlayer).transform.position, hasPosition: true, sender);
				return true;
			}
			return false;
		}

		private static bool TryGetPeerRoutedPlayer(long sender, long claimedPlayerID, out RoutedPlayerContext player)
		{
			if (!TryGetPeerRoutedPlayer(sender, out player))
			{
				return false;
			}
			return player.PlayerID == claimedPlayerID;
		}

		private static bool TryGetPeerRoutedPlayer(long sender, out RoutedPlayerContext player)
		{
			//IL_0062: 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_00b3: Unknown result type (might be due to invalid IL or missing references)
			player = default(RoutedPlayerContext);
			if ((Object)(object)ZNet.instance == (Object)null || ZDOMan.instance == null)
			{
				return false;
			}
			ZNetPeer peer = ZNet.instance.GetPeer(sender);
			if (peer == null || !peer.IsReady() || ((ZDOID)(ref peer.m_characterID)).IsNone())
			{
				return false;
			}
			ZDO zDO = ZDOMan.instance.GetZDO(peer.m_characterID);
			if (zDO == null)
			{
				return false;
			}
			long num = zDO.GetLong(ZDOVars.s_playerID, 0L);
			if (num == 0)
			{
				return false;
			}
			player = new RoutedPlayerContext(num, zDO.GetString(ZDOVars.s_playerName, ""), peer.m_characterID, zDO.GetPosition(), hasPosition: true, sender);
			return true;
		}

		private static bool TryFindPlayerCharacterZdo(long playerID, out ZDO characterZdo)
		{
			characterZdo = null;
			if (playerID == 0L || (Object)(object)ZNet.instance == (Object)null)
			{
				return false;
			}
			foreach (ZDO allCharacterZDO in ZNet.instance.GetAllCharacterZDOS())
			{
				if (allCharacterZDO == null || allCharacterZDO.GetLong(ZDOVars.s_playerID, 0L) != playerID)
				{
					continue;
				}
				characterZdo = allCharacterZDO;
				return true;
			}
			return false;
		}

		internal static bool TryFindPlayerInfo(long playerID, out PlayerInfo playerInfo)
		{
			//IL_0002: 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_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			playerInfo = default(PlayerInfo);
			if (playerID == 0L || (Object)(object)ZNet.instance == (Object)null || ZDOMan.instance == null)
			{
				return false;
			}
			foreach (PlayerInfo player in ZNet.instance.GetPlayerList())
			{
				ZDOID characterID = player.m_characterID;
				if (!((ZDOID)(ref characterID)).IsNone())
				{
					ZDO zDO = ZDOMan.instance.GetZDO(player.m_characterID);
					if (zDO != null && zDO.GetLong(ZDOVars.s_playerID, 0L) == playerID)
					{
						playerInfo = player;
						return true;
					}
				}
			}
			return false;
		}

		public static bool HasZdoBool(ZDO zdo, int key)
		{
			return zdo != null && zdo.GetBool(key, false) == zdo.GetBool(key, true);
		}

		public static bool HasZdoFloat(ZDO zdo, int key)
		{
			if (zdo == null)
			{
				return false;
			}
			return !Mathf.Approximately(zdo.GetFloat(key, -3102807f / (float)Math.PI), -3102807f / (float)Math.PI) || !Mathf.Approximately(zdo.GetFloat(key, -987653.1f), -987653.1f);
		}

		public static bool HasZdoString(ZDO zdo, int key)
		{
			if (zdo == null)
			{
				return false;
			}
			string text = zdo.GetString(key, "__pw_missing_a__");
			string text2 = zdo.GetString(key, "__pw_missing_b__");
			return text == text2 && !string.IsNullOrEmpty(text);
		}

		public static bool HasZdoVec3(ZDO zdo, int key)
		{
			Vector3 val = default(Vector3);
			return zdo != null && zdo.GetVec3(key, ref val);
		}

		public static bool GetWardBoolSetting(ZDO zdo, int key, bool defaultValue, bool disabledValue = false)
		{
			if (!ArePerWardSettingsEnabled())
			{
				return defaultValue;
			}
			bool flag = (wardSettingsUseDefaultsForAllWards.Value ? defaultValue : disabledValue);
			return (zdo != null) ? zdo.GetBool(key, flag) : flag;
		}

		public static float GetWardFloatSetting(ZDO zdo, int key, float defaultValue)
		{
			return (ArePerWardSettingsEnabled() && zdo != null) ? zdo.GetFloat(key, defaultValue) : defaultValue;
		}

		public static string GetWardStringSetting(ZDO zdo, int key, string defaultValue)
		{
			if (!ArePerWardSettingsEnabled() || zdo == null)
			{
				return defaultValue;
			}
			string text = zdo.GetString(key, defaultValue);
			return string.IsNullOrEmpty(text) ? defaultValue : text;
		}

		public static Vector3 GetWardVec3Setting(ZDO zdo, int key, Vector3 defaultValue)
		{
			//IL_0016: 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_001d: 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)
			Vector3 val = default(Vector3);
			return (ArePerWardSettingsEnabled() && zdo != null && zdo.GetVec3(key, ref val)) ? val : defaultValue;
		}

		public static void RemoveZdoBool(ZDO zdo, int key)
		{
			if (zdo != null)
			{
				zdo.RemoveInt(key);
			}
		}

		public static void RemoveZdoFloat(ZDO zdo, int key)
		{
			if (zdo != null)
			{
				zdo.RemoveFloat(key);
			}
		}

		public static void RemoveZdoString(ZDO zdo, int key)
		{
			if (zdo != null)
			{
				zdo.Set(key, "");
			}
		}

		public static void RemoveZdoVec3(ZDO zdo, int key)
		{
			if (zdo != null)
			{
				zdo.RemoveVec3(key);
			}
		}

		private static void ApplyRangeEffect(Component parent, Type includedTypes, float newRadius)
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)parent == (Object)null)
			{
				return;
			}
			EffectArea componentInChildren = parent.GetComponentInChildren<EffectArea>();
			if (!((Object)(object)componentInChildren == (Object)null) && componentInChildren.m_type == includedTypes)
			{
				SphereCollider component = ((Component)componentInChildren).GetComponent<SphereCollider>();
				if (!((Object)(object)component == (Object)null))
				{
					component.radius = newRadius;
				}
			}
		}

		private static void SetWardRange(PrivateArea __instance, float range)
		{
			float num = (__instance.m_radius = Math.Max(range, 0f));
			__instance.m_areaMarker.m_radius = num;
			__instance.m_areaMarker.m_nrOfSegments = (int)(80f * (wardAreaMarkerPatch.Value ? wardAreaMarkerAmount.Value : 1f) * (num / 32f));
			ApplyRangeEffect((Component)(object)__instance, (Type)4, num);
		}

		private static void SetWardPlayerBase(PrivateArea __instance, float range)
		{
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			Transform val = ((Component)__instance).transform.Find("PlayerBase");
			if ((Object)(object)val != (Object)null)
			{
				val.localScale = (supressSpawnInRange.Value ? Vector3.one : (Vector3.one * Math.Min(1f, 10f / Math.Max(range, 1f))));
			}
		}

		private static void FillWardProtectionLists()
		{
			_wardPlantProtectionList = new HashSet<string>((from p in wardPlantProtectionList.Value.Split(new char[1] { ',' }).SelectMany(delegate(string p)
				{
					string text = p.Trim();
					string itemName = text.GetItemName();
					return new string[2]
					{
						text.ToLower(),
						itemName.ToLower()
					};
				})
				where !string.IsNullOrWhiteSpace(p)
				select p).ToList());
			_boarsHensProtectionGroupList = new HashSet<string>((from p in boarsHensProtectionGroupList.Value.Split(new char[1] { ',' })
				select p.Trim().ToLower() into p
				where !string.IsNullOrWhiteSpace(p)
				select p).ToList());
		}

		private static bool IsCraftingStationNear(Piece piece, PrivateArea ward)
		{
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			return !wardPassiveRepairRequireStation.Value || (Object)(object)piece.m_craftingStation == (Object)null || ZoneSystem.instance.GetGlobalKey((GlobalKeys)22) || Object.op_Implicit((Object)(object)CraftingStation.HaveBuildStationInRange(piece.m_craftingStation.m_name, ((Component)ward).transform.position)) || Object.op_Implicit((Object)(object)CraftingStation.HaveBuildStationInRange(piece.m_craftingStation.m_name, ((Component)piece).transform.position));
		}

		private static bool CanBeRepaired(Piece piece, PrivateArea ward)
		{
			WearNTear val = default(WearNTear);
			return (piece.IsPlacedByPlayer() ? IsCraftingStationNear(piece, ward) : wardPassiveRepairNonPlayer.Value) && ((Component)piece).TryGetComponent<WearNTear>(ref val) && val.GetHealthPercentage() < 1f;
		}

		public static IEnumerator PassiveRepairEffect(PrivateArea ward, Player initiator)
		{
			WearNTear WNT = default(WearNTear);
			while (true)
			{
				if ((Object)(object)ward == (Object)null || !Object.op_Implicit((Object)(object)ZNetScene.instance))
				{
					yield break;
				}
				if (Game.IsPaused())
				{
					yield return (object)new WaitForSeconds(2f);
				}
				List<Piece> pieces = new List<Piece>();
				CollectionExtensions.Do<PrivateArea>(ConnectedAreas(ward), (Action<PrivateArea>)delegate(PrivateArea area)
				{
					//IL_0006: Unknown result type (might be due to invalid IL or missing references)
					Piece.GetAllPiecesInRadius(((Component)area).transform.position, area.m_radius, pieces);
				});
				HashSet<Piece> piecesToRepair = pieces.Where((Piece piece2) => CanBeRepaired(piece2, ward)).ToHashSet();
				if (piecesToRepair.Count == 0)
				{
					break;
				}
				wardIsRepairing[ward] = piecesToRepair.Count;
				foreach (Piece piece in piecesToRepair)
				{
					if (((Component)piece).TryGetComponent<WearNTear>(ref WNT) && WNT.Repair())
					{
						piece.m_placeEffect.Create(((Component)piece).transform.position, ((Component)piece).transform.rotation, (Transform)null, 1f, -1);
						wardIsRepairing.TryGetValue(ward, out var toRepair);
						wardIsRepairing[ward] = Math.Max(toRepair - 1, 0);
						if (initiator != null)
						{
							((Character)initiator).Message((MessageType)1, "$piece_repair".Localize(), 0, (Sprite)null);
						}
						break;
					}
					WNT = null;
				}
				yield return (object)new WaitForSecondsRealtime(10f);
			}
			LogInfo("Passive repairing stopped");
			wardIsRepairing.Remove(ward);
			if ((Object)(object)initiator != (Object)null)
			{
				string str = "$msg_doesnotneedrepair".Localize();
				((Character)initiator).Message((MessageType)1, char.ToUpper(str[0]) + str.Substring(1), 0, (Sprite)null);
			}
		}

		public static IEnumerator AutoClosingDoors(PrivateArea ward)
		{
			List<Door> doors;
			while (true)
			{
				if ((Object)(object)ward == (Object)null)
				{
					yield break;
				}
				if (Game.IsPaused())
				{
					yield return (object)new WaitForSeconds(2f);
				}
				if (!wardIsClosing.TryGetValue(ward, out var secondsToClose) || !doorsToClose.TryGetValue(ward, out doors))
				{
					yield break;
				}
				if (secondsToClose <= 0)
				{
					break;
				}
				wardIsClosing[ward]--;
				yield return (object)new WaitForSeconds(1f);
				doors = null;
			}
			if (doors.Count > 0)
			{
				LogInfo($"Closed {doors.Count} doors");
				doors.ForEach(delegate(Door door)
				{
					if (door.m_nview.IsValid())
					{
						door.m_nview.GetZDO().Set(ZDOVars.s_state, 0, false);
						door.UpdateState();
					}
				});
			}
			wardIsClosing.Remove(ward);
			doorsToClose.Remove(ward);
			LogInfo("Doors closing stopped");
		}

		public static IEnumerable<PrivateArea> ConnectedAreas(PrivateArea ward)
		{
			return PrivateArea.m_allAreas.Where((PrivateArea area) => (Object)(object)area == (Object)(object)ward || (area.IsEnabled() && AreWardsOverlapping(ward, area)));
		}

		internal static void ActivateConnectedLoadedWards(PrivateArea rootWard, long requesterID, string requesterName = "")
		{
			if (s_activatingConnectedWards || (Object)(object)rootWard == (Object)null || requesterID == 0L || !rootWard.IsEnabled())
			{
				return;
			}
			WardConnectedAccessMode wardConnectedAccessMode = wardAccessConnectedAccessMode?.Value ?? WardConnectedAccessMode.Off;
			if (wardConnectedAccessMode == WardConnectedAccessMode.Off)
			{
				return;
			}
			s_activatingConnectedWards = true;
			try
			{
				foreach (PrivateArea item in ConnectedActivationAreas(rootWard, requesterID, wardConnectedAccessMode))
				{
					if (!((Object)(object)item == (Object)(object)rootWard))
					{
						if (WardExpiration.IsExpired(item))
						{
							WardExpiration.SetExpired(item.m_nview.GetZDO(), expired: false, requesterID, requesterName);
						}
						if (!item.IsEnabled())
						{
							item.SetEnabled(true);
						}
					}
				}
			}
			finally
			{
				s_activatingConnectedWards = false;
			}
		}

		internal static void ActivateConnectedWardZdos(ZDO rootWard, long requesterID, string requesterName = "")
		{
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_011c: Unknown result type (might be due to invalid IL or missing references)
			if (s_activatingConnectedWardZdos || !WardZdoUtils.IsWard(rootWard) || requesterID == 0L || !rootWard.GetBool(ZDOVars.s_enabled, false) || WardExpiration.IsExpired(rootWard))
			{
				return;
			}
			WardConnectedAccessMode wardConnectedAccessMode = wardAccessConnectedAccessMode?.Value ?? WardConnectedAccessMode.Off;
			if (wardConnectedAccessMode == WardConnectedAccessMode.Off)
			{
				return;
			}
			s_activatingConnectedWardZdos = true;
			try
			{
				HashSet<ZDOID> hashSet = new HashSet<ZDOID>();
				List<ZDO> list = new List<ZDO>();
				int num = 0;
				hashSet.Add(rootWard.m_uid);
				list.Add(rootWard);
				while (num < list.Count)
				{
					ZDO protectedWard = list[num++];
					foreach (ZDO allWard in WardZdoUtils.GetAllWards())
					{
						if (allWard != null && !hashSet.Contains(allWard.m_uid) && WardZdoUtils.AreWardZdosOverlapping(protectedWard, allWard) && (WardZdoUtils.HasDirectAccessToWardZdo(allWard, requesterID) || HasWardAdminAccess(requesterID)) && WardZdoUtils.CanShareConnectedWardAccess(rootWard, allWard, wardConnectedAccessMode))
						{
							hashSet.Add(allWard.m_uid);
							list.Add(allWard);
							if (WardExpiration.IsExpired(allWard))
							{
								WardExpiration.SetExpired(allWard, expired: false, requesterID, requesterName);
							}
							if (!allWard.GetBool(ZDOVars.s_enabled, false))
							{
								allWard.Set(ZDOVars.s_enabled, true);
							}
						}
					}
				}
			}
			finally
			{
				s_activatingConnectedWardZdos = false;
			}
		}

		private static IEnumerable<PrivateArea> ConnectedActivationAreas(PrivateArea rootWard, long requesterID, WardConnectedAccessMode mode)
		{
			HashSet<PrivateArea> visited = new HashSet<PrivateArea>();
			List<PrivateArea> queue = new List<PrivateArea>();
			int queueIndex = 0;
			visited.Add(rootWard);
			queue.Add(rootWard);
			while (queueIndex < queue.Count)
			{
				PrivateArea current = queue[queueIndex++];
				yield return current;
				foreach (PrivateArea candidate in PrivateArea.m_allAreas)
				{
					if (!((Object)(object)candidate == (Object)null) && !visited.Contains(candidate) && IsPlayerWard(candidate) && AreWardsOverlapping(current, candidate) && (HasDirectAccessToWard(candidate, requesterID) || HasWardAdminAccess(requesterID)) && CanShareConnectedActivation(rootWard, candidate, mode))
					{
						visited.Add(candidate);
						queue.Add(candidate);
					}
				}
			}
		}

		private static bool IsPlayerWard(PrivateArea ward)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Invalid comparison between Unknown and I4
			return (Object)(object)ward != (Object)null && (int)ward.m_ownerFaction == 0;
		}

		private static bool CanShareConnectedActivation(PrivateArea protectedWard, PrivateArea candidateWard, WardConnectedAccessMode mode)
		{
			if (mode == WardConnectedAccessMode.Off)
			{
				return false;
			}
			if (!IsPlayerWard(protectedWard) || !IsPlayerWard(candidateWard))
			{
				return false;
			}
			if ((Object)(object)protectedWard == (Object)(object)candidateWard)
			{
				return true;
			}
			switch (mode)
			{
			case WardConnectedAccessMode.SameCreatorOnly:
			{
				long creatorId = GetCreatorId(protectedWard);
				long creatorId2 = GetCreatorId(candidateWard);
				return creatorId != 0L && creatorId == creatorId2;
			}
			case WardConnectedAccessMode.MutualTrust:
			{
				long creatorId = GetCreatorId(protectedWard);
				long creatorId2 = GetCreatorId(candidateWard);
				return creatorId != 0L && creatorId2 != 0L && HasDirectAccessToWard(protectedWard, creatorId2) && HasDirectAccessToWard(candidateWard, creatorId);
			}
			case WardConnectedAccessMode.AnyConnected:
				return true;
			default:
				return false;
			}
		}

		private static void InitEmissionColor(PrivateArea ward)
		{
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: 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_015d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0166: Unknown result type (might be due to invalid IL or missing references)
			//IL_0139: Unknown result type (might be due to invalid IL or missing references)
			//IL_013f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0145: Unknown result type (might be due to invalid IL or missing references)
			//IL_0190: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0204: Unknown result type (might be due to invalid IL or missing references)
			//IL_0208: Unknown result type (might be due to invalid IL or missing references)
			//IL_0212: Unknown result type (might be due to invalid IL or missing references)
			//IL_021c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0228: Unknown result type (might be due to invalid IL or missing references)
			//IL_022d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0231: Unknown result type (might be due to invalid IL or missing references)
			//IL_023b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0240: Unknown result type (might be due to invalid IL or missing references)
			//IL_0289: Unknown result type (might be due to invalid IL or missing references)
			//IL_028e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0298: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b6: Unknown result type (might be due to invalid IL or missing references)
			if (!IsPlayerWardPrefab(ward) || !Object.op_Implicit((Object)(object)ward.m_model) || (Object)(object)ward.m_nview == (Object)null || !ward.m_nview.IsValid())
			{
				return;
			}
			ZDO zDO = ward.m_nview.GetZDO();
			if (zDO == null)
			{
				return;
			}
			int num = FindWardEmissionMaterialIndex(ward);
			if (num == -1)
			{
				return;
			}
			CacheWardEmissionDefaults(ward);
			if (!GetWardBoolSetting(zDO, s_customColor, wardEmissionColorEnabled.Value))
			{
				ResetWardEmissionColor(ward, num);
				return;
			}
			Vector3 defaultValue = default(Vector3);
			((Vector3)(ref defaultValue))..ctor(wardEmissionColor.Value.r, wardEmissionColor.Value.g, wardEmissionColor.Value.b);
			Vector3 wardVec3Setting = GetWardVec3Setting(zDO, s_color, defaultValue);
			float wardFloatSetting = GetWardFloatSetting(zDO, s_colorMultiplier, wardEmissionColorMultiplier.Value);
			Color val = default(Color);
			if (ArePerWardSettingsEnabled() && HasZdoVec3(zDO, s_color) && !HasZdoFloat(zDO, s_colorMultiplier))
			{
				((Color)(ref val))..ctor(wardVec3Setting.x, wardVec3Setting.y, wardVec3Setting.z);
			}
			else
			{
				((Color)(ref val))..ctor(wardVec3Setting.x * wardFloatSetting, wardVec3Setting.y * wardFloatSetting, wardVec3Setting.z * wardFloatSetting);
			}
			((Renderer)ward.m_model).GetPropertyBlock(s_matBlock, num);
			s_matBlock.SetColor("_EmissionColor", val);
			((Renderer)ward.m_model).SetPropertyBlock(s_matBlock, num);
			if (!wardLightColorEnabled.Value || !Object.op_Implicit((Object)(object)ward.m_enabledEffect))
			{
				return;
			}
			float num2 = ((wardFloatSetting == 0f) ? 1f : wardFloatSetting);
			ParticleSystem[] componentsInChildren = ward.m_enabledEffect.GetComponentsInChildren<ParticleSystem>();
			foreach (ParticleSystem val2 in componentsInChildren)
			{
				MainModule main = val2.main;
				float num3 = val.r / num2;
				float num4 = val.g / num2;
				float num5 = val.b / num2;
				MinMaxGradient startColor = ((MainModule)(ref main)).startColor;
				((MainModule)(ref main)).startColor = MinMaxGradient.op_Implicit(new Color(num3, num4, num5, ((MinMaxGradient)(ref startColor)).color.a));
			}
			Light componentInChildren = ward.m_enabledEffect.GetComponentInChildren<Light>();
			if (Object.op_Implicit((Object)(object)componentInChildren))
			{
				componentInChildren.color = Color.Lerp(new Color(0.99f, 0.87f, 0.76f), new Color(val.r / num2, val.g / num2, val.b / num2), 0.5f);
				LightFlicker val3 = default(LightFlicker);
				if (!((Component)componentInChildren).TryGetComponent<LightFlicker>(ref val3) && addLightMovement.Value)
				{
					val3 = ((Component)componentInChildren).gameObject.AddComponent<LightFlicker>();
				}
				if ((Object)(object)val3 != (Object)null)
				{
					((Behaviour)val3).enabled = addLightMovement.Value;
					val3.m_flickerIntensity = 0.1f;
					val3.m_flickerSpeed = 1f;
					val3.m_movement = 0.1f;
					val3.m_fadeInDuration = 3f;
				}
			}
		}

		private static int FindWardEmissionMaterialIndex(PrivateArea ward)
		{
			if ((Object)(object)ward == (Object)null || !Object.op_Implicit((Object)(object)ward.m_model))
			{
				return -1;
			}
			for (int i = 0; i < ((Renderer)ward.m_model).sharedMaterials.Length; i++)
			{
				if (((Object)((Renderer)ward.m_model).sharedMaterials[i]).name.StartsWith("Guardstone_OdenGlow_mat"))
				{
					return i;
				}
			}
			return -1;
		}

		private static void CacheWardEmissionDefaults(PrivateArea ward)
		{
			//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_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)ward == (Object)null || s_wardEmissionDefaults.ContainsKey(ward))
			{
				return;
			}
			WardEmissionDefaults wardEmissionDefaults = new WardEmissionDefaults();
			if (Object.op_Implicit((Object)(object)ward.m_enabledEffect))
			{
				wardEmissionDefaults.ParticleSystems = ward.m_enabledEffect.GetComponentsInChildren<ParticleSystem>();
				wardEmissionDefaults.ParticleStartColors = (MinMaxGradient[])(object)new MinMaxGradient[wardEmissionDefaults.ParticleSystems.Length];
				for (int i = 0; i < wardEmissionDefaults.ParticleSystems.Length; i++)
				{
					MinMaxGradient[] particleStartColors = wardEmissionDefaults.ParticleStartColors;
					int num = i;
					MainModule main = wardEmissionDefaults.ParticleSystems[i].main;
					particleStartColors[num] = ((MainModule)(ref main)).startColor;
				}
				wardEmissionDefaults.Light = ward.m_enabledEffect.GetComponentInChildren<Light>();
				if (Object.op_Implicit((Object)(object)wardEmissionDefaults.Light))
				{
					wardEmissionDefaults.LightColor = wardEmissionDefaults.Light.color;
					wardEmissionDefaults.HadFlicker = ((Component)wardEmissionDefaults.Light).TryGetComponent<LightFlicker>(ref wardEmissionDefaults.Flicker);
					wardEmissionDefaults.FlickerEnabled = (Object)(object)wardEmissionDefaults.Flicker != (Object)null && ((Behaviour)wardEmissionDefaults.Flicker).enabled;
				}
			}
			s_wardEmissionDefaults[ward] = wardEmissionDefaults;
		}

		private static void ResetWardEmissionColor(PrivateArea ward, int materialIndex)
		{
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)ward == (Object)null || !Object.op_Implicit((Object)(object)ward.m_model))
			{
				return;
			}
			((Renderer)ward.m_model).SetPropertyBlock((MaterialPropertyBlock)null, materialIndex);
			if (!s_wardEmissionDefaults.TryGetValue(ward, out var value))
			{
				return;
			}
			if (value.ParticleSystems != null && value.ParticleStartColors != null)
			{
				int num = Math.Min(value.ParticleSystems.Length, value.ParticleStartColors.Length);
				for (int i = 0; i < num; i++)
				{
					ParticleSystem val = value.ParticleSystems[i];
					if (Object.op_Implicit((Object)(object)val))
					{
						MainModule main = val.main;
						((MainModule)(ref main)).startColor = value.ParticleStartColors[i];
					}
				}
			}
			if (!Object.op_Implicit((Object)(object)value.Light))
			{
				return;
			}
			value.Light.color = value.LightColor;
			LightFlicker component = ((Component)value.Light).GetComponent<LightFlicker>();
			if ((Object)(object)component != (Object)null)
			{
				if (value.HadFlicker)
				{
					((Behaviour)component).enabled = value.FlickerEnabled;
				}
				else
				{
					Object.Destroy((Object)(object)component);
				}
			}
		}

		private static string NormalizeHtmlColor(string value)
		{
			if (Utility.IsNullOrWhiteSpace(value))
			{
				return value;
			}
			return value.StartsWith("#") ? value : ("#" + value);
		}

		public static void InitCircleProjectorState(CircleProjector marker, ZNetView nview)
		{
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: 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_00be: 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_010d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0114: Expected O, but got Unknown
			//IL_0114: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: Unknown result type (might be due to invalid IL or missing references)
			//IL_0109: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0131: Unknown result type (might be due to invalid IL or missing references)
			//IL_0137: Unknown result type (might be due to invalid IL or missing references)
			//IL_013c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0143: Unknown result type (might be due to invalid IL or missing references)
			//IL_014a: Unknown result type (might be due to invalid IL or missing references)
			//IL_014f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0156: Unknown result type (might be due to invalid IL or missing references)
			//IL_015d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0162: Unknown result type (might be due to invalid IL or missing references)
			//IL_0169: Unknown result type (might be due to invalid IL or missing references)
			//IL_016f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0174: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_020a: Unknown result type (might be due to invalid IL or missing references)
			//IL_022a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0255: Unknown result type (might be due to invalid IL or missing references)
			//IL_0257: Unknown result type (might be due to invalid IL or missing references)
			//IL_027c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0275: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)marker == (Object)null || (Object)(object)nview == (Object)null || !nview.IsValid())
			{
				return;
			}
			PrivateArea component = ((Component)((Component)marker).transform.root).GetComponent<PrivateArea>();
			if (!IsPlayerWardPrefab(component))
			{
				return;
			}
			ZDO zDO = nview.GetZDO();
			if (GetWardBoolSetting(zDO, s_circleEnabled, wardAreaMarkerPatch.Value))
			{
				string wardStringSetting = GetWardStringSetting(zDO, s_circleStartColor, ColorUtility.ToHtmlStringRGBA(wardAreaMarkerStartColor.Value));
				Color val = wardAreaMarkerStartColor.Value;
				Color val2 = default(Color);
				if (!Utility.IsNullOrWhiteSpace(wardStringSetting) && ColorUtility.TryParseHtmlString(NormalizeHtmlColor(wardStringSetting), ref val2))
				{
					val = val2;
				}
				string wardStringSetting2 = GetWardStringSetting(zDO, s_circleEndColor, ColorUtility.ToHtmlStringRGBA(wardAreaMarkerEndColor.Value));
				Color val3 = wardAreaMarkerEndColor.Value;
				Color val4 = default(Color);
				if (!Utility.IsNullOrWhiteSpace(wardStringSetting2) && ColorUtility.TryParseHtmlString(NormalizeHtmlColor(wardStringSetting2), ref val4))
				{
					val3 = val4;
				}
				Gradient val5 = new Gradient();
				if (val3 != Color.clear)
				{
					val5.SetKeys((GradientColorKey[])(object)new GradientColorKey[4]
					{
						new GradientColorKey(val, 0f),
						new GradientColorKey(val3, 0.45f),
						new GradientColorKey(val3, 0.55f),
						new GradientColorKey(val, 1f)
					}, Array.Empty<GradientAlphaKey>());
				}
				marker.m_speed = GetWardFloatSetting(zDO, s_circleSpeed, wardAreaMarkerSpeed.Value);
				for (int i = 0; i < marker.m_segments.Count; i++)
				{
					GameObject val6 = marker.m_segments[i];
					val6.transform.localScale = new Vector3(marker.m_prefab.transform.localScale.x * GetWardFloatSetting(zDO, s_circleWidth, wardAreaMarkerWidth.Value), marker.m_prefab.transform.localScale.y, marker.m_prefab.transform.localScale.z * GetWardFloatSetting(zDO, s_circleLength, wardAreaMarkerLength.Value));
					Renderer component2 = (Renderer)(object)val6.GetComponent<MeshRenderer>();
					component2.GetPropertyBlock(s_matBlock);
					s_matBlock.SetColor("_Color", (val3 == Color.clear) ? val : val5.Evaluate((float)i / (float)marker.m_segments.Count));
					component2.SetPropertyBlock(s_matBlock);
				}
			}
		}

		public static void InitBubbleState(PrivateArea ward, GameObject bubble, ZNetView m_nview)
		{
			//IL_0094: 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: 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_00ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_010e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0118: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0125: Unknown result type (might be due to invalid IL or missing references)
			//IL_012b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0131: Unknown result type (might be due to invalid IL or missing references)
			//IL_0142: Unknown result type (might be due to invalid IL or missing references)
			//IL_016c: Unknown result type (might be due to invalid IL or missing references)
			if (!IsPlayerWardPrefab(ward) || (Object)(object)bubble == (Object)null)
			{
				return;
			}
			if ((Object)(object)m_nview == (Object)null || !m_nview.IsValid())
			{
				bubble.SetActive(false);
				return;
			}
			ZDO zDO = m_nview.GetZDO();
			if (zDO == null)
			{
				bubble.SetActive(false);
				return;
			}
			bubble.SetActive(GetWardBoolSetting(zDO, s_bubbleEnabled, wardBubbleShow.Value) && ward.IsEnabled());
			bubble.transform.localScale = Vector3.one * ward.m_radius * 2f;
			Transform val = bubble.transform.Find("NoMonsterArea");
			if ((Object)(object)val != (Object)null)
			{
				Object.Destroy((Object)(object)((Component)val).gameObject);
			}
			MeshRenderer component = bubble.GetComponent<MeshRenderer>();
			Vector3 wardVec3Setting = GetWardVec3Setting(zDO, s_bubbleColor, new Vector3(wardBubbleColor.Value.r, wardBubbleColor.Value.g, wardBubbleColor.Value.b));
			Color val2 = default(Color);
			((Color)(ref val2))..ctor(wardVec3Setting.x, wardVec3Setting.y, wardVec3Setting.z, GetWardFloatSetting(zDO, s_bubbleColorAlpha, wardBubbleColor.Value.a));
			((Renderer)component).GetPropertyBlock(s_matBlock);
			s_matBlock.SetColor("_Color", val2);
			s_matBlock.SetFloat("_RefractionIntensity", GetWardFloatSetting(zDO, s_bubbleRefractionIntensity, wardBubbleRefractionIntensity.Value));
			s_matBlock.SetFloat("_WaveVel", GetWardFloatSetting(zDO, s_bubbleWaveVel, wardBubbleWaveIntensity.Value));
			s_matBlock.SetFloat("_Glossiness", GetWardFloatSetting(zDO, s_bubbleGlossiness, wardBubbleGlossiness.Value));
			s_matBlock.SetFloat("_Metallic", GetWardFloatSetting(zDO, s_bubbleMetallic, wardBubbleMetallic.Value));
			s_matBlock.SetFloat("_NormalScale", GetWardFloatSetting(zDO, s_bubbleNormalScale, wardBubbleNormalScale.Value));
			s_matBlock.SetFloat("_DepthFade", GetWardFloatSetting(zDO, s_bubbleDepthFade, wardBubbleDepthFade.Value));
			((Renderer)component).SetPropertyBlock(s_matBlock);
		}

		public static void InitDemisterState(PrivateArea ward, GameObject demister, ZNetView m_nview)
		{
			if (IsPlayerWardPrefab(ward) && !((Object)(object)demister == (Object)null))
			{
				if ((Object)(object)m_nview == (Object)null || !m_nview.IsValid())
				{
					demister.SetActive(false);
					return;
				}
				demister.SetActive(wardDemisterEnabled.Value && ward.IsEnabled());
				demister.GetComponent<ParticleSystemForceField>().endRange = ward.m_radius;
			}
		}

		private static void AddBossAltarTaxiOffering(List<string> offeringsList, bool enabled, string itemName, int amount, bool consumeItem, string destinationName)
		{
			if (enabled && !Utility.IsNullOrWhiteSpace(itemName) && !((Object)(object)Player.m_localPlayer == (Object)null) && (Player.m_localPlayer.IsMaterialKnown(itemName) || Player.m_localPlayer.NoCostCheat()))
			{
				offeringsList.Add(itemName + " " + ((amount > 1) ? $"x{amount}" : "") + " - $pw_ward_offering_bossaltar_description " + destinationName + (consumeItem ? ". $pw_ward_offering_bossaltar_item_consumed" : ""));
			}
		}

		private static List<string> BuildAvailableOfferingList(out bool hasTaxiOffering)
		{
			List<string> list = new List<string>();
			hasTaxiOffering = false;
			if ((Object)(object)Player.m_localPlayer == (Object)null)
			{
				return list;
			}
			if (offeringActiveRepair.Value && (Player.m_localPlayer.IsMaterialKnown("$item_surtlingcore") || Player.m_localPlayer.NoCostCheat()))
			{
				list.Add("$item_surtlingcore - $pw_ward_offering_surtlingcore_description");
			}
			if (offeringAugmenting.Value && (Player.m_localPlayer.IsMaterialKnown("$item_blackcore") || Player.m_localPlayer.NoCostCheat()))
			{
				list.Add("$item_blackcore - $pw_ward_offering_blackcore_description");
			}
			if (offeringFood.Value)
			{
				list.Add("$item_food - $pw_ward_offering_food_description");
			}
			if (offeringMead.Value)
			{
				list.Add("$se_mead_name - $pw_ward_offering_mead_description");
			}
			if (offeringThundertone.Value && (Player.m_localPlayer.IsMaterialKnown("$item_thunderstone") || Player.m_localPlayer.NoCostCheat()))
			{
				list.Add("$item_thunderstone - $pw_ward_offering_thunderstone_description");
			}
			if (offeringTrophy.Value)
			{
				list.Add("$inventory_trophies - $pw_ward_offering_trophies_description");
			}
			if (offeringYmirRemains.Value && (Player.m_localPlayer.IsMaterialKnown("$item_ymirremains") || Player.m_localPlayer.NoCostCheat()))
			{
				list.Add("$item_ymirremains - $pw_ward_offering_ymirremains_description");
			}
			if (offeringEitr.Value && (Player.m_localPlayer.IsMaterialKnown("$item_eitr") || Player.m_localPlayer.NoCostCheat()))
			{
				list.Add("$item_eitr - $pw_ward_offering_eitr_description");
			}
			if (offeringDragonEgg.Value && ((Player.m_localPlayer.IsMaterialKnown("$item_dragonegg") && ZoneSystem.instance.GetGlobalKey((GlobalKeys)34)) || Player.m_localPlayer.NoCostCheat()))
			{
				list.Add("$item_dragonegg - $pw_ward_offering_dragonegg_description");
			}
			if (!offeringTaxi.Value)
			{
				return list;
			}
			int count = list.Count;
			if (offeringTaxiStartTempleEnabled.Value)
			{
				list.Add(offeringTaxiStartTempleConsumeItem.Value ? "$pw_ward_offering_bosstrophies - $pw_ward_offering_bosstrophies_consumed_description" : "$pw_ward_offering_bosstrophies - $pw_ward_offering_bosstrophies_description");
			}
			string itemName = offeringTaxiPriceHaldorItem.Value.GetItemName();
			if (offeringTaxiHaldorEnabled.Value && !Utility.IsNullOrWhiteSpace(itemName) && (Player.m_localPlayer.IsMaterialKnown(itemName) || Player.m_localPlayer.NoCostCheat()))
			{
				ZoneSystem.instance.tempIconList.Clear();
				ZoneSystem.instance.GetLocationIcons(ZoneSystem.instance.tempIconList);
				int num = (ZoneSystem.instance.tempIconList.Any((KeyValuePair<Vector3, string> icon) => icon.Value == "Vendor_BlackForest") ? offeringTaxiPriceHaldorDiscovered.Value : offeringTaxiPriceHaldorUndiscovered.Value);
				list.Add($"{itemName}: {num} - $pw_ward_offering_coins_description");
			}
			string itemName2 = offeringTaxiPriceHildirItem.Value.GetItemName();
			if (offeringTaxiHildirEnabled.Value && !Utility.IsNullOrWhiteSpace(itemName2) && (Player.m_localPlayer.IsMaterialKnown(itemName2) || Player.m_localPlayer.NoCostCheat()))
			{
				list.Add(itemName2 + " " + ((offeringTaxiPriceHildirAmount.Value > 1) ? $"x{offeringTaxiPriceHildirAmount.Value}" : "") + " - $pw_ward_offering_hildiritem_description");
			}
			if (offeringTaxiHildirEnabled.Value && offeringTaxiHildirChestsEnabled.Value && (Player.m_localPlayer.IsMaterialKnown("$item_chest_hildir1") || Player.m_localPlayer.IsMaterialKnown("$item_chest_hildir2") || Player.m_localPlayer.IsMaterialKnown("$item_chest_hildir3") || Player.m_localPlayer.NoCostCheat()))
			{
				list.Add("$pw_ward_offering_hildirchest - $pw_ward_offering_hildirchest_description");
			}
			string itemName3 = offeringTaxiPriceBogWitchItem.Value.GetItemName();
			if (offeringTaxiBogWitchEnabled.Value && !Utility.IsNullOrWhiteSpace(itemName3) && (Player.m_localPlayer.IsMaterialKnown(itemName3) || Player.m_localPlayer.NoCostCheat()))
			{
				list.Add(itemName3 + " " + ((offeringTaxiPriceBogWitchAmount.Value > 0) ? $"x{offeringTaxiPriceBogWitchAmount.Value}" : "") + " - $pw_ward_offering_bogwitchitem_description");
			}
			AddBossAltarTaxiOffering(list, offeringTaxiEikthyrAltarEnabled.Value, offeringTaxiEikthyrAltarItem.Value.GetItemName(), offeringTaxiEikthyrAltarAmount.Value, offeringTaxiEikthyrAltarConsumeItem.Value, "Eikthyr altar");
			AddBossAltarTaxiOffering(list, offeringTaxiElderAltarEnabled.Value, offeringTaxiElderAltarItem.Value.GetItemName(), offeringTaxiElderAltarAmount.Value, offeringTaxiElderAltarConsumeItem.Value, "Elder altar");
			AddBossAltarTaxiOffering(list, offeringTaxiBonemassAltarEnabled.Value, offeringTaxiBonemassAltarItem.Value.GetItemName(), offeringTaxiBonemassAltarAmount.Value, offeringTaxiBonemassAltarConsumeItem.Value, "Bonemass altar");
			AddBossAltarTaxiOffering(list, offeringTaxiModerAltarEnabled.Value, offeringTaxiModerAltarItem.Value.GetItemName(), offeringTaxiModerAltarAmount.Value, offeringTaxiModerAltarConsumeItem.Value, "Moder altar");
			AddBossAltarTaxiOffering(list, offeringTaxiYagluthAltarEnabled.Value, offeringTaxiYagluthAltarItem.Value.GetItemName(), offeringTaxiYagluthAltarAmount.Value, offeringTaxiYagluthAltarConsumeItem.Value, "Yagluth altar");
			AddBossAltarTaxiOffering(list, offeringTaxiQueenAltarEnabled.Value, offeringTaxiQueenAltarItem.Value.GetItemName(), offeringTaxiQueenAltarAmount.Value, offeringTaxiQueenAltarConsumeItem.Value, "Queen altar");
			AddBossAltarTaxiOffering(list, offeringTaxiFaderAltarEnabled.Value, offeringTaxiFaderAltarItem.Value.GetItemName(), offeringTaxiFaderAltarAmount.Value, offeringTaxiFaderAltarConsumeItem.Value, "Fader altar");
			hasTaxiOffering = list.Count > count;
			return list;
		}

		private static string BuildWardSacrificesCompendiumText(List<string> offeringsList, bool hasTaxiOffering)
		{
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.Append("$pw_ward_offerings_compendium_intro");
			foreach (string offerings in offeringsList)
			{
				stringBuilder.Append("\n\n• ");
				stringBuilder.Append(offerings);
			}
			if (hasTaxiOffering)
			{
				stringBuilder.Append("\n\n");
				stringBuilder.Append((offeringTaxiSecondsToFlyBack.Value > 0) ? "$pw_ward_offerings_taxi_return" : "$pw_ward_offerings_taxi_oneway");
			}
			return stringBuilder.ToString();
		}

		private static bool IsWardToSetRange(PrivateArea ward)
		{
			return IsPlayerWardPrefab(ward);
		}

		private static void CacheWardDefaultRange(PrivateArea ward)
		{
			if (!((Object)(object)ward == (Object)null) && !s_wardDefaultRanges.ContainsKey(ward))
			{
				s_wardDefaultRanges[ward] = ward.m_radius;
			}
		}

		private static void ResetWardRange(PrivateArea ward)
		{
			if (!((Object)(object)ward == (Object)null) && s_wardDefaultRanges.TryGetValue(ward, out var value) && !(Math.Abs(ward.m_radius - value) < 0.001f))
			{
				SetWardRange(ward, value);
				SetWardPlayerBase(ward, value);
			}
		}

		private static void PatchRange(PrivateArea ward)
		{
			if ((Object)(object)ward.m_nview == (Object)null || !ward.m_nview.IsValid() || !IsWardToSetRange(ward))
			{
				return;
			}
			ZDO zDO = ward.m_nview.GetZDO();
			if (zDO == null)
			{
				return;
			}
			if (!WardZdoUtils.UseCustomWardRange(zDO))
			{
				ResetWardRange(ward);
				return;
			}
			float configuredWardRange = WardZdoUtils.GetConfiguredWardRange(zDO);
			if (Math.Abs(ward.m_radius - configuredWardRange) >= 0.001f)
			{
				SetWardRange(ward, configuredWardRange);
				SetWardPlayerBase(ward, configuredWardRange);
			}
		}

		private static GameObject EnsureWardBubble(PrivateArea ward)
		{
			if ((Object)(object)ward == (Object)null)
			{
				return null;
			}
			Transform val = ((Component)ward).transform.Find("ForceField");
			if ((Object)(object)val != (Object)null)
			{
				return ((Component)val).gameObject;
			}
			if ((Object)(object)forceField == (Object)null)
			{
				return null;
			}
			GameObject val2 = Object.Instantiate<GameObject>(forceField, ((Component)ward).transform);
			((Object)val2).name = "ForceField";
			return val2;
		}

		private static GameObject EnsureWardDemister(PrivateArea ward)
		{
			if ((Object)(object)ward == (Object)null)
			{
				return null;
			}
			Transform val = ((Component)ward).transform.Find("Particle System Force Field");
			if ((Object)(object)val != (Object)null)
			{
				return ((Component)val).gameObject;
			}
			if ((Object)(object)forceFieldDemister == (Object)null)
			{
				return null;
			}
			GameObject val2 = Object.Instantiate<GameObject>(forceFieldDemister, ((Component)ward).transform);
			((Object)val2).name = "Particle System Force Field";
			return val2;
		}

		private static IEnumerator DelayedRefreshWardVisuals(PrivateArea ward)
		{
			yield return (object)new WaitForSeconds(1f);
			RefreshWardVisuals(ward);
		}

		private static void RefreshAllLoadedWardVisuals()
		{
			foreach (PrivateArea allArea in PrivateArea.m_allAreas)
			{
				RefreshWardVisuals(allArea);
			}
		}

		public static void RefreshWardVisuals(PrivateArea ward)
		{
			if (IsPlayerWardPrefab(ward) && !((Object)(object)ward.m_nview == (Object)null) && ward.m_nview.IsValid())
			{
				PatchRange(ward);
				InitEmissionColor(ward);
				InitBubbleState(ward, EnsureWardBubble(ward), ward.m_nview);
				InitDemisterState(ward, EnsureWardDemister(ward), ward.m_nview);
				InitCircleProjectorState(ward.m_areaMarker, ward.m_nview);
			}
		}
	}
}
namespace ProtectiveWards.Compatibility
{
	internal static class CompatibilityHelper
	{
		internal static void CheckForCompatibility()
		{
			GuildsCompat.CheckForCompatibility();
			EpicLootCompat.CheckForCompatibility();
		}

		internal static void ResetRuntimeState()
		{
			GuildsCompat.ResetRuntimeState();
		}
	}
	internal static class GuildsCompat
	{
		internal readonly struct GuildIdentity
		{
			internal readonly int Id;

			internal readonly string Name;

			internal bool IsValid => Id > 0 && !string.IsNullOrEmpty(Name);

			internal GuildIdentity(int id, string name)
			{
				Id = id;
				Name = name ?? "";
			}
		}

		internal enum GuildBindingResult
		{
			Success,
			NotAuthorized,
			Unavailable,
			NoGuild,
			TooFar
		}

		private sealed class CachedGuildIdentity
		{
			internal float CachedAt;

			internal bool HasGuild;

			internal GuildIdentity Guild;
		}

		[HarmonyPatch(typeof(ZoneSystem), "Start")]
		private static class ZoneSystem_Start_RegisterGuildCompatibilityRPCs
		{
			private static bool Prepare()
			{
				return IsEnabled;
			}

			private static void Postfix()
			{
				RegisterRPCs();
			}
		}

		[HarmonyPatch(typeof(ZoneSystem), "OnDestroy")]
		private static class ZoneSystem_OnDestroy_ResetGuildCompatibility
		{
			private static bool Prepare()
			{
				return IsEnabled;
			}

			private static void Postfix()
			{
				ResetRuntimeState();
			}
		}

		private const string PluginGuid = "org.bepinex.plugins.guilds";

		private const string ApiTypeName = "Guilds.API";

		private const string PlayerReferenceTypeName = "Guilds.PlayerReference";

		private const string GuildTypeName = "Guilds.Guild";

		private const string GuildGeneralTypeName = "Guilds.GuildGeneral";

		private const string RPC_UpdateGuildBinding = "PW_UpdateGuildBinding";

		private const string RPC_UpdateGuildBindingResult = "PW_UpdateGuildBindingResult";

		private const float PlayerGuildCacheSeconds = 1f;

		internal static readonly int s_guildAccessEnabled = StringExtensionMethods.GetStableHashCode("pw_guild_access_enabled");

		internal static readonly int s_guildId = StringExtensionMethods.GetStableHashCode("pw_guild_id");

		internal static readonly int s_guildName = StringExtensionMethods.GetStableHashCode("pw_guild_name");

		private static PluginInfo s_plugin;

		private static Assembly s_assembly;

		private static Type s_apiType;

		private static Type s_playerReferenceType;

		private static Type s_guildType;

		private static Type s_guildGeneralType;

		private static MethodInfo s_getPlayerGuildByPlayer;

		private static MethodInfo s_getPlayerGuildByReference;

		private static MethodInfo s_playerReferenceFromPlayerInfo;

		private static FieldInfo s_guildNameField;

		private static FieldInfo s_guildGeneralField;

		private static FieldInfo s_guildIdField;

		private static bool s_rpcRegistered;

		private static readonly Dictionary<long, CachedGuildIdentity> s_playerGuildCache = new Dictionary<long, CachedGuildIdentity>();

		internal static bool IsEnabled { get; private set; }

		internal static void CheckForCompatibility()
		{
			IsEnabled = false;
			if (!Chainloader.PluginInfos.TryGetValue("org.bepinex.plugins.guilds", out s_plugin))
			{
				return;
			}
			s_assembly = ((object)s_plugin.Instance).GetType().Assembly;
			s_apiType = s_assembly.GetType("Guilds.API");
			s_playerReferenceType = s_assembly.GetType("Guilds.PlayerReference");
			s_guildType = s_assembly.GetType("Guilds.Guild");
			s_guildGeneralType = s_assembly.GetType("Guilds.GuildGeneral");
			if (s_apiType == null || s_playerReferenceType == null || s_guildType == null || s_guildGeneralType == null)
			{
				ProtectiveWards.LogInfo("Guilds is loaded but the required membership types could not be resolved");
				return;
			}
			s_getPlayerGuildByPlayer = AccessTools.Method(s_apiType, "GetPlayerGuild", new Type[1] { typeof(Player) }, (Type[])null);
			s_getPlayerGuildByReference = s_apiType.GetMethods(BindingFlags.Static | BindingFlags.Public).FirstOrDefault((MethodInfo method) => method.Name == "GetPlayerGuild" && method.GetParameters().Length == 1 && method.GetParameters()[0].ParameterType == s_playerReferenceType);
			s_playerReferenceFromPlayerInfo = AccessTools.Method(s_playerReferenceType, "fromPlayerInfo", new Type[1] { typeof(PlayerInfo) }, (Type[])null);
			s_guildNameField = AccessTools.Field(s_guildType, "Name");
			s_guildGeneralField = AccessTools.Field(s_guildType, "General");
			s_guildIdField = AccessTools.Field(s_guildGeneralType, "id");
			if (s_getPlayerGuildByPlayer == null || s_getPlayerGuildByReference == null || s_playerReferenceFromPlayerInfo == null || s_guildNameField == null || s_guildGeneralField == null || s_guildIdField == null)
			{
				ProtectiveWards.LogInfo("Guilds is loaded but the required membership API could not be resolved");
			}
			else
			{
				IsEnabled = true;
			}
		}

		internal static void ResetRuntimeState()
		{
			s_rpcRegistered = false;
			s_playerGuildCache.Clear();
		}

		internal static bool IsGuildAccessEnabled(ZDO zdo)
		{
			return ProtectiveWards.ArePerWardSettingsEnabled() && zdo != null && zdo.GetBool(s_guildAccessEnabled, false) && HasBoundGuild(zdo);
		}

		internal static bool HasBoundGuild(ZDO zdo)
		{
			return zdo != null && zdo.GetInt(s_guildId, 0) > 0 && !string.IsNullOrEmpty(zdo.GetString(s_guildName, ""));
		}

		internal static int GetBoundGuildId(ZDO zdo)
		{
			return (zdo != null) ? zdo.GetInt(s_guildId, 0) : 0;
		}

		internal static string GetBoundGuildName(ZDO zdo)
		{
			return ((zdo != null) ? zdo.GetString(s_guildName, "") : null) ?? "";
		}

		internal static void SetGuildAccessEnabled(ZDO zdo, bool enabled)
		{
			if (zdo != null)
			{
				zdo.Set(s_guildAccessEnabled, enabled && HasBoundGuild(zdo));
			}
		}

		internal static void SetBoundGuildState(ZDO zdo, bool enabled, int guildId, string guildName)
		{
			if (zdo != null)
			{
				zdo.Set(s_guildId, Math.Max(guildId, 0), false);
				zdo.Set(s_guildName, guildName ?? "");
				zdo.Set(s_guildAccessEnabled, enabled && guildId > 0 && !string.IsNullOrEmpty(guildName));
			}
		}

		internal static bool HasWardGuildAccess(PrivateArea ward, long playerID)
		{
			if (ward != null)
			{
				ZNetView nview = ward.m_nview;
				if (((nview != null) ? new bool?(nview.IsValid()) : ((bool?)null)) == true)
				{
					return HasWardGuildAccess(ward.m_nview.GetZDO(), playerID);
				}
			}
			return false;
		}

		internal static bool HasWardGuildAccess(ZDO zdo, long playerID)
		{
			if (!IsEnabled || playerID == 0L || !IsGuildAccessEnabled(zdo))
			{
				return false;
			}
			if (!TryGetPlayerGuild(playerID, out var guild))
			{
				return false;
			}
			return guild.Id == GetBoundGuildId(zdo) && string.Equals(guild.Name, GetBoundGuildName(zdo), StringComparison.Ordinal);
		}

		internal static bool TryGetPlayerGuild(long playerID, out GuildIdentity guild)
		{
			guild = default(GuildIdentity);
			if (!IsEnabled || playerID == 0)
			{
				return false;
			}
			float realtimeSinceStartup = Time.realtimeSinceStartup;
			if (s_playerGuildCache.TryGetValue(playerID, out var value) && realtimeSinceStartup - value.CachedAt <= 1f)
			{
				guild = value.Guild;
				return value.HasGuild;
			}
			bool flag = TryResolvePlayerGuild(playerID, out guild);
			s_playerGuildCache[playerID] = new CachedGuildIdentity
			{
				CachedAt = realtimeSinceStartup,
				HasGuild = flag,
				Guild = guild
			};
			return flag;
		}

		private static bool TryResolvePlayerGuild(long playerID, out GuildIdentity guild)
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			guild = default(GuildIdentity);
			try
			{
				object obj = null;
				if (ProtectiveWards.TryFindPlayerInfo(playerID, out var playerInfo))
				{
					object obj2 = s_playerReferenceFromPlayerInfo.Invoke(null, new object[1] { playerInfo });
					obj = s_getPlayerGuildByReference.Invoke(null, new object[1] { obj2 });
				}
				if (obj == null)
				{
					Player player = Player.GetPlayer(playerID);
					if ((Object)(object)player != (Object)null)
					{
						obj = s_getPlayerGuildByPlayer.Invoke(null, new object[1] { player });
					}
				}
				return TryReadGuildIdentity(obj, out guild);
			}
			catch (Exception ex)
			{
				ProtectiveWards.LogInfo("Guild membership lookup failed: " + ex.GetType().Name);
				return false;
			}
		}

		private static bool TryReadGuildIdentity(object guildObject, out GuildIdentity guild)
		{
			guild = default(GuildIdentity);
			if (guildObject == null)
			{
				return false;
			}
			object value = s_guildGeneralField.GetValue(guildObject);
			if (value == null)
			{
				return false;
			}
			int id = (int)s_guildIdField.GetValue(value);
			string name = (s_guildNameField.GetValue(guildObject) as string) ?? "";
			guild = new GuildIdentity(id, name);
			return guild.IsValid;
		}

		internal static void RequestBindCurrentGuild(ZDOID wardID)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			RequestGuildBindingUpdate(wardID, bind: true);
		}

		internal static void RequestUnbindGuild(ZDOID wardID)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			RequestGuildBindingUpdate(wardID, bind: false);
		}

		private static void RequestGuildBindingUpdate(ZDOID wardID, bool bind)
		{
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Expected O, but got Unknown
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Expected O, but got Unknown
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			Player localPlayer = Player.m_localPlayer;
			if (!IsEnabled || (Object)(object)localPlayer == (Object)null || ((ZDOID)(ref wardID)).IsNone())
			{
				WardSettingsUI.OnGuildBindingResult(wardID, GuildBindingResult.Unavailable, enabled: false, 0, "");
				return;
			}
			ZPackage val = new ZPackage();
			val.Write(wardID);
			val.Write(localPlayer.GetPlayerID());
			val.Write(bind);
			ZNet instance = ZNet.instance;
			if (instance != null && instance.IsServer())
			{
				RPC_UpdateGuildBindingServer(0L, new ZPackage(val.GetArray()));
			}
			else if (ZRoutedRpc.instance != null)
			{
				ZRoutedRpc.instance.InvokeRoutedRPC("PW_UpdateGuildBinding", new object[1] { val });
			}
			else
			{
				WardSettingsUI.OnGuildBindingResult(wardID, GuildBindingResult.Unavailable, enabled: false, 0, "");
			}
		}

		private static void RegisterRPCs()
		{
			if (IsEnabled && !s_rpcRegistered && ZRoutedRpc.instance != null)
			{
				ZRoutedRpc.instance.Register<ZPackage>("PW_UpdateGuildBindingResult", (Action<long, ZPackage>)RPC_UpdateGuildBindingResultClient);
				ZNet instance = ZNet.instance;
				if (instance != null && instance.IsServer())
				{
					ZRoutedRpc.instance.Register<ZPackage>("PW_UpdateGuildBinding", (Action<long, ZPackage>)RPC_UpdateGuildBindingServer);
				}
				s_rpcRegistered = true;
			}
		}

		private static void RPC_UpdateGuildBindingServer(long sender, ZPackage package)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: 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_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			ZDOID val = package.ReadZDOID();
			long claimedPlayerID = package.ReadLong();
			bool flag = package.ReadBool();
			if (!ProtectiveWards.TryGetRoutedPlayer(sender, claimedPlayerID, out var player))
			{
				return;
			}
			if (!WardZdoUtils.TryGetWard(val, out var zdo))
			{
				SendGuildBindingResult(sender, val, GuildBindingResult.Unavailable, null);
				return;
			}
			if (!ProtectiveWards.CanApplyWardSettings(zdo, player.PlayerID))
			{
				SendGuildBindingResult(sender, val, GuildBindingResult.NotAuthorized, zdo);
				return;
			}
			if (flag)
			{
				s_playerGuildCache.Remove(player.PlayerID);
				if (!TryGetPlayerGuild(player.PlayerID, out var guild))
				{
					SendGuildBindingResult(sender, val, GuildBindingResult.NoGuild, zdo);
					return;
				}
				SetBoundGuildState(zdo, enabled: true, guild.Id, guild.Name);
				ProtectiveWards.LogInfo($"Bound ward {val} to guild {guild.Name} ({guild.Id})");
			}
			else
			{
				SetBoundGuildState(zdo, enabled: false, 0, "");
				ProtectiveWards.LogInfo($"Removed guild binding from ward {val}");
			}
			SendGuildBindingResult(sender, val, GuildBindingResult.Success, zdo);
		}

		private static void SendGuildBindingResult(long peerID, ZDOID wardID, GuildBindingResult result, ZDO zdo)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Expected O, but got Unknown
			ZPackage val = new ZPackage();
			val.Write(wardID);
			val.Write((int)result);
			val.Write(zdo != null && zdo.GetBool(s_guildAccessEnabled, false));
			val.Write(GetBoundGuildId(zdo));
			val.Write(GetBoundGuildName(zdo));
			ZNet instance = ZNet.instance;
			if (instance != null && instance.IsServer() && ZRoutedRpc.instance != null && peerID != 0)
			{
				ZRoutedRpc.instance.InvokeRoutedRPC(peerID, "PW_UpdateGuildBindingResult", new object[1] { val });
			}
			else
			{
				RPC_UpdateGuildBindingResultClient(0L, new ZPackage(val.GetArray()));
			}
		}

		private static void RPC_UpdateGuildBindingResultClient(long _, ZPackage package)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			ZDOID val = package.ReadZDOID();
			GuildBindingResult result = (GuildBindingResult)package.ReadInt();
			bool enabled = package.ReadBool();
			int guildId = package.ReadInt();
			string guildName = package.ReadString() ?? "";
			ZDOMan instance = ZDOMan.instance;
			ZDO val2 = ((instance != null) ? instance.GetZDO(val) : null);
			if (val2 != null)
			{
				SetBoundGuildState(val2, enabled, guildId, guildName);
			}
			WardSettingsUI.OnGuildBindingResult(val, result, enabled, guildId, guildName);
		}
	}
	internal static class EpicLootCompat
	{
		[HarmonyPatch]
		private static class EnchantingTable_Interact_PreventUnauthorizedCraftingStationAccess
		{
			private static bool Prepare(MethodBase original)
			{
				if (!IsEnabled || s_enchantingTableInteract == null)
				{
					return false;
				}
				if (original == null)
				{
					ProtectiveWards.LogInfo("EpicLoot_UnityLib.EnchantingTable.Interact is patched as a crafting station");
				}
				return true;
			}

			private static MethodBase TargetMethod()
			{
				return s_enchantingTableInteract;
			}

			[HarmonyPriority(800)]
			private static bool Prefix(object __instance, Humanoid user, ref bool __result)
			{
				if (!ProtectiveWards.wardAccessProtectCraftingStations.Value)
				{
					return true;
				}
				Component val = (Component)((__instance is Component) ? __instance : null);
				if (val == null)
				{
					return true;
				}
				if (!FullProtection.BlockProtectedInteraction(val, user, ref __result))
				{
					return true;
				}
				return false;
			}
		}

		internal const string PluginGuid = "randyknapp.mods.epicloot";

		private const string UnityLibAssemblyName = "EpicLoot-UnityLib";

		private const string EnchantingTableTypeName = "EpicLoot_UnityLib.EnchantingTable";

		private static MethodInfo s_enchantingTableInteract;

		internal static bool IsEnabled { get; private set; }

		internal static void CheckForCompatibility()
		{
			IsEnabled = false;
			if (!Chainloader.PluginInfos.ContainsKey("randyknapp.mods.epicloot"))
			{
				return;
			}
			Assembly assembly = AppDomain.CurrentDomain.GetAssemblies().FirstOrDefault((Assembly assembly2) => string.Equals(assembly2.GetName().Name, "EpicLoot-UnityLib", StringComparison.OrdinalIgnoreCase));
			if (assembly == null)
			{
				ProtectiveWards.LogInfo("EpicLoot is loaded but assembly EpicLoot-UnityLib was not found");
				return;
			}
			Type type = assembly.GetType("EpicLoot_UnityLib.EnchantingTable", throwOnError: false, ignoreCase: false);
			if (type == null)
			{
				ProtectiveWards.LogInfo("EpicLoot assembly EpicLoot-UnityLib is loaded but EpicLoot_UnityLib.EnchantingTable was not found");
				return;
			}
			s_enchantingTableInteract = AccessTools.Method(type, "Interact", new Type[3]
			{
				typeof(Humanoid),
				typeof(bool),
				typeof(bool)
			}, (Type[])null);
			if (s_enchantingTableInteract == null)
			{
				ProtectiveWards.LogInfo("EpicLoot is loaded but EpicLoot_UnityLib.EnchantingTable.Interact(Humanoid, bool, bool) was not found");
				return;
			}
			FullProtection.ExcludeInteractableType(type);
			IsEnabled = true;
		}
	}
}