using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.IO.Compression;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Serialization;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Cryptography;
using System.Security.Permissions;
using System.Text;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using GUIFramework;
using GuildStructures.Compat;
using GuildStructures.Config;
using GuildStructures.Guilds;
using GuildStructures.Ownership;
using GuildStructures.Patches;
using GuildStructures.Storage;
using GuildStructures.Sync;
using GuildStructures.Util;
using Guilds;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using ServerSync;
using TMPro;
using UnityEngine;
using UnityEngine.Events;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

		public NullableAttribute(byte P_0)
		{
			NullableFlags = new byte[1] { P_0 };
		}

		public NullableAttribute(byte[] P_0)
		{
			NullableFlags = P_0;
		}
	}
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableContextAttribute : Attribute
	{
		public readonly byte Flag;

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace ServerSync
{
	public abstract class OwnConfigEntryBase
	{
		public object? LocalBaseValue;

		public bool SynchronizedConfig = true;

		public abstract ConfigEntryBase BaseConfig { get; }
	}
	public class SyncedConfigEntry<T>(ConfigEntry<T> sourceConfig) : OwnConfigEntryBase()
	{
		public readonly ConfigEntry<T> SourceConfig = sourceConfig;

		public override ConfigEntryBase BaseConfig => (ConfigEntryBase)(object)SourceConfig;

		public T Value
		{
			get
			{
				return SourceConfig.Value;
			}
			set
			{
				SourceConfig.Value = value;
			}
		}

		public void AssignLocalValue(T value)
		{
			if (LocalBaseValue == null)
			{
				Value = value;
			}
			else
			{
				LocalBaseValue = value;
			}
		}
	}
	public abstract class CustomSyncedValueBase
	{
		public object? LocalBaseValue;

		public readonly string Identifier;

		public readonly Type Type;

		private object? boxedValue;

		protected bool localIsOwner;

		public readonly int Priority;

		public object? BoxedValue
		{
			get
			{
				return boxedValue;
			}
			set
			{
				boxedValue = value;
				this.ValueChanged?.Invoke();
			}
		}

		public event Action? ValueChanged;

		protected CustomSyncedValueBase(ConfigSync configSync, string identifier, Type type, int priority)
		{
			Priority = priority;
			Identifier = identifier;
			Type = type;
			configSync.AddCustomValue(this);
			localIsOwner = configSync.IsSourceOfTruth;
			configSync.SourceOfTruthChanged += delegate(bool truth)
			{
				localIsOwner = truth;
			};
		}
	}
	public sealed class CustomSyncedValue<T> : CustomSyncedValueBase
	{
		public T Value
		{
			get
			{
				return (T)base.BoxedValue;
			}
			set
			{
				base.BoxedValue = value;
			}
		}

		public CustomSyncedValue(ConfigSync configSync, string identifier, T value = default(T), int priority = 0)
			: base(configSync, identifier, typeof(T), priority)
		{
			Value = value;
		}

		public void AssignLocalValue(T value)
		{
			if (localIsOwner)
			{
				Value = value;
			}
			else
			{
				LocalBaseValue = value;
			}
		}
	}
	internal class ConfigurationManagerAttributes
	{
		public bool? ReadOnly = false;
	}
	public class ConfigSync
	{
		[HarmonyPatch(typeof(ZRpc), "HandlePackage")]
		private static class SnatchCurrentlyHandlingRPC
		{
			public static ZRpc? currentRpc;

			[HarmonyPrefix]
			private static void Prefix(ZRpc __instance)
			{
				currentRpc = __instance;
			}
		}

		[HarmonyPatch(typeof(ZNet), "Awake")]
		internal static class RegisterRPCPatch
		{
			[HarmonyPostfix]
			private static void Postfix(ZNet __instance)
			{
				isServer = __instance.IsServer();
				foreach (ConfigSync configSync2 in configSyncs)
				{
					ZRoutedRpc.instance.Register<ZPackage>(configSync2.Name + " ConfigSync", (Action<long, ZPackage>)configSync2.RPC_FromOtherClientConfigSync);
					if (isServer)
					{
						configSync2.InitialSyncDone = true;
						Debug.Log((object)("Registered '" + configSync2.Name + " ConfigSync' RPC - waiting for incoming connections"));
					}
				}
				if (isServer)
				{
					((MonoBehaviour)__instance).StartCoroutine(WatchAdminListChanges());
				}
				static void SendAdmin(List<ZNetPeer> peers, bool isAdmin)
				{
					ZPackage package = ConfigsToPackage(null, null, new PackageEntry[1]
					{
						new PackageEntry
						{
							section = "Internal",
							key = "lockexempt",
							type = typeof(bool),
							value = isAdmin
						}
					});
					ConfigSync configSync = configSyncs.First();
					if (configSync != null)
					{
						((MonoBehaviour)ZNet.instance).StartCoroutine(configSync.sendZPackage(peers, package));
					}
				}
				static IEnumerator WatchAdminListChanges()
				{
					MethodInfo listContainsId = AccessTools.DeclaredMethod(typeof(ZNet), "ListContainsId", (Type[])null, (Type[])null);
					SyncedList adminList = (SyncedList)AccessTools.DeclaredField(typeof(ZNet), "m_adminList").GetValue(ZNet.instance);
					List<string> CurrentList = new List<string>(adminList.GetList());
					while (true)
					{
						yield return (object)new WaitForSeconds(30f);
						if (!adminList.GetList().SequenceEqual(CurrentList))
						{
							CurrentList = new List<string>(adminList.GetList());
							List<ZNetPeer> list = ZNet.instance.GetPeers().Where(delegate(ZNetPeer p)
							{
								string hostName = p.m_rpc.GetSocket().GetHostName();
								return ((object)listContainsId != null) ? ((bool)listContainsId.Invoke(ZNet.instance, new object[2] { adminList, hostName })) : adminList.Contains(hostName);
							}).ToList();
							SendAdmin(ZNet.instance.GetPeers().Except(list).ToList(), isAdmin: false);
							SendAdmin(list, isAdmin: true);
						}
					}
				}
			}
		}

		[HarmonyPatch(typeof(ZNet), "OnNewConnection")]
		private static class RegisterClientRPCPatch
		{
			[HarmonyPostfix]
			private static void Postfix(ZNet __instance, ZNetPeer peer)
			{
				if (__instance.IsServer())
				{
					return;
				}
				foreach (ConfigSync configSync in configSyncs)
				{
					peer.m_rpc.Register<ZPackage>(configSync.Name + " ConfigSync", (Action<ZRpc, ZPackage>)configSync.RPC_FromServerConfigSync);
				}
			}
		}

		private class ParsedConfigs
		{
			public readonly Dictionary<OwnConfigEntryBase, object?> configValues = new Dictionary<OwnConfigEntryBase, object>();

			public readonly Dictionary<CustomSyncedValueBase, object?> customValues = new Dictionary<CustomSyncedValueBase, object>();
		}

		[HarmonyPatch(typeof(ZNet), "Shutdown")]
		private class ResetConfigsOnShutdown
		{
			[HarmonyPostfix]
			private static void Postfix()
			{
				ProcessingServerUpdate = true;
				foreach (ConfigSync configSync in configSyncs)
				{
					configSync.resetConfigsFromServer();
					configSync.IsSourceOfTruth = true;
					configSync.InitialSyncDone = false;
				}
				ProcessingServerUpdate = false;
			}
		}

		[HarmonyPatch(typeof(ZNet), "RPC_PeerInfo")]
		private class SendConfigsAfterLogin
		{
			private class BufferingSocket : ZPlayFabSocket, ISocket
			{
				public volatile bool finished;

				public volatile int versionMatchQueued = -1;

				public readonly List<ZPackage> Package = new List<ZPackage>();

				public readonly ISocket Original;

				public BufferingSocket(ISocket original)
				{
					Original = original;
					((ZPlayFabSocket)this)..ctor();
				}

				public bool IsConnected()
				{
					return Original.IsConnected();
				}

				public ZPackage Recv()
				{
					return Original.Recv();
				}

				public int GetSendQueueSize()
				{
					return Original.GetSendQueueSize();
				}

				public int GetCurrentSendRate()
				{
					return Original.GetCurrentSendRate();
				}

				public bool IsHost()
				{
					return Original.IsHost();
				}

				public void Dispose()
				{
					Original.Dispose();
				}

				public bool GotNewData()
				{
					return Original.GotNewData();
				}

				public void Close()
				{
					Original.Close();
				}

				public string GetEndPointString()
				{
					return Original.GetEndPointString();
				}

				public void GetAndResetStats(out int totalSent, out int totalRecv)
				{
					Original.GetAndResetStats(ref totalSent, ref totalRecv);
				}

				public void GetConnectionQuality(out float localQuality, out float remoteQuality, out int ping, out float outByteSec, out float inByteSec)
				{
					Original.GetConnectionQuality(ref localQuality, ref remoteQuality, ref ping, ref outByteSec, ref inByteSec);
				}

				public ISocket Accept()
				{
					return Original.Accept();
				}

				public int GetHostPort()
				{
					return Original.GetHostPort();
				}

				public bool Flush()
				{
					return Original.Flush();
				}

				public string GetHostName()
				{
					return Original.GetHostName();
				}

				public void VersionMatch()
				{
					if (finished)
					{
						Original.VersionMatch();
					}
					else
					{
						versionMatchQueued = Package.Count;
					}
				}

				public void Send(ZPackage pkg)
				{
					//IL_004c: Unknown result type (might be due to invalid IL or missing references)
					//IL_0052: Expected O, but got Unknown
					int pos = pkg.GetPos();
					pkg.SetPos(0);
					int num = pkg.ReadInt();
					if ((num == StringExtensionMethods.GetStableHashCode("PeerInfo") || num == StringExtensionMethods.GetStableHashCode("RoutedRPC") || num == StringExtensionMethods.GetStableHashCode("ZDOData")) && !finished)
					{
						ZPackage val = new ZPackage(pkg.GetArray());
						val.SetPos(pos);
						Package.Add(val);
					}
					else
					{
						pkg.SetPos(pos);
						Original.Send(pkg);
					}
				}
			}

			[HarmonyPriority(800)]
			[HarmonyPrefix]
			private static void Prefix(ref Dictionary<Assembly, BufferingSocket>? __state, ZNet __instance, ZRpc rpc)
			{
				//IL_0073: Unknown result type (might be due to invalid IL or missing references)
				if (!__instance.IsServer())
				{
					return;
				}
				BufferingSocket bufferingSocket = new BufferingSocket(rpc.GetSocket());
				AccessTools.DeclaredField(typeof(ZRpc), "m_socket").SetValue(rpc, bufferingSocket);
				object? obj = AccessTools.DeclaredMethod(typeof(ZNet), "GetPeer", new Type[1] { typeof(ZRpc) }, (Type[])null).Invoke(__instance, new object[1] { rpc });
				ZNetPeer val = (ZNetPeer)((obj is ZNetPeer) ? obj : null);
				if (val != null && (int)ZNet.m_onlineBackend != 0)
				{
					FieldInfo fieldInfo = AccessTools.DeclaredField(typeof(ZNetPeer), "m_socket");
					object? value = fieldInfo.GetValue(val);
					ZPlayFabSocket val2 = (ZPlayFabSocket)((value is ZPlayFabSocket) ? value : null);
					if (val2 != null)
					{
						typeof(ZPlayFabSocket).GetField("m_remotePlayerId").SetValue(bufferingSocket, val2.m_remotePlayerId);
					}
					fieldInfo.SetValue(val, bufferingSocket);
				}
				if (__state == null)
				{
					__state = new Dictionary<Assembly, BufferingSocket>();
				}
				__state[Assembly.GetExecutingAssembly()] = bufferingSocket;
			}

			[HarmonyPostfix]
			private static void Postfix(Dictionary<Assembly, BufferingSocket> __state, ZNet __instance, ZRpc rpc)
			{
				ZNetPeer peer;
				if (__instance.IsServer())
				{
					object obj = AccessTools.DeclaredMethod(typeof(ZNet), "GetPeer", new Type[1] { typeof(ZRpc) }, (Type[])null).Invoke(__instance, new object[1] { rpc });
					peer = (ZNetPeer)((obj is ZNetPeer) ? obj : null);
					if (peer == null)
					{
						SendBufferedData();
					}
					else
					{
						((MonoBehaviour)__instance).StartCoroutine(sendAsync());
					}
				}
				void SendBufferedData()
				{
					if (rpc.GetSocket() is BufferingSocket bufferingSocket)
					{
						AccessTools.DeclaredField(typeof(ZRpc), "m_socket").SetValue(rpc, bufferingSocket.Original);
						object? obj2 = AccessTools.DeclaredMethod(typeof(ZNet), "GetPeer", new Type[1] { typeof(ZRpc) }, (Type[])null).Invoke(__instance, new object[1] { rpc });
						ZNetPeer val = (ZNetPeer)((obj2 is ZNetPeer) ? obj2 : null);
						if (val != null)
						{
							AccessTools.DeclaredField(typeof(ZNetPeer), "m_socket").SetValue(val, bufferingSocket.Original);
						}
					}
					BufferingSocket bufferingSocket2 = __state[Assembly.GetExecutingAssembly()];
					bufferingSocket2.finished = true;
					for (int i = 0; i < bufferingSocket2.Package.Count; i++)
					{
						if (i == bufferingSocket2.versionMatchQueued)
						{
							bufferingSocket2.Original.VersionMatch();
						}
						bufferingSocket2.Original.Send(bufferingSocket2.Package[i]);
					}
					if (bufferingSocket2.Package.Count == bufferingSocket2.versionMatchQueued)
					{
						bufferingSocket2.Original.VersionMatch();
					}
				}
				IEnumerator sendAsync()
				{
					foreach (ConfigSync configSync in configSyncs)
					{
						List<PackageEntry> list = new List<PackageEntry>();
						if (configSync.CurrentVersion != null)
						{
							list.Add(new PackageEntry
							{
								section = "Internal",
								key = "serverversion",
								type = typeof(string),
								value = configSync.CurrentVersion
							});
						}
						MethodInfo methodInfo = AccessTools.DeclaredMethod(typeof(ZNet), "ListContainsId", (Type[])null, (Type[])null);
						SyncedList val = (SyncedList)AccessTools.DeclaredField(typeof(ZNet), "m_adminList").GetValue(ZNet.instance);
						list.Add(new PackageEntry
						{
							section = "Internal",
							key = "lockexempt",
							type = typeof(bool),
							value = (((object)methodInfo == null) ? ((object)val.Contains(rpc.GetSocket().GetHostName())) : methodInfo.Invoke(ZNet.instance, new object[2]
							{
								val,
								rpc.GetSocket().GetHostName()
							}))
						});
						ZPackage package = ConfigsToPackage(configSync.allConfigs.Select((OwnConfigEntryBase c) => c.BaseConfig), configSync.allCustomValues, list, partial: false);
						yield return ((MonoBehaviour)__instance).StartCoroutine(configSync.sendZPackage(new List<ZNetPeer> { peer }, package));
					}
					SendBufferedData();
				}
			}
		}

		private class PackageEntry
		{
			public string section;

			public string key;

			public Type type;

			public object? value;
		}

		[HarmonyPatch(typeof(ConfigEntryBase), "GetSerializedValue")]
		private static class PreventSavingServerInfo
		{
			[HarmonyPrefix]
			private static bool Prefix(ConfigEntryBase __instance, ref string __result)
			{
				OwnConfigEntryBase ownConfigEntryBase = configData(__instance);
				if (ownConfigEntryBase == null || isWritableConfig(ownConfigEntryBase))
				{
					return true;
				}
				__result = TomlTypeConverter.ConvertToString(ownConfigEntryBase.LocalBaseValue, __instance.SettingType);
				return false;
			}
		}

		[HarmonyPatch(typeof(ConfigEntryBase), "SetSerializedValue")]
		private static class PreventConfigRereadChangingValues
		{
			[HarmonyPrefix]
			private static bool Prefix(ConfigEntryBase __instance, string value)
			{
				OwnConfigEntryBase ownConfigEntryBase = configData(__instance);
				if (ownConfigEntryBase == null || ownConfigEntryBase.LocalBaseValue == null)
				{
					return true;
				}
				try
				{
					ownConfigEntryBase.LocalBaseValue = TomlTypeConverter.ConvertToValue(value, __instance.SettingType);
				}
				catch (Exception ex)
				{
					Debug.LogWarning((object)$"Config value of setting \"{__instance.Definition}\" could not be parsed and will be ignored. Reason: {ex.Message}; Value: {value}");
				}
				return false;
			}
		}

		private class InvalidDeserializationTypeException : Exception
		{
			public string expected;

			public string received;

			public string field = "";
		}

		public static bool ProcessingServerUpdate;

		public readonly string Name;

		public string? DisplayName;

		public string? CurrentVersion;

		public string? MinimumRequiredVersion;

		public bool ModRequired;

		private bool? forceConfigLocking;

		private bool isSourceOfTruth = true;

		private static readonly HashSet<ConfigSync> configSyncs;

		private readonly HashSet<OwnConfigEntryBase> allConfigs = new HashSet<OwnConfigEntryBase>();

		private HashSet<CustomSyncedValueBase> allCustomValues = new HashSet<CustomSyncedValueBase>();

		private static bool isServer;

		private static bool lockExempt;

		private OwnConfigEntryBase? lockedConfig;

		private const byte PARTIAL_CONFIGS = 1;

		private const byte FRAGMENTED_CONFIG = 2;

		private const byte COMPRESSED_CONFIG = 4;

		private readonly Dictionary<string, SortedDictionary<int, byte[]>> configValueCache = new Dictionary<string, SortedDictionary<int, byte[]>>();

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

		private static long packageCounter;

		public bool IsLocked
		{
			get
			{
				bool? flag = forceConfigLocking;
				bool num;
				if (!flag.HasValue)
				{
					if (lockedConfig == null)
					{
						goto IL_0051;
					}
					num = ((IConvertible)lockedConfig.BaseConfig.BoxedValue).ToInt32(CultureInfo.InvariantCulture) != 0;
				}
				else
				{
					num = flag == true;
				}
				if (num)
				{
					return !lockExempt;
				}
				goto IL_0051;
				IL_0051:
				return false;
			}
			set
			{
				forceConfigLocking = value;
			}
		}

		public bool IsAdmin
		{
			get
			{
				if (!lockExempt)
				{
					return isSourceOfTruth;
				}
				return true;
			}
		}

		public bool IsSourceOfTruth
		{
			get
			{
				return isSourceOfTruth;
			}
			private set
			{
				if (value != isSourceOfTruth)
				{
					isSourceOfTruth = value;
					this.SourceOfTruthChanged?.Invoke(value);
				}
			}
		}

		public bool InitialSyncDone { get; private set; }

		public event Action<bool>? SourceOfTruthChanged;

		private event Action? lockedConfigChanged;

		static ConfigSync()
		{
			ProcessingServerUpdate = false;
			configSyncs = new HashSet<ConfigSync>();
			lockExempt = false;
			packageCounter = 0L;
			RuntimeHelpers.RunClassConstructor(typeof(VersionCheck).TypeHandle);
		}

		public ConfigSync(string name)
		{
			Name = name;
			configSyncs.Add(this);
			new VersionCheck(this);
		}

		public SyncedConfigEntry<T> AddConfigEntry<T>(ConfigEntry<T> configEntry)
		{
			OwnConfigEntryBase ownConfigEntryBase = configData((ConfigEntryBase)(object)configEntry);
			SyncedConfigEntry<T> syncedEntry = ownConfigEntryBase as SyncedConfigEntry<T>;
			if (syncedEntry == null)
			{
				syncedEntry = new SyncedConfigEntry<T>(configEntry);
				AccessTools.DeclaredField(typeof(ConfigDescription), "<Tags>k__BackingField").SetValue(((ConfigEntryBase)configEntry).Description, new object[1]
				{
					new ConfigurationManagerAttributes()
				}.Concat(((ConfigEntryBase)configEntry).Description.Tags ?? Array.Empty<object>()).Concat(new SyncedConfigEntry<T>[1] { syncedEntry }).ToArray());
				configEntry.SettingChanged += delegate
				{
					if (!ProcessingServerUpdate && syncedEntry.SynchronizedConfig)
					{
						Broadcast(ZRoutedRpc.Everybody, (ConfigEntryBase)configEntry);
					}
				};
				allConfigs.Add(syncedEntry);
			}
			return syncedEntry;
		}

		public SyncedConfigEntry<T> AddLockingConfigEntry<T>(ConfigEntry<T> lockingConfig) where T : IConvertible
		{
			if (lockedConfig != null)
			{
				throw new Exception("Cannot initialize locking ConfigEntry twice");
			}
			lockedConfig = AddConfigEntry<T>(lockingConfig);
			lockingConfig.SettingChanged += delegate
			{
				this.lockedConfigChanged?.Invoke();
			};
			return (SyncedConfigEntry<T>)lockedConfig;
		}

		internal void AddCustomValue(CustomSyncedValueBase customValue)
		{
			if (allCustomValues.Select((CustomSyncedValueBase v) => v.Identifier).Concat(new string[1] { "serverversion" }).Contains(customValue.Identifier))
			{
				throw new Exception("Cannot have multiple settings with the same name or with a reserved name (serverversion)");
			}
			allCustomValues.Add(customValue);
			allCustomValues = new HashSet<CustomSyncedValueBase>(allCustomValues.OrderByDescending((CustomSyncedValueBase v) => v.Priority));
			customValue.ValueChanged += delegate
			{
				if (!ProcessingServerUpdate)
				{
					Broadcast(ZRoutedRpc.Everybody, customValue);
				}
			};
		}

		private void RPC_FromServerConfigSync(ZRpc rpc, ZPackage package)
		{
			lockedConfigChanged += serverLockedSettingChanged;
			IsSourceOfTruth = false;
			if (HandleConfigSyncRPC(0L, package, clientUpdate: false))
			{
				InitialSyncDone = true;
			}
		}

		private void RPC_FromOtherClientConfigSync(long sender, ZPackage package)
		{
			HandleConfigSyncRPC(sender, package, clientUpdate: true);
		}

		private bool HandleConfigSyncRPC(long sender, ZPackage package, bool clientUpdate)
		{
			//IL_0209: Unknown result type (might be due to invalid IL or missing references)
			//IL_0210: Expected O, but got Unknown
			//IL_01b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bf: Expected O, but got Unknown
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Expected O, but got Unknown
			try
			{
				if (isServer && IsLocked)
				{
					ZRpc? currentRpc = SnatchCurrentlyHandlingRPC.currentRpc;
					object obj;
					if (currentRpc == null)
					{
						obj = null;
					}
					else
					{
						ISocket socket = currentRpc.GetSocket();
						obj = ((socket != null) ? socket.GetHostName() : null);
					}
					string text = (string)obj;
					if (text != null)
					{
						MethodInfo methodInfo = AccessTools.DeclaredMethod(typeof(ZNet), "ListContainsId", (Type[])null, (Type[])null);
						SyncedList val = (SyncedList)AccessTools.DeclaredField(typeof(ZNet), "m_adminList").GetValue(ZNet.instance);
						if (!(((object)methodInfo == null) ? val.Contains(text) : ((bool)methodInfo.Invoke(ZNet.instance, new object[2] { val, text }))))
						{
							return false;
						}
					}
				}
				cacheExpirations.RemoveAll(delegate(KeyValuePair<long, string> kv)
				{
					if (kv.Key < DateTimeOffset.Now.Ticks)
					{
						configValueCache.Remove(kv.Value);
						return true;
					}
					return false;
				});
				byte b = package.ReadByte();
				if ((b & 2) != 0)
				{
					long num = package.ReadLong();
					string text2 = sender.ToString() + num;
					if (!configValueCache.TryGetValue(text2, out var value))
					{
						value = new SortedDictionary<int, byte[]>();
						configValueCache[text2] = value;
						cacheExpirations.Add(new KeyValuePair<long, string>(DateTimeOffset.Now.AddSeconds(60.0).Ticks, text2));
					}
					int key = package.ReadInt();
					int num2 = package.ReadInt();
					value.Add(key, package.ReadByteArray());
					if (value.Count < num2)
					{
						return false;
					}
					configValueCache.Remove(text2);
					package = new ZPackage(value.Values.SelectMany((byte[] a) => a).ToArray());
					b = package.ReadByte();
				}
				ProcessingServerUpdate = true;
				if ((b & 4) != 0)
				{
					MemoryStream stream = new MemoryStream(package.ReadByteArray());
					MemoryStream memoryStream = new MemoryStream();
					using (DeflateStream deflateStream = new DeflateStream(stream, CompressionMode.Decompress))
					{
						deflateStream.CopyTo(memoryStream);
					}
					package = new ZPackage(memoryStream.ToArray());
					b = package.ReadByte();
				}
				if ((b & 1) == 0)
				{
					resetConfigsFromServer();
				}
				ParsedConfigs parsedConfigs = ReadConfigsFromPackage(package);
				ConfigFile val2 = null;
				bool saveOnConfigSet = false;
				foreach (KeyValuePair<OwnConfigEntryBase, object> configValue in parsedConfigs.configValues)
				{
					if (!isServer && configValue.Key.LocalBaseValue == null)
					{
						configValue.Key.LocalBaseValue = configValue.Key.BaseConfig.BoxedValue;
					}
					if (val2 == null)
					{
						val2 = configValue.Key.BaseConfig.ConfigFile;
						saveOnConfigSet = val2.SaveOnConfigSet;
						val2.SaveOnConfigSet = false;
					}
					configValue.Key.BaseConfig.BoxedValue = configValue.Value;
				}
				if (val2 != null)
				{
					val2.SaveOnConfigSet = saveOnConfigSet;
					val2.Save();
				}
				foreach (KeyValuePair<CustomSyncedValueBase, object> customValue in parsedConfigs.customValues)
				{
					if (!isServer)
					{
						CustomSyncedValueBase key2 = customValue.Key;
						if (key2.LocalBaseValue == null)
						{
							key2.LocalBaseValue = customValue.Key.BoxedValue;
						}
					}
					customValue.Key.BoxedValue = customValue.Value;
				}
				Debug.Log((object)string.Format("Received {0} configs and {1} custom values from {2} for mod {3}", parsedConfigs.configValues.Count, parsedConfigs.customValues.Count, (isServer || clientUpdate) ? $"client {sender}" : "the server", DisplayName ?? Name));
				if (!isServer)
				{
					serverLockedSettingChanged();
				}
				return true;
			}
			finally
			{
				ProcessingServerUpdate = false;
			}
		}

		private ParsedConfigs ReadConfigsFromPackage(ZPackage package)
		{
			ParsedConfigs parsedConfigs = new ParsedConfigs();
			Dictionary<string, OwnConfigEntryBase> dictionary = allConfigs.Where((OwnConfigEntryBase c) => c.SynchronizedConfig).ToDictionary((OwnConfigEntryBase c) => c.BaseConfig.Definition.Section + "_" + c.BaseConfig.Definition.Key, (OwnConfigEntryBase c) => c);
			Dictionary<string, CustomSyncedValueBase> dictionary2 = allCustomValues.ToDictionary((CustomSyncedValueBase c) => c.Identifier, (CustomSyncedValueBase c) => c);
			int num = package.ReadInt();
			for (int num2 = 0; num2 < num; num2++)
			{
				string text = package.ReadString();
				string text2 = package.ReadString();
				string text3 = package.ReadString();
				Type type = Type.GetType(text3);
				if (text3 == "" || type != null)
				{
					object obj;
					try
					{
						obj = ((text3 == "") ? null : ReadValueWithTypeFromZPackage(package, type));
					}
					catch (InvalidDeserializationTypeException ex)
					{
						Debug.LogWarning((object)("Got unexpected struct internal type " + ex.received + " for field " + ex.field + " struct " + text3 + " for " + text2 + " in section " + text + " for mod " + (DisplayName ?? Name) + ", expecting " + ex.expected));
						continue;
					}
					OwnConfigEntryBase value2;
					if (text == "Internal")
					{
						CustomSyncedValueBase value;
						if (text2 == "serverversion")
						{
							if (obj?.ToString() != CurrentVersion)
							{
								Debug.LogWarning((object)("Received server version is not equal: server version = " + (obj?.ToString() ?? "null") + "; local version = " + (CurrentVersion ?? "unknown")));
							}
						}
						else if (text2 == "lockexempt")
						{
							if (obj is bool flag)
							{
								lockExempt = flag;
							}
						}
						else if (dictionary2.TryGetValue(text2, out value))
						{
							if ((text3 == "" && (!value.Type.IsValueType || Nullable.GetUnderlyingType(value.Type) != null)) || GetZPackageTypeString(value.Type) == text3)
							{
								parsedConfigs.customValues[value] = obj;
								continue;
							}
							Debug.LogWarning((object)("Got unexpected type " + text3 + " for internal value " + text2 + " for mod " + (DisplayName ?? Name) + ", expecting " + value.Type.AssemblyQualifiedName));
						}
					}
					else if (dictionary.TryGetValue(text + "_" + text2, out value2))
					{
						Type type2 = configType(value2.BaseConfig);
						if ((text3 == "" && (!type2.IsValueType || Nullable.GetUnderlyingType(type2) != null)) || GetZPackageTypeString(type2) == text3)
						{
							parsedConfigs.configValues[value2] = obj;
							continue;
						}
						Debug.LogWarning((object)("Got unexpected type " + text3 + " for " + text2 + " in section " + text + " for mod " + (DisplayName ?? Name) + ", expecting " + type2.AssemblyQualifiedName));
					}
					else
					{
						Debug.LogWarning((object)("Received unknown config entry " + text2 + " in section " + text + " for mod " + (DisplayName ?? Name) + ". This may happen if client and server versions of the mod do not match."));
					}
					continue;
				}
				Debug.LogWarning((object)("Got invalid type " + text3 + ", abort reading of received configs"));
				return new ParsedConfigs();
			}
			return parsedConfigs;
		}

		private static bool isWritableConfig(OwnConfigEntryBase config)
		{
			ConfigSync configSync = configSyncs.FirstOrDefault((ConfigSync cs) => cs.allConfigs.Contains(config));
			if (configSync == null)
			{
				return true;
			}
			if (!configSync.IsSourceOfTruth && config.SynchronizedConfig && config.LocalBaseValue != null)
			{
				if (!configSync.IsLocked)
				{
					if (config == configSync.lockedConfig)
					{
						return lockExempt;
					}
					return true;
				}
				return false;
			}
			return true;
		}

		private void serverLockedSettingChanged()
		{
			foreach (OwnConfigEntryBase allConfig in allConfigs)
			{
				configAttribute<ConfigurationManagerAttributes>(allConfig.BaseConfig).ReadOnly = !isWritableConfig(allConfig);
			}
		}

		private void resetConfigsFromServer()
		{
			ConfigFile val = null;
			bool saveOnConfigSet = false;
			foreach (OwnConfigEntryBase item in allConfigs.Where((OwnConfigEntryBase config) => config.LocalBaseValue != null))
			{
				if (val == null)
				{
					val = item.BaseConfig.ConfigFile;
					saveOnConfigSet = val.SaveOnConfigSet;
					val.SaveOnConfigSet = false;
				}
				item.BaseConfig.BoxedValue = item.LocalBaseValue;
				item.LocalBaseValue = null;
			}
			if (val != null)
			{
				val.SaveOnConfigSet = saveOnConfigSet;
			}
			foreach (CustomSyncedValueBase item2 in allCustomValues.Where((CustomSyncedValueBase config) => config.LocalBaseValue != null))
			{
				item2.BoxedValue = item2.LocalBaseValue;
				item2.LocalBaseValue = null;
			}
			lockedConfigChanged -= serverLockedSettingChanged;
			serverLockedSettingChanged();
		}

		private IEnumerator<bool> distributeConfigToPeers(ZNetPeer peer, ZPackage package)
		{
			ZRoutedRpc rpc = ZRoutedRpc.instance;
			if (rpc == null)
			{
				yield break;
			}
			byte[] data = package.GetArray();
			if (data != null && data.LongLength > 250000)
			{
				int fragments = (int)(1 + (data.LongLength - 1) / 250000);
				long packageIdentifier = ++packageCounter;
				int fragment = 0;
				while (fragment < fragments)
				{
					foreach (bool item in waitForQueue())
					{
						yield return item;
					}
					if (peer.m_socket.IsConnected())
					{
						ZPackage val = new ZPackage();
						val.Write((byte)2);
						val.Write(packageIdentifier);
						val.Write(fragment);
						val.Write(fragments);
						val.Write(data.Skip(250000 * fragment).Take(250000).ToArray());
						SendPackage(val);
						if (fragment != fragments - 1)
						{
							yield return true;
						}
						int num = fragment + 1;
						fragment = num;
						continue;
					}
					break;
				}
				yield break;
			}
			foreach (bool item2 in waitForQueue())
			{
				yield return item2;
			}
			SendPackage(package);
			void SendPackage(ZPackage pkg)
			{
				string text = Name + " ConfigSync";
				if (isServer)
				{
					peer.m_rpc.Invoke(text, new object[1] { pkg });
				}
				else
				{
					rpc.InvokeRoutedRPC(peer.m_server ? 0 : peer.m_uid, text, new object[1] { pkg });
				}
			}
			IEnumerable<bool> waitForQueue()
			{
				float timeout = Time.time + 30f;
				while (peer.m_socket.GetSendQueueSize() > 20000)
				{
					if (Time.time > timeout)
					{
						Debug.Log((object)$"Disconnecting {peer.m_uid} after 30 seconds config sending timeout");
						peer.m_rpc.Invoke("Error", new object[1] { (object)(ConnectionStatus)5 });
						ZNet.instance.Disconnect(peer);
						break;
					}
					yield return false;
				}
			}
		}

		private IEnumerator sendZPackage(long target, ZPackage package)
		{
			if (!Object.op_Implicit((Object)(object)ZNet.instance))
			{
				return Enumerable.Empty<object>().GetEnumerator();
			}
			List<ZNetPeer> list = (List<ZNetPeer>)AccessTools.DeclaredField(typeof(ZRoutedRpc), "m_peers").GetValue(ZRoutedRpc.instance);
			if (target != ZRoutedRpc.Everybody)
			{
				list = list.Where((ZNetPeer p) => p.m_uid == target).ToList();
			}
			return sendZPackage(list, package);
		}

		private IEnumerator sendZPackage(List<ZNetPeer> peers, ZPackage package)
		{
			if (!Object.op_Implicit((Object)(object)ZNet.instance))
			{
				yield break;
			}
			byte[] array = package.GetArray();
			if (array != null && array.LongLength > 10000)
			{
				ZPackage val = new ZPackage();
				val.Write((byte)4);
				MemoryStream memoryStream = new MemoryStream();
				using (DeflateStream deflateStream = new DeflateStream(memoryStream, CompressionLevel.Optimal))
				{
					deflateStream.Write(array, 0, array.Length);
				}
				val.Write(memoryStream.ToArray());
				package = val;
			}
			List<IEnumerator<bool>> writers = (from p in peers
				where p.IsReady()
				select distributeConfigToPeers(p, package)).ToList();
			writers.RemoveAll((IEnumerator<bool> writer) => !writer.MoveNext());
			while (writers.Count > 0)
			{
				yield return null;
				writers.RemoveAll((IEnumerator<bool> writer) => !writer.MoveNext());
			}
		}

		private void Broadcast(long target, params ConfigEntryBase[] configs)
		{
			if (!IsLocked || isServer)
			{
				ZPackage package = ConfigsToPackage(configs);
				ZNet instance = ZNet.instance;
				if (instance != null)
				{
					((MonoBehaviour)instance).StartCoroutine(sendZPackage(target, package));
				}
			}
		}

		private void Broadcast(long target, params CustomSyncedValueBase[] customValues)
		{
			if (!IsLocked || isServer)
			{
				ZPackage package = ConfigsToPackage(null, customValues);
				ZNet instance = ZNet.instance;
				if (instance != null)
				{
					((MonoBehaviour)instance).StartCoroutine(sendZPackage(target, package));
				}
			}
		}

		private static OwnConfigEntryBase? configData(ConfigEntryBase config)
		{
			return config.Description.Tags?.OfType<OwnConfigEntryBase>().SingleOrDefault();
		}

		public static SyncedConfigEntry<T>? ConfigData<T>(ConfigEntry<T> config)
		{
			return ((ConfigEntryBase)config).Description.Tags?.OfType<SyncedConfigEntry<T>>().SingleOrDefault();
		}

		private static T configAttribute<T>(ConfigEntryBase config)
		{
			return config.Description.Tags.OfType<T>().First();
		}

		private static Type configType(ConfigEntryBase config)
		{
			return configType(config.SettingType);
		}

		private static Type configType(Type type)
		{
			if (!type.IsEnum)
			{
				return type;
			}
			return Enum.GetUnderlyingType(type);
		}

		private static ZPackage ConfigsToPackage(IEnumerable<ConfigEntryBase>? configs = null, IEnumerable<CustomSyncedValueBase>? customValues = null, IEnumerable<PackageEntry>? packageEntries = null, bool partial = true)
		{
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Expected O, but got Unknown
			List<ConfigEntryBase> list = configs?.Where((ConfigEntryBase config) => configData(config).SynchronizedConfig).ToList() ?? new List<ConfigEntryBase>();
			List<CustomSyncedValueBase> list2 = customValues?.ToList() ?? new List<CustomSyncedValueBase>();
			ZPackage val = new ZPackage();
			val.Write(partial ? ((byte)1) : ((byte)0));
			val.Write(list.Count + list2.Count + (packageEntries?.Count() ?? 0));
			foreach (PackageEntry item in packageEntries ?? Array.Empty<PackageEntry>())
			{
				AddEntryToPackage(val, item);
			}
			foreach (CustomSyncedValueBase item2 in list2)
			{
				AddEntryToPackage(val, new PackageEntry
				{
					section = "Internal",
					key = item2.Identifier,
					type = item2.Type,
					value = item2.BoxedValue
				});
			}
			foreach (ConfigEntryBase item3 in list)
			{
				AddEntryToPackage(val, new PackageEntry
				{
					section = item3.Definition.Section,
					key = item3.Definition.Key,
					type = configType(item3),
					value = item3.BoxedValue
				});
			}
			return val;
		}

		private static void AddEntryToPackage(ZPackage package, PackageEntry entry)
		{
			package.Write(entry.section);
			package.Write(entry.key);
			package.Write((entry.value == null) ? "" : GetZPackageTypeString(entry.type));
			AddValueToZPackage(package, entry.value);
		}

		private static string GetZPackageTypeString(Type type)
		{
			return type.AssemblyQualifiedName;
		}

		private static void AddValueToZPackage(ZPackage package, object? value)
		{
			Type type = value?.GetType();
			if (value is Enum)
			{
				value = ((IConvertible)value).ToType(Enum.GetUnderlyingType(value.GetType()), CultureInfo.InvariantCulture);
			}
			else
			{
				if (value is ICollection collection)
				{
					package.Write(collection.Count);
					{
						foreach (object item in collection)
						{
							AddValueToZPackage(package, item);
						}
						return;
					}
				}
				if ((object)type != null && type.IsValueType && !type.IsPrimitive)
				{
					FieldInfo[] fields = type.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
					package.Write(fields.Length);
					FieldInfo[] array = fields;
					foreach (FieldInfo fieldInfo in array)
					{
						package.Write(GetZPackageTypeString(fieldInfo.FieldType));
						AddValueToZPackage(package, fieldInfo.GetValue(value));
					}
					return;
				}
			}
			ZRpc.Serialize(new object[1] { value }, ref package);
		}

		private static object ReadValueWithTypeFromZPackage(ZPackage package, Type type)
		{
			if ((object)type != null && type.IsValueType && !type.IsPrimitive && !type.IsEnum)
			{
				FieldInfo[] fields = type.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				int num = package.ReadInt();
				if (num != fields.Length)
				{
					throw new InvalidDeserializationTypeException
					{
						received = $"(field count: {num})",
						expected = $"(field count: {fields.Length})"
					};
				}
				object uninitializedObject = FormatterServices.GetUninitializedObject(type);
				FieldInfo[] array = fields;
				foreach (FieldInfo fieldInfo in array)
				{
					string text = package.ReadString();
					if (text != GetZPackageTypeString(fieldInfo.FieldType))
					{
						throw new InvalidDeserializationTypeException
						{
							received = text,
							expected = GetZPackageTypeString(fieldInfo.FieldType),
							field = fieldInfo.Name
						};
					}
					fieldInfo.SetValue(uninitializedObject, ReadValueWithTypeFromZPackage(package, fieldInfo.FieldType));
				}
				return uninitializedObject;
			}
			if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Dictionary<, >))
			{
				int num2 = package.ReadInt();
				IDictionary dictionary = (IDictionary)Activator.CreateInstance(type);
				Type type2 = typeof(KeyValuePair<, >).MakeGenericType(type.GenericTypeArguments);
				FieldInfo field = type2.GetField("key", BindingFlags.Instance | BindingFlags.NonPublic);
				FieldInfo field2 = type2.GetField("value", BindingFlags.Instance | BindingFlags.NonPublic);
				for (int j = 0; j < num2; j++)
				{
					object obj = ReadValueWithTypeFromZPackage(package, type2);
					dictionary.Add(field.GetValue(obj), field2.GetValue(obj));
				}
				return dictionary;
			}
			if (type != typeof(List<string>) && type.IsGenericType)
			{
				Type type3 = typeof(ICollection<>).MakeGenericType(type.GenericTypeArguments[0]);
				if ((object)type3 != null && type3.IsAssignableFrom(type))
				{
					int num3 = package.ReadInt();
					object obj2 = Activator.CreateInstance(type);
					MethodInfo method = type3.GetMethod("Add");
					for (int k = 0; k < num3; k++)
					{
						method.Invoke(obj2, new object[1] { ReadValueWithTypeFromZPackage(package, type.GenericTypeArguments[0]) });
					}
					return obj2;
				}
			}
			ParameterInfo parameterInfo = (ParameterInfo)FormatterServices.GetUninitializedObject(typeof(ParameterInfo));
			AccessTools.DeclaredField(typeof(ParameterInfo), "ClassImpl").SetValue(parameterInfo, type);
			List<object> source = new List<object>();
			ZRpc.Deserialize(new ParameterInfo[2] { null, parameterInfo }, package, ref source);
			return source.First();
		}
	}
	[HarmonyPatch]
	public class VersionCheck
	{
		private static readonly HashSet<VersionCheck> versionChecks;

		private static readonly Dictionary<string, string> notProcessedNames;

		public string Name;

		private string? displayName;

		private string? currentVersion;

		private string? minimumRequiredVersion;

		public bool ModRequired = true;

		private string? ReceivedCurrentVersion;

		private string? ReceivedMinimumRequiredVersion;

		private readonly List<ZRpc> ValidatedClients = new List<ZRpc>();

		private ConfigSync? ConfigSync;

		public string DisplayName
		{
			get
			{
				return displayName ?? Name;
			}
			set
			{
				displayName = value;
			}
		}

		public string CurrentVersion
		{
			get
			{
				return currentVersion ?? "0.0.0";
			}
			set
			{
				currentVersion = value;
			}
		}

		public string MinimumRequiredVersion
		{
			get
			{
				string text = minimumRequiredVersion;
				if (text == null)
				{
					if (!ModRequired)
					{
						return "0.0.0";
					}
					text = CurrentVersion;
				}
				return text;
			}
			set
			{
				minimumRequiredVersion = value;
			}
		}

		private static void PatchServerSync()
		{
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Expected O, but got Unknown
			Patches patchInfo = PatchProcessor.GetPatchInfo((MethodBase)AccessTools.DeclaredMethod(typeof(ZNet), "Awake", (Type[])null, (Type[])null));
			if (patchInfo != null && patchInfo.Postfixes.Count((Patch p) => p.PatchMethod.DeclaringType == typeof(ConfigSync.RegisterRPCPatch)) > 0)
			{
				return;
			}
			Harmony val = new Harmony("org.bepinex.helpers.ServerSync");
			foreach (Type item in from t in typeof(ConfigSync).GetNestedTypes(BindingFlags.NonPublic).Concat(new Type[1] { typeof(VersionCheck) })
				where t.IsClass
				select t)
			{
				val.PatchAll(item);
			}
		}

		static VersionCheck()
		{
			versionChecks = new HashSet<VersionCheck>();
			notProcessedNames = new Dictionary<string, string>();
			typeof(ThreadingHelper).GetMethod("StartSyncInvoke").Invoke(ThreadingHelper.Instance, new object[1]
			{
				new Action(PatchServerSync)
			});
		}

		public VersionCheck(string name)
		{
			Name = name;
			ModRequired = true;
			versionChecks.Add(this);
		}

		public VersionCheck(ConfigSync configSync)
		{
			ConfigSync = configSync;
			Name = ConfigSync.Name;
			versionChecks.Add(this);
		}

		public void Initialize()
		{
			ReceivedCurrentVersion = null;
			ReceivedMinimumRequiredVersion = null;
			if (ConfigSync != null)
			{
				Name = ConfigSync.Name;
				DisplayName = ConfigSync.DisplayName;
				CurrentVersion = ConfigSync.CurrentVersion;
				MinimumRequiredVersion = ConfigSync.MinimumRequiredVersion;
				ModRequired = ConfigSync.ModRequired;
			}
		}

		private bool IsVersionOk()
		{
			if (ReceivedMinimumRequiredVersion == null || ReceivedCurrentVersion == null)
			{
				return !ModRequired;
			}
			bool num = new Version(CurrentVersion) >= new Version(ReceivedMinimumRequiredVersion);
			bool flag = new Version(ReceivedCurrentVersion) >= new Version(MinimumRequiredVersion);
			return num && flag;
		}

		private string ErrorClient()
		{
			if (ReceivedMinimumRequiredVersion == null)
			{
				return DisplayName + " is not installed on the server.";
			}
			if (!(new Version(CurrentVersion) >= new Version(ReceivedMinimumRequiredVersion)))
			{
				return DisplayName + " needs to be at least version " + ReceivedMinimumRequiredVersion + ". You have version " + CurrentVersion + ".";
			}
			return DisplayName + " may not be higher than version " + ReceivedCurrentVersion + ". You have version " + CurrentVersion + ".";
		}

		private string ErrorServer(ZRpc rpc)
		{
			return "Disconnect: The client (" + rpc.GetSocket().GetHostName() + ") doesn't have the correct " + DisplayName + " version " + MinimumRequiredVersion;
		}

		private string Error(ZRpc? rpc = null)
		{
			if (rpc != null)
			{
				return ErrorServer(rpc);
			}
			return ErrorClient();
		}

		private static VersionCheck[] GetFailedClient()
		{
			return versionChecks.Where((VersionCheck check) => !check.IsVersionOk()).ToArray();
		}

		private static VersionCheck[] GetFailedServer(ZRpc rpc)
		{
			return versionChecks.Where((VersionCheck check) => check.ModRequired && !check.ValidatedClients.Contains(rpc)).ToArray();
		}

		private static void Logout()
		{
			Game.instance.Logout(true, true);
			AccessTools.DeclaredField(typeof(ZNet), "m_connectionStatus").SetValue(null, (object)(ConnectionStatus)3);
		}

		private static void DisconnectClient(ZRpc rpc)
		{
			rpc.Invoke("Error", new object[1] { 3 });
		}

		private static void CheckVersion(ZRpc rpc, ZPackage pkg)
		{
			CheckVersion(rpc, pkg, null);
		}

		private static void CheckVersion(ZRpc rpc, ZPackage pkg, Action<ZRpc, ZPackage>? original)
		{
			string text = pkg.ReadString();
			string text2 = pkg.ReadString();
			string text3 = pkg.ReadString();
			bool flag = false;
			foreach (VersionCheck versionCheck in versionChecks)
			{
				if (!(text != versionCheck.Name))
				{
					Debug.Log((object)("Received " + versionCheck.DisplayName + " version " + text3 + " and minimum version " + text2 + " from the " + (ZNet.instance.IsServer() ? "client" : "server") + "."));
					versionCheck.ReceivedMinimumRequiredVersion = text2;
					versionCheck.ReceivedCurrentVersion = text3;
					if (ZNet.instance.IsServer() && versionCheck.IsVersionOk())
					{
						versionCheck.ValidatedClients.Add(rpc);
					}
					flag = true;
				}
			}
			if (flag)
			{
				return;
			}
			pkg.SetPos(0);
			if (original != null)
			{
				original(rpc, pkg);
				if (pkg.GetPos() == 0)
				{
					notProcessedNames.Add(text, text3);
				}
			}
		}

		[HarmonyPatch(typeof(ZNet), "RPC_PeerInfo")]
		[HarmonyPrefix]
		private static bool RPC_PeerInfo(ZRpc rpc, ZNet __instance)
		{
			VersionCheck[] array = (__instance.IsServer() ? GetFailedServer(rpc) : GetFailedClient());
			if (array.Length == 0)
			{
				return true;
			}
			VersionCheck[] array2 = array;
			for (int i = 0; i < array2.Length; i++)
			{
				Debug.LogWarning((object)array2[i].Error(rpc));
			}
			if (__instance.IsServer())
			{
				DisconnectClient(rpc);
			}
			else
			{
				Logout();
			}
			return false;
		}

		[HarmonyPatch(typeof(ZNet), "OnNewConnection")]
		[HarmonyPrefix]
		private static void RegisterAndCheckVersion(ZNetPeer peer, ZNet __instance)
		{
			//IL_0172: Unknown result type (might be due to invalid IL or missing references)
			//IL_0179: Expected O, but got Unknown
			notProcessedNames.Clear();
			IDictionary dictionary = (IDictionary)typeof(ZRpc).GetField("m_functions", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(peer.m_rpc);
			if (dictionary.Contains(StringExtensionMethods.GetStableHashCode("ServerSync VersionCheck")))
			{
				object obj = dictionary[StringExtensionMethods.GetStableHashCode("ServerSync VersionCheck")];
				Action<ZRpc, ZPackage> action = (Action<ZRpc, ZPackage>)obj.GetType().GetField("m_action", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(obj);
				peer.m_rpc.Register<ZPackage>("ServerSync VersionCheck", (Action<ZRpc, ZPackage>)delegate(ZRpc rpc, ZPackage pkg)
				{
					CheckVersion(rpc, pkg, action);
				});
			}
			else
			{
				peer.m_rpc.Register<ZPackage>("ServerSync VersionCheck", (Action<ZRpc, ZPackage>)CheckVersion);
			}
			foreach (VersionCheck versionCheck in versionChecks)
			{
				versionCheck.Initialize();
				if (versionCheck.ModRequired || __instance.IsServer())
				{
					Debug.Log((object)("Sending " + versionCheck.DisplayName + " version " + versionCheck.CurrentVersion + " and minimum version " + versionCheck.MinimumRequiredVersion + " to the " + (__instance.IsServer() ? "client" : "server") + "."));
					ZPackage val = new ZPackage();
					val.Write(versionCheck.Name);
					val.Write(versionCheck.MinimumRequiredVersion);
					val.Write(versionCheck.CurrentVersion);
					peer.m_rpc.Invoke("ServerSync VersionCheck", new object[1] { val });
				}
			}
		}

		[HarmonyPatch(typeof(ZNet), "Disconnect")]
		[HarmonyPrefix]
		private static void RemoveDisconnected(ZNetPeer peer, ZNet __instance)
		{
			if (!__instance.IsServer())
			{
				return;
			}
			foreach (VersionCheck versionCheck in versionChecks)
			{
				versionCheck.ValidatedClients.Remove(peer.m_rpc);
			}
		}

		[HarmonyPatch(typeof(FejdStartup), "ShowConnectError")]
		[HarmonyPostfix]
		private static void ShowConnectionError(FejdStartup __instance)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Invalid comparison between Unknown and I4
			//IL_014e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0153: 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_01a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01be: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01de: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ee: Unknown result type (might be due to invalid IL or missing references)
			if (!__instance.m_connectionFailedPanel.activeSelf || (int)ZNet.GetConnectionStatus() != 3)
			{
				return;
			}
			bool flag = false;
			VersionCheck[] failedClient = GetFailedClient();
			if (failedClient.Length != 0)
			{
				string text = string.Join("\n", failedClient.Select((VersionCheck check) => check.Error()));
				TMP_Text connectionFailedError = __instance.m_connectionFailedError;
				connectionFailedError.text = connectionFailedError.text + "\n" + text;
				flag = true;
			}
			foreach (KeyValuePair<string, string> item in notProcessedNames.OrderBy((KeyValuePair<string, string> kv) => kv.Key))
			{
				if (!__instance.m_connectionFailedError.text.Contains(item.Key))
				{
					TMP_Text connectionFailedError2 = __instance.m_connectionFailedError;
					connectionFailedError2.text = connectionFailedError2.text + "\nServer expects you to have " + item.Key + " (Version: " + item.Value + ") installed.";
					flag = true;
				}
			}
			if (flag)
			{
				RectTransform component = ((Component)__instance.m_connectionFailedPanel.transform.Find("Image")).GetComponent<RectTransform>();
				Vector2 sizeDelta = component.sizeDelta;
				sizeDelta.x = 675f;
				component.sizeDelta = sizeDelta;
				__instance.m_connectionFailedError.ForceMeshUpdate(false, false);
				float num = __instance.m_connectionFailedError.renderedHeight + 105f;
				RectTransform component2 = ((Component)((Component)component).transform.Find("ButtonOk")).GetComponent<RectTransform>();
				component2.anchoredPosition = new Vector2(component2.anchoredPosition.x, component2.anchoredPosition.y - (num - component.sizeDelta.y) / 2f);
				sizeDelta = component.sizeDelta;
				sizeDelta.y = num;
				component.sizeDelta = sizeDelta;
			}
		}
	}
}
namespace GuildStructures
{
	[BepInPlugin("com.rdmods.guildstructures", "Guild Structures", "1.1.0")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public sealed class GuildStructuresPlugin : BaseUnityPlugin
	{
		private Harmony _harmony;

		internal static GuildStructuresConfig Cfg { get; private set; }

		private void Awake()
		{
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Expected O, but got Unknown
			Cfg = new GuildStructuresConfig(((BaseUnityPlugin)this).Config);
			Log.Init(((BaseUnityPlugin)this).Logger, () => Cfg.DebugLogging.Value);
			GuildGenerationTracker.Initialize();
			if (!Cfg.Enabled.Value)
			{
				Log.Warn("Guild Structures is disabled via config (1 - General / Enabled). No patches applied.");
				return;
			}
			_harmony = new Harmony("com.rdmods.guildstructures");
			PatchInit.ApplyAll(_harmony);
			((BaseUnityPlugin)this).Config.SettingChanged += delegate
			{
				OwnershipPatches.ReloadRules();
				ProtectedStorageRules.ReloadRules();
			};
			try
			{
				ConfigLiveReload.Begin((MonoBehaviour)(object)this, ((BaseUnityPlugin)this).Config, _harmony);
				Log.Info("[Patch OK] Server CFG live reload (FileSystemWatcher)");
			}
			catch (Exception ex)
			{
				Log.Error("[Patch FAILED] Server CFG live reload (FileSystemWatcher): " + ex.Message + "\nLive disk reload will be inactive; restart-the-server and Config Manager paths still work. Every other Guild Structures feature keeps working.\n" + ex);
			}
			WecCompat.BeginRegistration((MonoBehaviour)(object)this, GuildZdo.AllFieldNames, PasswordZdo.AllFieldNames);
			Log.Info("Guild Structures v1.1.0 loaded.");
		}

		private void OnDestroy()
		{
			ConfigLiveReload.Dispose();
			Harmony harmony = _harmony;
			if (harmony != null)
			{
				harmony.UnpatchSelf();
			}
		}
	}
	internal static class PluginInfo
	{
		public const string PLUGIN_GUID = "com.rdmods.guildstructures";

		public const string PLUGIN_NAME = "Guild Structures";

		public const string PLUGIN_VERSION = "1.1.0";

		public const string GUILDS_GUID = "org.bepinex.plugins.guilds";

		public const string WEC_GUID = "world_edit_commands";
	}
}
namespace GuildStructures.Util
{
	internal static class Log
	{
		private static ManualLogSource _source;

		private static Func<bool> _debugEnabled;

		internal static bool IsDebugEnabled
		{
			get
			{
				if (_debugEnabled != null)
				{
					return _debugEnabled();
				}
				return false;
			}
		}

		internal static void Init(ManualLogSource source, Func<bool> debugEnabled)
		{
			_source = source;
			_debugEnabled = debugEnabled;
		}

		internal static void Info(string message)
		{
			ManualLogSource source = _source;
			if (source != null)
			{
				source.LogInfo((object)message);
			}
		}

		internal static void Warn(string message)
		{
			ManualLogSource source = _source;
			if (source != null)
			{
				source.LogWarning((object)message);
			}
		}

		internal static void Error(string message)
		{
			ManualLogSource source = _source;
			if (source != null)
			{
				source.LogError((object)message);
			}
		}

		internal static void Debug(string message)
		{
			if (IsDebugEnabled)
			{
				ManualLogSource source = _source;
				if (source != null)
				{
					source.LogInfo((object)("[Debug] " + message));
				}
			}
		}
	}
	internal static class PlayerNameResolver
	{
		internal static string Resolve(long playerUid)
		{
			if (playerUid == 0L)
			{
				return "Unknown";
			}
			try
			{
				Player localPlayer = Player.m_localPlayer;
				if ((Object)(object)localPlayer != (Object)null && localPlayer.GetPlayerID() == playerUid)
				{
					return localPlayer.GetPlayerName();
				}
				List<Player> allPlayers = Player.GetAllPlayers();
				if (allPlayers != null)
				{
					for (int i = 0; i < allPlayers.Count; i++)
					{
						Player val = allPlayers[i];
						if ((Object)(object)val != (Object)null && val.GetPlayerID() == playerUid)
						{
							return val.GetPlayerName();
						}
					}
				}
			}
			catch (Exception arg)
			{
				Log.Error($"[PlayerNameResolver] Failed to resolve display name for uid {playerUid}: {arg}");
			}
			return "Unknown";
		}
	}
	internal static class RpcIdentity
	{
		internal static long ResolvePlayerId(long rpcSenderUid)
		{
			try
			{
				long num = ResolveByLiveCharacter(rpcSenderUid);
				if (num != 0L)
				{
					return num;
				}
				ZNet instance = ZNet.instance;
				ZNetPeer val = ((instance != null) ? instance.GetPeer(rpcSenderUid) : null);
				if (val != null)
				{
					long num2 = ResolvePlayerId(val);
					if (num2 != 0L)
					{
						return num2;
					}
				}
				Player localPlayer = Player.m_localPlayer;
				return ((Object)(object)localPlayer != (Object)null) ? localPlayer.GetPlayerID() : 0;
			}
			catch (Exception arg)
			{
				Log.Error($"[RpcIdentity] Failed to resolve RPC sender {rpcSenderUid} to a player id: {arg}");
				return 0L;
			}
		}

		private static long ResolveByLiveCharacter(long rpcSenderUid)
		{
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer != (Object)null && OwnsCharacter(localPlayer, rpcSenderUid))
			{
				return localPlayer.GetPlayerID();
			}
			List<Player> allPlayers = Player.GetAllPlayers();
			if (allPlayers == null)
			{
				return 0L;
			}
			for (int i = 0; i < allPlayers.Count; i++)
			{
				Player val = allPlayers[i];
				if ((Object)(object)val != (Object)null && OwnsCharacter(val, rpcSenderUid))
				{
					return val.GetPlayerID();
				}
			}
			return 0L;
		}

		private static bool OwnsCharacter(Player player, long rpcSenderUid)
		{
			ZNetView component = ((Component)player).GetComponent<ZNetView>();
			if ((Object)(object)component == (Object)null || !component.IsValid())
			{
				return false;
			}
			ZDO zDO = component.GetZDO();
			if (zDO != null)
			{
				return ((ZDOID)(ref zDO.m_uid)).UserID == rpcSenderUid;
			}
			return false;
		}

		internal static long ResolvePlayerId(ZNetPeer peer)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if (peer == null)
				{
					return 0L;
				}
				ZDOMan instance = ZDOMan.instance;
				ZDO val = ((instance != null) ? instance.GetZDO(peer.m_characterID) : null);
				if (val == null)
				{
					return 0L;
				}
				return val.GetLong(ZDOVars.s_playerID, 0L);
			}
			catch (Exception arg)
			{
				Log.Error($"[RpcIdentity] Failed to resolve peer {peer?.m_uid} to a player id: {arg}");
				return 0L;
			}
		}
	}
}
namespace GuildStructures.Sync
{
	internal static class GuildStructuresSync
	{
		internal static readonly ConfigSync Instance = new ConfigSync("com.rdmods.guildstructures")
		{
			DisplayName = "Guild Structures",
			CurrentVersion = "1.1.0",
			ModRequired = false
		};
	}
}
namespace GuildStructures.Storage
{
	internal static class PasswordCrypto
	{
		private const int SaltBytes = 16;

		internal static string GenerateSalt()
		{
			byte[] array = new byte[16];
			using (RandomNumberGenerator randomNumberGenerator = RandomNumberGenerator.Create())
			{
				randomNumberGenerator.GetBytes(array);
			}
			return Convert.ToBase64String(array);
		}

		internal static string Hash(string password, string saltBase64)
		{
			if (password == null)
			{
				password = string.Empty;
			}
			byte[] array = Convert.FromBase64String(saltBase64);
			byte[] bytes = Encoding.UTF8.GetBytes(password);
			byte[] array2 = new byte[array.Length + bytes.Length];
			Buffer.BlockCopy(array, 0, array2, 0, array.Length);
			Buffer.BlockCopy(bytes, 0, array2, array.Length, bytes.Length);
			using SHA256 sHA = SHA256.Create();
			return Convert.ToBase64String(sHA.ComputeHash(array2));
		}

		internal static bool FixedTimeEquals(string a, string b)
		{
			if (a == null || b == null)
			{
				return false;
			}
			if (a.Length != b.Length)
			{
				return false;
			}
			int num = 0;
			for (int i = 0; i < a.Length; i++)
			{
				num |= a[i] ^ b[i];
			}
			return num == 0;
		}
	}
	internal static class PasswordRemoveGuard
	{
		internal static bool ShouldBlockRemove(Piece piece, long removerPlayerId)
		{
			if ((Object)(object)piece == (Object)null || !ProtectedStorageRules.Pieces.HasAnyRules)
			{
				return false;
			}
			if (!ProtectedStorageRules.Pieces.Matches(Utils.GetPrefabName(((Component)piece).gameObject)))
			{
				return false;
			}
			ZNetView component = ((Component)piece).GetComponent<ZNetView>();
			if ((Object)(object)component == (Object)null || !component.IsValid())
			{
				return false;
			}
			ZDO zDO = component.GetZDO();
			if (zDO == null || !PasswordZdo.HasPassword(zDO))
			{
				return false;
			}
			long creator = piece.GetCreator();
			if (creator == 0L)
			{
				return false;
			}
			if (removerPlayerId != 0L && removerPlayerId == creator)
			{
				return false;
			}
			return true;
		}

		internal static void ShowDeniedMessage(Player player)
		{
			if (!((Object)(object)player == (Object)null))
			{
				((Character)player).Message((MessageType)2, "Only the owner can remove this while it is password-protected.", 0, (Sprite)null);
			}
		}

		internal static void LogDenied(string prefab, long removerPlayerId, long ownerUid, string gate)
		{
			if (Log.IsDebugEnabled)
			{
				Log.Debug("[Password] Remove DENIED via " + gate + " on '" + prefab + "' " + $"(remover player id {removerPlayerId}, owner {ownerUid}; permitted/non-owners cannot de-hammer).");
			}
		}
	}
	internal static class PasswordRpc
	{
		private const string SetPasswordRpc = "GS_SetPassword";

		private const string SetPasswordResultRpc = "GS_SetPasswordResult";

		private const string TryPasswordRpc = "GS_TryPassword";

		private const string TryPasswordResultRpc = "GS_TryPasswordResult";

		internal static void RegisterForPiece(Piece piece, ZNetView nview)
		{
			nview.Register<string>("GS_SetPassword", (Action<long, string>)delegate(long sender, string newPassword)
			{
				HandleSetPassword(piece, nview, sender, newPassword);
			});
			nview.Register<bool, bool>("GS_SetPasswordResult", (Action<long, bool, bool>)delegate(long sender, bool success, bool removed)
			{
				PasswordUI.OnSetPasswordResult(nview, success, removed);
			});
			nview.Register<string>("GS_TryPassword", (Action<long, string>)delegate(long sender, string attempt)
			{
				HandleTryPassword(piece, nview, sender, attempt);
			});
			nview.Register<bool>("GS_TryPasswordResult", (Action<long, bool>)delegate(long sender, bool success)
			{
				PasswordUI.OnTryPasswordResult(nview, success);
			});
		}

		internal static void RequestSetPassword(ZNetView nview, string newPassword)
		{
			nview.InvokeRPC("GS_SetPassword", new object[1] { newPassword ?? string.Empty });
		}

		internal static void RequestTryPassword(ZNetView nview, string attempt)
		{
			nview.InvokeRPC("GS_TryPassword", new object[1] { attempt ?? string.Empty });
		}

		private static void HandleSetPassword(Piece piece, ZNetView nview, long sender, string newPassword)
		{
			try
			{
				if ((Object)(object)piece == (Object)null || (Object)(object)nview == (Object)null || !nview.IsValid() || !nview.IsOwner())
				{
					return;
				}
				ZDO zDO = nview.GetZDO();
				if (zDO == null)
				{
					return;
				}
				long creator = piece.GetCreator();
				long num = RpcIdentity.ResolvePlayerId(sender);
				if (creator == 0L || num == 0L || num != creator)
				{
					Log.Warn("[Password] Rejected password change on '" + Utils.GetPrefabName(((Component)piece).gameObject) + "' " + $"from RPC sender {sender} (resolved player id {num}) - not the recorded owner ({creator}).");
					nview.InvokeRPC(sender, "GS_SetPasswordResult", new object[2] { false, false });
					return;
				}
				bool flag = string.IsNullOrEmpty(newPassword);
				if (flag)
				{
					PasswordZdo.ClearPassword(zDO);
				}
				else
				{
					string text = PasswordCrypto.GenerateSalt();
					string hash = PasswordCrypto.Hash(newPassword, text);
					PasswordZdo.SetPassword(zDO, hash, text);
					PasswordZdo.EnsureOwnerName(zDO, PlayerNameResolver.Resolve(num));
				}
				PasswordZdo.ClearGrants(zDO);
				if (Log.IsDebugEnabled)
				{
					Log.Debug(string.Format("[Password] Owner (player id {0}) {1} password on ", num, flag ? "removed" : "set a new") + "'" + Utils.GetPrefabName(((Component)piece).gameObject) + "'.");
				}
				nview.InvokeRPC(sender, "GS_SetPasswordResult", new object[2] { true, flag });
			}
			catch (Exception arg)
			{
				Log.Error($"[Password] HandleSetPassword threw: {arg}");
			}
		}

		private static void HandleTryPassword(Piece piece, ZNetView nview, long sender, string attempt)
		{
			try
			{
				if ((Object)(object)piece == (Object)null || (Object)(object)nview == (Object)null || !nview.IsValid() || !nview.IsOwner())
				{
					return;
				}
				ZDO zDO = nview.GetZDO();
				if (zDO == null || !PasswordZdo.HasPassword(zDO))
				{
					return;
				}
				string salt = PasswordZdo.GetSalt(zDO);
				string hash = PasswordZdo.GetHash(zDO);
				string a = PasswordCrypto.Hash(attempt ?? string.Empty, salt);
				long num = RpcIdentity.ResolvePlayerId(sender);
				bool flag = num != 0L && PasswordCrypto.FixedTimeEquals(a, hash);
				if (flag)
				{
					PasswordZdo.Grant(zDO, num, PlayerNameResolver.Resolve(num));
					if (Log.IsDebugEnabled)
					{
						Log.Debug($"[Password] player id {num} entered the correct password for '{Utils.GetPrefabName(((Component)piece).gameObject)}'.");
					}
				}
				else if (Log.IsDebugEnabled)
				{
					Log.Debug($"[Password] RPC sender {sender} (resolved player id {num}) entered an incorrect password for '{Utils.GetPrefabName(((Component)piece).gameObject)}'.");
				}
				nview.InvokeRPC(sender, "GS_TryPasswordResult", new object[1] { flag });
			}
			catch (Exception arg)
			{
				Log.Error($"[Password] HandleTryPassword threw: {arg}");
			}
		}
	}
	internal sealed class PasswordUI : TextReceiver
	{
		private enum Mode
		{
			None,
			Set,
			Enter
		}

		private static readonly PasswordUI _instance = new PasswordUI();

		private Mode _pendingMode;

		private ZNetView _pendingView;

		private static ContentType? _originalContentType;

		private static char _originalAsteriskChar;

		private static readonly char Bullet = '•';

		private static string _realPassword = string.Empty;

		private static bool _sessionActive;

		private static bool _updatingDisplay;

		private static TMP_InputField _hookedField;

		private static UnityAction<string> _valueChangedHandler;

		private static bool _pendingSetWasChange;

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

		internal static bool IsLocallyGranted(ZDO zdo)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			if (zdo == null)
			{
				return false;
			}
			ZDOID uid = zdo.m_uid;
			if (!_locallyGranted.TryGetValue(uid, out var value))
			{
				return false;
			}
			string hash = PasswordZdo.GetHash(zdo);
			if (string.IsNullOrEmpty(hash) || !string.Equals(value, hash, StringComparison.Ordinal))
			{
				_locallyGranted.Remove(uid);
				if (Log.IsDebugEnabled)
				{
					Log.Debug("[Password] Local session grant for this piece was invalidated (password changed or removed since it was entered) - will re-prompt.");
				}
				return false;
			}
			return true;
		}

		internal static void RevokeLocalGrant(ZDOID id)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			_locallyGranted.Remove(id);
		}

		internal static void ShowSetPassword(ZNetView nview)
		{
			Show(nview, Mode.Set, "Set/Change Storage Password (empty = remove)");
		}

		internal static void ShowEnterPassword(ZNetView nview)
		{
			Show(nview, Mode.Enter, "Enter Storage Password");
		}

		private static void Show(ZNetView nview, Mode mode, string topic)
		{
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)TextInput.instance == (Object)null)
			{
				Log.Warn("[Password UI] TextInput.instance unavailable - cannot show password prompt.");
				return;
			}
			_instance._pendingMode = mode;
			_instance._pendingView = nview;
			_realPassword = string.Empty;
			_sessionActive = true;
			GuiInputField inputField = TextInput.instance.m_inputField;
			if ((Object)(object)inputField != (Object)null)
			{
				if (!_originalContentType.HasValue)
				{
					_originalContentType = ((TMP_InputField)inputField).contentType;
					_originalAsteriskChar = ((TMP_InputField)inputField).asteriskChar;
				}
				((TMP_InputField)inputField).contentType = (ContentType)0;
				((TMP_InputField)inputField).asteriskChar = Bullet;
				HookField((TMP_InputField)(object)inputField);
			}
			TextInput.instance.RequestText((TextReceiver)(object)_instance, topic, 64);
			RefreshDisplay();
		}

		private static void HookField(TMP_InputField field)
		{
			UnhookField();
			_hookedField = field;
			_valueChangedHandler = OnInputValueChanged;
			((UnityEvent<string>)(object)field.onValueChanged).AddListener(_valueChangedHandler);
		}

		private static void UnhookField()
		{
			if ((Object)(object)_hookedField != (Object)null && _valueChangedHandler != null)
			{
				((UnityEvent<string>)(object)_hookedField.onValueChanged).RemoveListener(_valueChangedHandler);
			}
			_hookedField = null;
			_valueChangedHandler = null;
		}

		private static void OnInputValueChanged(string text)
		{
			if (!_sessionActive || _updatingDisplay)
			{
				return;
			}
			try
			{
				text = text ?? string.Empty;
				int length = _realPassword.Length;
				int length2 = text.Length;
				if (length2 > length)
				{
					string text2 = FormatDisplay(_realPassword);
					if (length == 0 || text.StartsWith(text2, StringComparison.Ordinal))
					{
						_realPassword += text.Substring(text2.Length);
					}
					else
					{
						_realPassword = text;
					}
				}
				else if (length2 < length)
				{
					string text3 = FormatDisplay(_realPassword.Substring(0, length2));
					if (text == text3 || IsOnlyBullets(text) || length2 == length - 1)
					{
						_realPassword = _realPassword.Substring(0, length2);
					}
					else
					{
						_realPassword = text;
					}
				}
				else if (length2 > 0 && text != FormatDisplay(_realPassword))
				{
					if (IsMaskedShape(text))
					{
						_realPassword = _realPassword.Substring(0, length2 - 1) + text[length2 - 1];
					}
					else
					{
						_realPassword = text;
					}
				}
				if ((Object)(object)_hookedField != (Object)null && _hookedField.characterLimit > 0 && _realPassword.Length > _hookedField.characterLimit)
				{
					_realPassword = _realPassword.Substring(0, _hookedField.characterLimit);
				}
				RefreshDisplay();
			}
			catch (Exception arg)
			{
				Log.Error($"[Password UI] Last-letter mask update threw: {arg}");
			}
		}

		private static void RefreshDisplay()
		{
			if ((Object)(object)_hookedField == (Object)null)
			{
				return;
			}
			string text = FormatDisplay(_realPassword);
			_updatingDisplay = true;
			try
			{
				_hookedField.text = text;
				_hookedField.caretPosition = text.Length;
				_hookedField.selectionAnchorPosition = text.Length;
				_hookedField.selectionFocusPosition = text.Length;
			}
			finally
			{
				_updatingDisplay = false;
			}
		}

		private static string FormatDisplay(string real)
		{
			if (string.IsNullOrEmpty(real))
			{
				return string.Empty;
			}
			if (real.Length == 1)
			{
				return real;
			}
			return new string(Bullet, real.Length - 1) + real[real.Length - 1];
		}

		private static bool IsOnlyBullets(string text)
		{
			if (string.IsNullOrEmpty(text))
			{
				return true;
			}
			for (int i = 0; i < text.Length; i++)
			{
				if (text[i] != Bullet)
				{
					return false;
				}
			}
			return true;
		}

		private static bool IsMaskedShape(string text)
		{
			if (string.IsNullOrEmpty(text))
			{
				return true;
			}
			for (int i = 0; i < text.Length - 1; i++)
			{
				if (text[i] != Bullet)
				{
					return false;
				}
			}
			return true;
		}

		internal static void OnTextInputHidden()
		{
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			UnhookField();
			_sessionActive = false;
			_realPassword = string.Empty;
			_updatingDisplay = false;
			_pendingSetWasChange = false;
			GuiInputField val = (((Object)(object)TextInput.instance != (Object)null) ? TextInput.instance.m_inputField : null);
			if ((Object)(object)val != (Object)null && _originalContentType.HasValue)
			{
				((TMP_InputField)val).contentType = _originalContentType.Value;
				((TMP_InputField)val).asteriskChar = _originalAsteriskChar;
			}
			_originalContentType = null;
		}

		string TextReceiver.GetText()
		{
			return string.Empty;
		}

		void TextReceiver.SetText(string text)
		{
			Mode pendingMode = _pendingMode;
			ZNetView pendingView = _pendingView;
			_pendingMode = Mode.None;
			_pendingView = null;
			string text2 = (_sessionActive ? _realPassword : (text ?? string.Empty));
			if ((Object)(object)pendingView == (Object)null || !pendingView.IsValid())
			{
				return;
			}
			switch (pendingMode)
			{
			case Mode.Set:
			{
				ZDO zDO = pendingView.GetZDO();
				_pendingSetWasChange = zDO != null && PasswordZdo.HasPassword(zDO);
				PasswordRpc.RequestSetPassword(pendingView, text2 ?? string.Empty);
				break;
			}
			case Mode.Enter:
				if (!string.IsNullOrEmpty(text2))
				{
					PasswordRpc.RequestTryPassword(pendingView, text2);
				}
				break;
			}
		}

		internal static void OnSetPasswordResult(ZNetView nview, bool success, bool removed)
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			if (success && (Object)(object)nview != (Object)null && nview.IsValid() && nview.GetZDO() != null)
			{
				RevokeLocalGrant(nview.GetZDO().m_uid);
			}
			string message = ((!success) ? "Failed to set password (are you sure you're the owner?)." : (removed ? "Password removed." : (_pendingSetWasChange ? "Password changed." : "Password set.")));
			_pendingSetWasChange = false;
			ShowFeedback(message);
		}

		internal static void OnTryPasswordResult(ZNetView nview, bool success)
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			if (success && (Object)(object)nview != (Object)null && nview.IsValid())
			{
				ZDO zDO = nview.GetZDO();
				if (zDO != null)
				{
					string hash = PasswordZdo.GetHash(zDO);
					if (!string.IsNullOrEmpty(hash))
					{
						_locallyGranted[zDO.m_uid] = hash;
						ShowFeedback("Access Granted");
						return;
					}
				}
			}
			if (success)
			{
				ShowFeedback("Access Granted");
			}
			else
			{
				ShowFeedback("Incorrect password.");
			}
		}

		private static void ShowFeedback(string message)
		{
			try
			{
				if ((Object)(object)MessageHud.instance != (Object)null)
				{
					MessageHud.instance.ShowMessage((MessageType)2, message, 0, (Sprite)null, false);
				}
			}
			catch (Exception arg)
			{
				Log.Error($"[Password UI] Failed to show feedback message: {arg}");
			}
		}
	}
	internal static class PasswordZdo
	{
		internal const string PwHashFieldName = "GS_PwHash";

		internal const string PwSaltFieldName = "GS_PwSalt";

		internal const string PwGrantedIdsFieldName = "GS_PwGrantedIds";

		internal const string PwOwnerNameFieldName = "GS_PwOwnerName";

		internal const string PwGrantedNamesFieldName = "GS_PwGrantedNames";

		internal static readonly string[] AllFieldNames = new string[5] { "GS_PwHash", "GS_PwSalt", "GS_PwGrantedIds", "GS_PwOwnerName", "GS_PwGrantedNames" };

		private static readonly int PwHashHash = StringExtensionMethods.GetStableHashCode("GS_PwHash");

		private static readonly int PwSaltHash = StringExtensionMethods.GetStableHashCode("GS_PwSalt");

		private static readonly int PwGrantedIdsHash = StringExtensionMethods.GetStableHashCode("GS_PwGrantedIds");

		private static readonly int PwOwnerNameHash = StringExtensionMethods.GetStableHashCode("GS_PwOwnerName");

		private static readonly int PwGrantedNamesHash = StringExtensionMethods.GetStableHashCode("GS_PwGrantedNames");

		private const char IdSeparator = ',';

		private const char NameSeparator = '|';

		internal const int MaxHoverPermittedNames = 8;

		internal static bool HasPassword(ZDO zdo)
		{
			if (zdo != null)
			{
				return !string.IsNullOrEmpty(zdo.GetString(PwHashHash, string.Empty));
			}
			return false;
		}

		internal static string GetHash(ZDO zdo)
		{
			return ((zdo != null) ? zdo.GetString(PwHashHash, string.Empty) : null) ?? string.Empty;
		}

		internal static string GetSalt(ZDO zdo)
		{
			return ((zdo != null) ? zdo.GetString(PwSaltHash, string.Empty) : null) ?? string.Empty;
		}

		internal static string GetOwnerName(ZDO zdo)
		{
			return ((zdo != null) ? zdo.GetString(PwOwnerNameHash, string.Empty) : null) ?? string.Empty;
		}

		internal static void EnsureOwnerName(ZDO zdo, string playerName)
		{
			if (zdo != null && !string.IsNullOrEmpty(playerName) && string.IsNullOrEmpty(GetOwnerName(zdo)))
			{
				zdo.Set(PwOwnerNameHash, playerName);
			}
		}

		internal static void SetPassword(ZDO zdo, string hash, string salt)
		{
			if (zdo != null)
			{
				zdo.Set(PwHashHash, hash);
				zdo.Set(PwSaltHash, salt);
			}
		}

		internal static void ClearPassword(ZDO zdo)
		{
			if (zdo != null)
			{
				zdo.Set(PwHashHash, string.Empty);
				zdo.Set(PwSaltHash, string.Empty);
			}
		}

		internal static bool IsGranted(ZDO zdo, long playerId)
		{
			if (zdo == null || playerId == 0L)
			{
				return false;
			}
			foreach (long item in ParseIdList(zdo.GetString(PwGrantedIdsHash, string.Empty)))
			{
				if (item == playerId)
				{
					return true;
				}
			}
			return false;
		}

		internal static void Grant(ZDO zdo, long playerId, string playerName)
		{
			if (zdo == null || playerId == 0L)
			{
				return;
			}
			List<long> list = ParseIdList(zdo.GetString(PwGrantedIdsHash, string.Empty));
			for (int i = 0; i < list.Count; i++)
			{
				if (list[i] == playerId)
				{
					return;
				}
			}
			list.Add(playerId);
			zdo.Set(PwGrantedIdsHash, JoinIds(list));
			List<string> list2 = ParseNameList(zdo.GetString(PwGrantedNamesHash, string.Empty));
			list2.Add(SanitizeName(playerName));
			zdo.Set(PwGrantedNamesHash, JoinNames(list2));
		}

		internal static void ClearGrants(ZDO zdo)
		{
			if (zdo != null)
			{
				zdo.Set(PwGrantedIdsHash, string.Empty);
				zdo.Set(PwGrantedNamesHash, string.Empty);
			}
		}

		internal static string FormatPermittedNamesForHover(ZDO zdo)
		{
			if (zdo == null)
			{
				return string.Empty;
			}
			List<string> list = ParseNameList(zdo.GetString(PwGrantedNamesHash, string.Empty));
			if (list.Count == 0)
			{
				return string.Empty;
			}
			StringBuilder stringBuilder = new StringBuilder();
			int num = Math.Min(list.Count, 8);
			for (int i = 0; i < num; i++)
			{
				if (i > 0)
				{
					stringBuilder.Append(", ");
				}
				stringBuilder.Append(list[i]);
			}
			if (list.Count > 8)
			{
				stringBuilder.Append(", ...");
			}
			return stringBuilder.ToString();
		}

		private static string SanitizeName(string playerName)
		{
			if (string.IsNullOrEmpty(playerName))
			{
				return "Unknown";
			}
			return playerName.Replace('|'.ToString(), string.Empty).Trim();
		}

		private static List<long> ParseIdList(string raw)
		{
			List<long> list = new List<long>();
			if (string.IsNullOrEmpty(raw))
			{
				return list;
			}
			string[] array = raw.Split(new char[1] { ',' });
			for (int i = 0; i < array.Length; i++)
			{
				if (long.TryParse(array[i], out var result))
				{
					list.Add(result);
				}
			}
			return list;
		}

		private static List<string> ParseNameList(string raw)
		{
			List<string> list = new List<string>();
			if (string.IsNullOrEmpty(raw))
			{
				return list;
			}
			string[] array = raw.Split(new char[1] { '|' });
			foreach (string text in array)
			{
				if (!string.IsNullOrEmpty(text))
				{
					list.Add(text);
				}
			}
			return list;
		}

		private static string JoinIds(List<long> ids)
		{
			StringBuilder stringBuilder = new StringBuilder();
			for (int i = 0; i < ids.Count; i++)
			{
				if (i > 0)
				{
					stringBuilder.Append(',');
				}
				stringBuilder.Append(ids[i]);
			}
			return stringBuilder.ToString();
		}

		private static string JoinNames(List<string> names)
		{
			StringBuilder stringBuilder = new StringBuilder();
			for (int i = 0; i < names.Count; i++)
			{
				if (i > 0)
				{
					stringBuilder.Append('|');
				}
				stringBuilder.Append(names[i]);
			}
			return stringBuilder.ToString();
		}
	}
	internal static class ProtectedStorageRules
	{
		internal static readonly PrefabRuleSet Pieces = new PrefabRuleSet();

		internal static void ReloadRules()
		{
			GuildStructuresConfig cfg = GuildStructuresPlugin.Cfg;
			Pieces.Reload(cfg.ProtectedStorageExactNames.Value, cfg.ProtectedStorageContainsNames.Value);
		}
	}
}
namespace GuildStructures.Patches
{
	internal static class AccessHoverTextPatches
	{
		private const float GracePeriodSeconds = 5f;

		private static Player _trackedLocalPlayer;

		private static float _trackedLocalPlayerSpawnTime;

		internal static void Apply(Harmony harmony)
		{
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Expected O, but got Unknown
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Expected O, but got Unknown
			MethodInfo methodInfo = AccessTools.Method(typeof(Door), "GetHoverText", (Type[])null, (Type[])null);
			if (methodInfo == null)
			{
				throw new InvalidOperationException("Door.GetHoverText() not found - Valheim version mismatch?");
			}
			MethodInfo methodInfo2 = AccessTools.Method(typeof(Container), "GetHoverText", (Type[])null, (Type[])null);
			if (methodInfo2 == null)
			{
				throw new InvalidOperationException("Container.GetHoverText() not found - Valheim version mismatch?");
			}
			harmony.Patch((MethodBase)methodInfo, (HarmonyMethod)null, new HarmonyMethod(typeof(AccessHoverTextPatches), "Postfix_Door_GetHoverText", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			harmony.Patch((MethodBase)methodInfo2, (HarmonyMethod)null, new HarmonyMethod(typeof(AccessHoverTextPatches), "Postfix_Container_GetHoverText", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		}

		private static void Postfix_Door_GetHoverText(Door __instance, ref string __result)
		{
			ApplyNoAccessHover(((Component)__instance).gameObject, __instance.m_name, ref __result);
		}

		private static void Postfix_Container_GetHoverText(Container __instance, ref string __result)
		{
			ApplyNoAccessHover(((Component)__instance).gameObject, __instance.m_name, ref __result);
		}

		private static void ApplyNoAccessHover(GameObject go, string pieceName, ref string __result)
		{
			try
			{
				if (string.IsNullOrEmpty(__result))
				{
					return;
				}
				ZNetView component = go.GetComponent<ZNetView>();
				if ((Object)(object)component == (Object)null || !component.IsValid())
				{
					return;
				}
				ZDO zDO = component.GetZDO();
				if (zDO == null || !OwnershipPatches.ProtectedPieces.Matches(Utils.GetPrefabName(go)))
				{
					return;
				}
				Player localPlayer = Player.m_localPlayer;
				if (!((Object)(object)localPlayer == (Object)null) && GuildBridge.Resolve(localPlayer).Kind != GuildMembershipKind.Unknown)
				{
					Piece component2 = go.GetComponent<Piece>();
					if (!AccessEvaluator.CanInteract(zDO, localPlayer, component2) && !IsWithinPostConnectGracePeriod())
					{
						__result = Localization.instance.Localize(pieceName + "\n$piece_noaccess");
					}
				}
			}
			catch (Exception arg)
			{
				Log.Error($"Access hover-text check threw, leaving vanilla hover text as-is: {arg}");
			}
		}

		private static bool IsWithinPostConnectGracePeriod()
		{
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null)
			{
				return false;
			}
			if (localPlayer != _trackedLocalPlayer)
			{
				_trackedLocalPlayer = localPlayer;
				_trackedLocalPlayerSpawnTime = Time.time;
			}
			return Time.time - _trackedLocalPlayerSpawnTime < 5f;
		}
	}
	internal static class ContainerAccessPatches
	{
		internal static void Apply(Harmony harmony)
		{
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Expected O, but got Unknown
			MethodInfo methodInfo = AccessTools.Method(typeof(Container), "CheckAccess", (Type[])null, (Type[])null);
			if (methodInfo == null)
			{
				throw new InvalidOperationException("Container.CheckAccess(long) not found - Valheim version mismatch?");
			}
			harmony.Patch((MethodBase)methodInfo, new HarmonyMethod(typeof(ContainerAccessPatches), "Prefix_CheckAccess", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		}

		private static bool Prefix_CheckAccess(Container __instance, long playerID, ref bool __result)
		{
			try
			{
				ZNetView component = ((Component)__instance).GetComponent<ZNetView>();
				if ((Object)(object)component == (Object)null || !component.IsValid())
				{
					return true;
				}
				if (!component.IsOwner())
				{
					return true;
				}
				ZDO zDO = component.GetZDO();
				if (zDO == null || !OwnershipPatches.ProtectedPieces.Matches(Utils.GetPrefabName(((Component)__instance).gameObject)))
				{
					return true;
				}
				Piece component2 = ((Component)__instance).GetComponent<Piece>();
				string debugDetail;
				bool flag = AccessEvaluator.CanInteract(zDO, playerID, out debugDetail, component2);
				if (Log.IsDebugEnabled)
				{
					string prefabName = Utils.GetPrefabName(((Component)__instance).gameObject);
					Log.Debug($"[Container] CheckAccess player id {playerID} on '{prefabName}': " + (debugDetail ?? (flag ? "ALLOW" : "DENY")));
				}
				if (!flag)
				{
					__result = false;
					return false;
				}
				return true;
			}
			catch (Exception arg)
			{
				Log.Error($"Container access check threw, falling back to vanilla behaviour: {arg}");
				return true;
			}
		}
	}
	internal static class ContainerDenialMessagePatches
	{
		internal static void Apply(Harmony harmony)
		{
			Patch(harmony, "RPC_OpenRespons");
			Patch(harmony, "RPC_StackResponse");
			Patch(harmony, "RPC_TakeAllRespons");
		}

		private static void Patch(Harmony harmony, string methodName)
		{
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Expected O, but got Unknown
			MethodInfo methodInfo = AccessTools.Method(typeof(Container), methodName, (Type[])null, (Type[])null);
			if (methodInfo == null)
			{
				throw new InvalidOperationException("Container." + methodName + " not found - Valheim version mismatch?");
			}
			harmony.Patch((MethodBase)methodInfo, new HarmonyMethod(typeof(ContainerDenialMessagePatches), "Prefix_DenialResponse", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		}

		private static bool Prefix_DenialResponse(Container __instance, bool granted)
		{
			try
			{
				if (granted || (Object)(object)Player.m_localPlayer == (Object)null)
				{
					return true;
				}
				if (!IsLocalAccessDeniedByMod(__instance))
				{
					return true;
				}
				InventoryGui instance = InventoryGui.instance;
				if ((Object)(object)instance != (Object)null && instance.IsContainerOpen())
				{
					instance.Hide();
				}
				((Character)Player.m_localPlayer).Message((MessageType)2, "$msg_cantopen", 0, (Sprite)null);
				return false;
			}
			catch (Exception arg)
			{
				Log.Error($"Container denial-message rewrite threw, leaving vanilla message as-is: {arg}");
				return true;
			}
		}

		private static bool IsLocalAccessDeniedByMod(Container container)
		{
			ZNetView component = ((Component)container).GetComponent<ZNetView>();
			if ((Object)(object)component == (Object)null || !component.IsValid())
			{
				return false;
			}
			ZDO zDO = component.GetZDO();
			if (zDO == null)
			{
				return false;
			}
			string prefabName = Utils.GetPrefabName(((Component)container).gameObject);
			Player localPlayer = Player.m_localPlayer;
			long playerID = localPlayer.GetPlayerID();
			Piece component2 = ((Component)container).GetComponent<Piece>();
			if (ProtectedStorageRules.Pieces.Matches(prefabName) && PasswordZdo.HasPassword(zDO))
			{
				long num = (((Object)(object)component2 != (Object)null) ? component2.GetCreator() : 0);
				if ((num == 0L || playerID != num) && !PasswordZdo.IsGranted(zDO, playerID) && !PasswordUI.IsLocallyGranted(zDO))
				{
					return true;
				}
			}
			if (OwnershipPatches.ProtectedPieces.Matches(prefabName) && AccessEvaluator.IsConfidentLocalDeny(zDO, localPlayer, component2))
			{
				return true;
			}
			return false;
		}
	}
	internal static class ContainerGuildInteractPatches
	{
		internal static void Apply(Harmony harmony)
		{
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Expected O, but got Unknown
			MethodInfo methodInfo = AccessTools.Method(typeof(Container), "Interact", (Type[])null, (Type[])null);
			if (methodInfo == null)
			{
				throw new InvalidOperationException("Container.Interact(Humanoid,bool,bool) not found - Valheim version mismatch?");
			}
			harmony.Patch((MethodBase)methodInfo, new HarmonyMethod(typeof(ContainerGuildInteractPatches), "Prefix_Interact", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		}

		private static bool Prefix_Interact(Container __instance, Humanoid character, bool hold, bool alt, ref bool __result)
		{
			try
			{
				if (hold || !OwnershipPatches.ProtectedPieces.HasAnyRules)
				{
					return true;
				}
				Player val = (Player)(object)((character is Player) ? character : null);
				if ((Object)(object)val == (Object)null)
				{
					return true;
				}
				ZNetView component = ((Component)__instance).GetComponent<ZNetView>();
				if ((Object)(object)component == (Object)null || !component.IsValid())
				{
					return true;
				}
				ZDO zDO = component.GetZDO();
				string prefabName = Utils.GetPrefabName(((Component)__instance).gameObject);
				if (zDO == null || !OwnershipPatches.ProtectedPieces.Matches(prefabName))
				{
					return true;
				}
				Piece component2 = ((Component)__instance).GetComponent<Piece>();
				if (!AccessEvaluator.IsConfidentLocalDeny(zDO, val, component2))
				{
					return true;
				}
				if (Log.IsDebugEnabled)
				{
					Log.Debug("[Container] Interact blocked locally on '" + prefabName + "' (confident guild/pending deny) - no RequestOpen.");
				}
				((Character)val).Message((MessageType)2, "$msg_cantopen", 0, (Sprite)null);
				__result = false;
				return false;
			}
			catch (Exception arg)
			{
				Log.Error($"Guild container Interact gate threw, falling back to vanilla: {arg}");
				return true;
			}
		}
	}
	internal static class DoorAccessPatches
	{
		internal static void Apply(Harmony harmony)
		{
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Expected O, but got Unknown
			MethodInfo methodInfo = AccessTools.Method(typeof(Door), "CanInteract", (Type[])null, (Type[])null);
			if (methodInfo == null)
			{
				throw new InvalidOperationException("Door.CanInteract() not found - Valheim version mismatch?");
			}
			harmony.Patch((MethodBase)methodInfo, new HarmonyMethod(typeof(DoorAccessPatches), "Prefix_CanInteract", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		}

		private static bool Prefix_CanInteract()
		{
			return true;
		}
	}
	internal static class DoorRpcAccessPatches
	{
		internal static void Apply(Harmony harmony)
		{
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Expected O, but got Unknown
			MethodInfo methodInfo = AccessTools.Method(typeof(Door), "RPC_UseDoor", (Type[])null, (Type[])null);
			if (methodInfo == null)
			{
				throw new InvalidOperationException("Door.RPC_UseDoor(long, bool) not found - Valheim version mismatch?");
			}
			harmony.Patch((MethodBase)methodInfo, new HarmonyMethod(typeof(DoorRpcAccessPatches), "Prefix_RPC_UseDoor", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		}

		private static bool Prefix_RPC_UseDoor(Door __instance, long uid)
		{
			try
			{
				ZNetView component = ((Component)__instance).GetComponent<ZNetView>();
				if ((Object)(object)component == (Object)null || !component.IsValid())
				{
					return true;
				}
				if (!component.IsOwner())
				{
					return true;
				}
				ZDO zDO = component.GetZDO();
				if (zDO == null || !OwnershipPatches.ProtectedPieces.Matches(Utils.GetPrefabName(((Component)__instance).gameObject)))
				{
					return true;
				}
				long num = RpcIdentity.ResolvePlayerId(uid);
				Piece component2 = ((Component)__instance).GetComponent<Piece>();
				string debugDetail;
				bool flag = AccessEvaluator.CanInteract(zDO, num, out debugDetail, component2);
				if (Log.IsDebugEnabled)
				{
					string prefabName = Utils.GetPrefabName(((Component)__instance).gameObject);
					Log.Debug($"[Door RPC] UseDoor from RPC sender {uid} (player id {num}) on '{prefabName}': " + (debugDetail ?? (flag ? "ALLOW" : "DENY")));
				}
				if (!flag)
				{
					return false;
				}
				return true;
			}
			catch (Exception arg)
			{
				Log.Error($"Door RPC access re-validation threw, falling back to vanilla behaviour: {arg}");
				return true;
			}
		}
	}
	internal static class GuildCreateSafetyPatches
	{
		internal static void Apply(Harmony harmony)
		{
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Expected O, but got Unknown
			MethodInfo methodInfo = AccessTools.Method(typeof(API), "CreateGuild", new Type[2]
			{
				typeof(string),
				typeof(PlayerReference)
			}, (Type[])null);
			if (methodInfo == null)
			{
				throw new InvalidOperationException("Guilds.API.CreateGuild(string, PlayerReference) not found - Guilds mod version mismatch?");
			}
			harmony.Patch((MethodBase)methodInfo, new HarmonyMethod(typeof(GuildCreateSafetyPatches), "Prefix_CreateGuild", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		}

		private static void Prefix_CreateGuild(string name, PlayerReference leader)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if (API.RemovePlayerFromGuild(leader) && Log.IsDebugEnabled)
				{
					Log.Debug("[Guilds] Removed '" + leader.name + "' from their previous guild before letting them create/lead '" + name + "' (prevents ending up in two guilds at once).");
				}
			}
			catch (Exception arg)
			{
				Log.Error($"[Guild create safety] Failed to pre-emptively leave any existing guild before CreateGuild('{name}'): {arg}");
			}
		}
	}
	internal static class GuildRemovePatches
	{
		private static readonly FieldRef<Player, int> RemoveRayMask = AccessTools.FieldRefAccess<Player, int>("m_removeRayMask");

		internal static void Apply(Harmony harmony)
		{
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Expected O, but got Unknown
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Expected O, but got Unknown
			MethodInfo methodInfo = AccessTools.Method(typeof(Player), "RemovePiece", (Type[])null, (Type[])null);
			if (methodInfo == null)
			{
				throw new InvalidOperationException("Player.RemovePiece() not found - Valheim version mismatch?");
			}
			MethodInfo methodInfo2 = AccessTools.Method(typeof(WearNTear), "RPC_Remove", (Type[])null, (Type[])null);
			if (methodInfo2 == null)
			{
				throw new InvalidOperationException("WearNTear.RPC_Remove(long,bool) not found - Valheim version mismatch?");
			}
			harmony.Patch((MethodBase)methodInfo, new HarmonyMethod(typeof(GuildRemovePatches), "Prefix_RemovePiece", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			harmony.Patch((MethodBase)methodInfo2, new HarmonyMethod(typeof(GuildRemovePatches), "Prefix_RPC_Remove", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		}

		private static bool Prefix_RemovePiece(Player __instance, ref bool __result)
		{
			//IL_0057: 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_007c: 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)
			try
			{
				if (!OwnershipPatches.ProtectedPieces.HasAnyRules || (Object)(object)__instance == (Object)null)
				{
					return true;
				}
				if ((Object)(object)GameCamera.instance == (Object)null || (Object)(object)((Character)__instance).m_eye == (Object)null)
				{
					return true;
				}
				int num = RemoveRayMask.Invoke(__instance);
				RaycastHit val = default(RaycastHit);
				if (!Physics.Raycast(((Component)GameCamera.instance).transform.position, ((Component)GameCamera.instance).transform.forward, ref val, 50f, num) || Vector3.Distance(((RaycastHit)(ref val)).point, ((Character)__instance).m_eye.position) >= __instance.m_maxPlaceDistance)
				{
					return true;
				}
				Piece componentInParent = ((Component)((RaycastHit)(ref val)).collider).GetComponentInParent<Piece>();
				if ((Object)(object)componentInParent == (Object)null)
				{
					return true;
				}
				long playerID = __instance.GetPlayerID();
				if (!GuildRemoveGuard.ShouldBlockRemove(componentInParent, playerID))
				{
					return true;
				}
				ZNetView component = ((Component)componentInParent).GetComponent<ZNetView>();
				ZDO zdo = (((Object)(object)component != (Object)null && component.IsValid()) ? component.GetZDO() : null);
				GuildRemoveGuard.LogDenied(Utils.GetPrefabName(((Component)componentInParent).gameObject), playerID, zdo, "RemovePiece");
				GuildRemoveGuard.ShowDeniedMessage(__instance);
				__result = false;
				return false;
			}
			catch (Exception arg)
			{
				Log.Error($"Guild remove (RemovePiece) threw, falling back to vanilla: {arg}");
				return true;
			}
		}

		private static bool Prefix_RPC_Remove(WearNTear __instance, long sender, bool blockDrop)
		{
			try
			{
				if (!OwnershipPatches.ProtectedPieces.HasAnyRules || (Object)(object)__instance == (Object)null)
				{
					return true;
				}
				ZNetView component = ((Component)__instance).GetComponent<ZNetView>();
				if ((Object)(object)component == (Object)null || !component.IsValid() || !component.IsOwner())
				{
					return true;
				}
				Piece component2 = ((Component)__instance).GetComponent<Piece>();
				if ((Object)(object)component2 == (Object)null)
				{
					return true;
				}
				long removerPlayerId = RpcIdentity.ResolvePlayerId(sender);
				if (!GuildRemoveGuard.ShouldBlockRemove(component2, removerPlayerId))
				{
					return true;
				}
				GuildRemoveGuard.LogDenied(Utils.GetPrefabName(((Component)component2).gameObject), removerPlayerId, component.GetZDO(), "RPC_Remove");
				return false;
			}
			catch (Exception arg)
			{
				Log.Error($"Guild remove (RPC_Remove) threw, falling back to vanilla: {arg}");
				return true;
			}
		}
	}
	internal static class OwnershipPatches
	{
		internal static readonly PrefabRuleSet ProtectedPieces = new PrefabRuleSet();

		internal static void Apply(Harmony harmony)
		{
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Expected O, but got Unknown
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Expected O, but got Unknown
			ReloadRules();
			MethodInfo methodInfo = AccessTools.Method(typeof(Piece), "Awake", (Type[])null, (Type[])null);
			if (methodInfo == null)
			{
				throw new InvalidOperationException("Piece.Awake() not found - Valheim version mismatch?");
			}
			MethodInfo methodInfo2 = AccessTools.Method(typeof(Piece), "SetCreator", (Type[])null, (Type[])null);
			if (methodInfo2 == null)
			{
				throw new InvalidOperationException("Piece.SetCreator(long) not found - Valheim version mismatch?");
			}
			harmony.Patch((MethodBase)methodInfo, (HarmonyMethod)null, new HarmonyMethod(typeof(OwnershipPatches), "Postfix_Piece_Awake", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			harmony.Patch((MethodBase)methodInfo2, (HarmonyMethod)null, new HarmonyMethod(typeof(OwnershipPatches), "Postfix_Piece_SetCreator", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		}

		internal static void ReloadRules()
		{
			GuildStructuresConfig cfg = GuildStructuresPlugin.Cfg;
			ProtectedPieces.Reload(cfg.ProtectedExactNames.Value, cfg.ProtectedContainsNames.Value);
		}

		private static void Postfix_Piece_Awake(Piece __instance)
		{
			OnPieceReady(__instance);
		}

		private static void Postfix_Piece_SetCreator(Piece __instance)
		{
			OnPieceReady(__instance);
		}

		private static void OnPieceReady(Piece piece)
		{
			try
			{
				LogDiscoveryIfEnabled(piece);
				StampIfNeeded(piece);
			}
			catch (Exception arg)
			{
				Log.Error($"Ownership stamping failed for '{((piece != null) ? ((Object)piece).name : null)}': {arg}");
			}
		}

		private static void LogDiscoveryIfEnabled(Piece piece)
		{
			if (!((Object)(object)piece == (Object)null) && GuildStructuresPlugin.Cfg.DebugLogging.Value)
			{
				Player localPlayer = Player.m_localPlayer;
				if (!((Object)(object)localPlayer == (Object)null) && piece.GetCreator() == localPlayer.GetPlayerID() && Log.IsDebugEnabled)
				{
					Log.Debug("[Prefab Discovery] You just placed '" + Utils.GetPrefabName(((Component)piece).gameObject) + "' - use this exact string in the config's 'Exact Names' fields.");
				}
			}
		}

		private static void StampIfNeeded(Piece piece)
		{
			if ((Object)(object)piece == (Object)null || !ProtectedPieces.HasAnyRules)
			{
				return;
			}
			string prefabName = Utils.GetPrefabName(((Component)piece).gameObject);
			if (!ProtectedPieces.Matches(prefabName))
			{
				return;
			}
			ZNetView component = ((Component)piece).GetComponent<ZNetView>();
			if ((Object)(object)component == (Object)null || !component.IsValid() || !component.IsOwner())
			{
				return;
			}
			ZDO zDO = component.GetZDO();
			if (zDO == null || GuildZdo.IsOwned(zDO))
			{
				return;
			}
			long creator = piece.GetCreator();
			if (creator == 0L)
			{
				if (Log.IsDebugEnabled)
				{
					Log.Debug("'" + prefabName + "' has no recorded creator yet; leaving unowned for now.");
				}
				return;
			}
			int? guildIdPreferLocal = GuildBridge.GetGuildIdPreferLocal(creator);
			if (!guildIdPreferLocal.HasValue)
			{
				if (Log.IsDebugEnabled)
				{
					Log.Debug($"Could not resolve a Guild for creator uid {creator} on '{prefabName}'; leaving unowned.");
				}
				return;
			}
			int currentGeneration = GuildGenerationTracker.GetCurrentGeneration(guildIdPreferLocal.Value);
			string guildName = GuildBridge.GetGuildName(guildIdPreferLocal.Value);
			string text = ResolveCreatorName(creator);
			GuildZdo.SetOwner(zDO, guildIdPreferLocal.Value, currentGeneration, guildName, text);
			if (Log.IsDebugEnabled)
			{
				Log.Debug($"Stamped '{prefabName}' as locked by Guild id {guildIdPreferLocal.Value} batch {currentGeneration} '{guildName}' placer '{text}' (creator uid {creator}).");
			}
		}

		private static string ResolveCreatorName(long creatorUid)
		{
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer != (Object)null && localPlayer.GetPlayerID() == creatorUid)
			{
				return localPlayer.GetPlayerName();
			}
			try
			{
				List<Player> allPlayers = Player.GetAllPlayers();
				if (allPlayers != null)
				{
					for (int i = 0; i < allPlayers.Count; i++)
					{
						Player val = allPlayers[i];
						if ((Object)(object)val != (Object)null && val.GetPlayerID() == creatorUid)
						{
							return val.GetPlayerName();
						}
					}
				}
			}
			catch (Exception arg)
			{
				Log.Error($"[Debug Fields] Failed to resolve creator display name for uid {creatorUid}: {arg}");
			}
			return creatorUid.ToString();
		}
	}
	internal static class PasswordAccessPatches
	{
		internal static void Apply(Harmony harmony)
		{
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Expected O, but got Unknown
			MethodInfo methodInfo = AccessTools.Method(typeof(Container), "CheckAccess", (Type[])null, (Type[])null);
			if (methodInfo == null)
			{
				throw new InvalidOperationException("Container.CheckAccess(long) not found - Valheim version mismatch?");
			}
			harmony.Patch((MethodBase)methodInfo, new HarmonyMethod(typeof(PasswordAccessPatches), "Prefix_CheckAccess", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		}

		private static bool Prefix_CheckAccess(Container __instance, long playerID, ref bool __result)
		{
			try
			{
				if (!ProtectedStorageRules.Pieces.HasAnyRules)
				{
					return true;
				}
				ZNetView component = ((Component)__instance).GetComponent<ZNetView>();
				if ((Object)(object)component == (Object)null || !component.IsValid())
				{
					return true;
				}
				ZDO zDO = component.GetZDO();
				if (zDO == null || !ProtectedStorageRules.Pieces.Matches(Utils.GetPrefabName(((Component)__instance).gameObject)))
				{
					return true;
				}
				if (!component.IsOwner())
				{
					return true;
				}
				if (!PasswordZdo.HasPassword(zDO))
				{
					return true;
				}
				string text = null;
				Piece component2 = ((Component)__instance).GetComponent<Piece>();
				long num = (((Object)(object)component2 != (Object)null) ? component2.GetCreator() : 0);
				if (num != 0L && playerID == num)
				{
					if (Log.IsDebugEnabled)
					{
						text = Utils.GetPrefabName(((Component)__instance).gameObject);
						Log.Debug($"[Password] Player id {playerID} allowed into '{text}' (owner).");
					}
					return true;
				}
				if (PasswordZdo.IsGranted(zDO, playerID))
				{
					if (Log.IsDebugEnabled)
					{
						text = text ?? Utils.GetPrefabName(((Component)__instance).gameObject);
						Log.Debug($"[Password] Player id {playerID} allowed into '{text}' (valid password grant this session).");
					}
					return true;
				}
				if (Log.IsDebugEnabled)
				{
					text = text ?? Utils.GetPrefabName(((Component)__instance).gameObject);
					Log.Debug($"[Password] Player id {playerID} DENIED access to '{text}' " + "(not the owner, and no valid password grant this session).");
				}
				__result = false;
				return false;
			}
			catch (Exception arg)
			{
				Log.Error($"Password storage access check threw, falling back to vanilla behaviour: {arg}");
				return true;
			}
		}
	}
	internal static class PasswordHoverTextPatches
	{
		private const string AccentColor = "#7DCE82";

		internal static void Apply(Harmony harmony)
		{
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Expected O, but got Unknown
			MethodInfo methodInfo = AccessTools.Method(typeof(Container), "GetHoverText", (Type[])null, (Type[])null);
			if (methodInfo == null)
			{
				throw new InvalidOperationException("Container.GetHoverText() not found - Valheim version mismatch?");
			}
			harmony.Patch((MethodBase)methodInfo, (HarmonyMethod)null, new HarmonyMethod(typeof(PasswordHoverTextPatches), "Postfix_GetHoverText", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		}

		private static void Postfix_GetHoverText(Container __instance, ref string __result)
		{
			try
			{
				if (string.IsNullOrEmpty(__result) || !ProtectedStorageRules.Pieces.HasAnyRules)
				{
					return;
				}
				ZNetView component = ((Component)__instance).GetComponent<ZNetView>();
				if ((Object)(object)component == (Object)null || !component.IsValid())
				{
					return;
				}
				ZDO zDO = component.GetZDO();
				if (zDO == null || !ProtectedStorageRules.Pieces.Matches(Utils.GetPrefabName(((Component)__instance).gameObject)))
				{
					return;
				}
				Player localPlayer = Player.m_localPlayer;
				if ((Object)(object)localPlayer == (Object)null)
				{
					return;
				}
				Piece component2 = ((Component)__instance).GetComponent<Piece>();
				long num = (((Object)(object)component2 != (Object)null) ? component2.GetCreator() : 0);
				bool num2 = num != 0L && localPlayer.GetPlayerID() == num;
				bool flag = PasswordZdo.HasPassword(zDO);
				string value = PasswordZdo.GetOwnerName(zDO);
				if (string.IsNullOrEmpty(value))
				{
					value = "Unknown";
				}
				string text = ((Localization.instance != null) ? Localization.instance.Localize(__instance.m_name) : __instance.m_name);
				if (flag)
				{
					text += " (<color=#7DCE82>Password protected</color>)";
				}
				string value2 = ExtractBodyAfterTitle(__result);
				StringBuilder stringBuilder = new StringBuilder();
				stringBuilder.Append(text);
				if (!string.IsNullOrEmpty(value2))
				{
					stringBuilder.Append('\n');
					stringBuilder.Append(value2);
				}
				stringBuilder.Append("\n<color=");
				stringBuilder.Append("#7DCE82");
				stringBuilder.Append(">Owner:</color> ");
				stringBuilder.Append(value);
				if (num2)
				{
					stringBuilder.Append('\n');
					stringBuilder.Append(flag ? "[<color=yellow>Shift + E</color>] Change Password" : "[<color=yellow>Shift + E</color>] Set Password");
				}
				if (flag)
				{
					stringBuilder.Append("\n<color=");
					stringBuilder.Append("#7DCE82");
					stringBuilder.Append(">Permitted:</color> ");
					string value3 = PasswordZdo.FormatPermittedNamesForHover(zDO);
					if (!string.IsNullOrEmpty(value3))
					{
						stringBuilder.Append(value3);
					}
				}
				__result = stringBuilder.ToString();
			}
			catch (Exception arg)
			{
				Log.Error($"Password storage hover-text threw, leaving vanilla hover text as-is: {arg}");
			}
		}

		private static string ExtractBodyAfterTitle(string vanillaHover)
		{
			if (string.IsNullOrEmpty(vanillaHover))
			{
				return string.Empty;
			}
			int num = vanillaHover.IndexOf('\n');
			if (num < 0 || num >= vanillaHover.Length - 1)
			{
				return string.Empty;
			}
			return vanillaHover.Substring(num + 1);
		}
	}
	internal static class PasswordInteractPatches
	{
		internal static void Apply(Harmony harmony)
		{
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Expected O, but got Unknown
			MethodInfo methodInfo = AccessTools.Method(typeof(Container), "Interact", (Type[])null, (Type[])null);
			if (methodInfo == null)
			{
				throw new InvalidOperationException("Container.Interact(Humanoid,bool,bool) not found - Valheim version mismatch?");
			}
			harmony.Patch((MethodBase)methodInfo, new HarmonyMethod(typeof(PasswordInteractPatches), "Prefix_Interact", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		}

		private static bool Prefix_Interact(Container __instance, Humanoid character, bool hold, bool alt, ref bool __result)
		{
			try
			{
				if (hold || !ProtectedStorageRules.Pieces.HasAnyRules)
				{
					return true;
				}
				ZNetView component = ((Component)__instance).GetComponent<ZNetView>();
				if ((Object)(object)component == (Object)null || !component.IsValid())
				{
					return true;
				}
				ZDO zDO = component.GetZDO();
				if (zDO == null || !ProtectedStorageRules.Pieces.Matches(Utils.GetPrefabName(((Component)__instance).gameObject)))
				{
					return true;
				}
				Player val = (Player)(object)((character is Player) ? character : null);
				if ((Object)(object)val == (Object)null)
				{
					return true;
				}
				Piece component2 = ((Component)__instance).GetComponent<Piece>();
				long num = (((Object)(object)component2 != (Object)null) ? component2.GetCreator() : 0);
				bool flag = num != 0L && val.GetPlayerID() == num;
				bool flag2 = Input.GetKey((KeyCode)304) || Input.GetKey((KeyCode)303);
				if (flag && flag2)
				{
					if (Log.IsDebugEnabled)
					{
						Log.Debug("[Password] Owner opened the set/change/remove-password UI for '" + Utils.GetPrefabName(((Component)__instance).gameObject) + "'.");
					}
					PasswordUI.ShowSetPassword(component);
					__result = false;
					return false;
				}
				if (!PasswordZdo.HasPassword(zDO) || flag)
				{
					return true;
				}
				long playerID = val.GetPlayerID();
				if (PasswordZdo.IsGranted(zDO, playerID) || PasswordUI.IsLocallyGranted(zDO))
				{
					if (Log.IsDebugEnabled)
					{
						Log.Debug("[Password] Already-proven password for '" + Utils.GetPrefabName(((Component)__instance).gameObject) + "' (ZDO grant and/or this session) - letting the open attempt through to the server.");
					}
					return true;
				}
				if (Log.IsDebugEnabled)
				{
					Log.Debug("[Password] Prompting for password on '" + Utils.GetPrefabName(((Component)__instance).gameObject) + "'.");
				}
				PasswordUI.ShowEnterPassword(component);
				__result = false;
				return false;
			}
			catch (Exception arg)
			{
				Log.Error($"Password storage interact check threw, falling back to vanilla behaviour: {arg}");
				return true;
			}
		}
	}
	internal static class PasswordRemovePatches
	{
		private static readonly FieldRef<Player, int> RemoveRayMask = AccessTools.FieldRefAccess<Player, int>("m_removeRayMask");

		internal static void Apply(Harmony harmony)
		{
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Expected O, but got Unknown
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Expected O, but got Unknown
			MethodInfo methodInfo = AccessTools.Method(typeof(Player), "RemovePiece", (Type[])null, (Type[])null);
			if (methodInfo == null)
			{
				throw new InvalidOperationException("Player.RemovePiece() not found - Valheim version mismatch?");
			}
			MethodInfo methodInfo2 = AccessTools.Method(typeof(WearNTear), "RPC_Remove", (Type[])null, (Type[])null);
			if (methodInfo2 == null)
			{
				throw new InvalidOperationException("WearNTear.RPC_Remove(long,bool) not found - Valheim version mismatch?");
			}
			harmony.Patch((MethodBase)methodInfo, new HarmonyMethod(typeof(PasswordRemovePatches), "Prefix_RemovePiece", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			harmony.Patch((MethodBase)methodInfo2, new HarmonyMethod(typeof(PasswordRemovePatches), "Prefix_RPC_Remove", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		}

		private static bool Prefix_RemovePiece(Player __instance, ref bool __result)
		{
			//IL_0057: 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_007c: 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)
			try
			{
				if (!ProtectedStorageRules.Pieces.HasAnyRules || (Object)(object)__instance == (Object)null)
				{
					return true;
				}
				if ((Object)(object)GameCamera.instance == (Object)null || (Object)(object)((Character)__instance).m_eye == (Object)null)
				{
					return true;
				}
				int num = RemoveRayMask.Invoke(__instance);
				RaycastHit val = default(RaycastHit);
				if (!Physics.Raycast(((Component)GameCamera.instance).transform.position, ((Component)GameCamera.instance).transform.forward, ref val, 50f, num) || Vector3.Distance(((RaycastHit)(ref val)).point, ((Character)__instance).m_eye.position) >= __instance.m_maxPlaceDistance)
				{
					return true;
				}
				Piece componentInParent = ((Component)((RaycastHit)(ref val)).collider).GetComponentInParent<Piece>();
				if ((Object)(object)componentInParent == (Object)null)
				{
					return true;
				}
				long playerID = __instance.GetPlayerID();
				if (!PasswordRemoveGuard.ShouldBlockRemove(componentInParent, playerID))
				{
					return true;
				}
				PasswordRemoveGuard.LogDenied(Utils.GetPrefabName(((Component)componentInParent).gameObject), playerID, componentInParent.GetCreator(), "RemovePiece");
				PasswordRemoveGuard.ShowDeniedMessage(__instance);
				__result = false;
				return false;
			}
			catch (Exception arg)
			{
				Log.Error($"Password remove (RemovePiece) threw, falling back to vanilla: {arg}");
				return true;
			}
		}

		private static bool Prefix_RPC_Remove(WearNTear __instance, long sender, bool blockDrop)
		{
			try
			{
				if (!ProtectedStorageRules.Pieces.HasAnyRules || (Object)(object)__instance == (Object)null)
				{
					return true;
				}
				ZNetView component = ((Component)__instance).GetComponent<ZNetView>();
				if ((Object)(object)component == (Object)null || !component.IsValid() || !component.IsOwner())
				{
					return true;
				}
				Piece component2 = ((Component)__instance).GetComponent<Piece>();
				if ((Object)(object)component2 == (Object)null)
				{
					return true;
				}
				long removerPlayerId = RpcIdentity.ResolvePlayerId(sender);
				if (!PasswordRemoveGuard.ShouldBlockRemove(component2, removerPlayerId))
				{
					return true;
				}
				PasswordRemoveGuard.LogDenied(Utils.GetPrefabName(((Component)component2).gameObject), removerPlayerId, component2.GetCreator(), "RPC_Remove");
				return false;
			}
			catch (Exception arg)
			{
				Log.Error($"Password remove (RPC_Remove) threw, falling back to vanilla: {arg}");
				return true;
			}
		}
	}
	internal static class PasswordRpcPatches
	{
		internal static void Apply(Harmony harmony)
		{
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Expected O, but got Unknown
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Expected O, but got Unknown
			ProtectedStorageRules.ReloadRules();
			MethodInfo methodInfo = AccessTools.Method(typeof(Piece), "Awake", (Type[])null, (Type[])null);
			if (methodInfo == null)
			{
				throw new InvalidOperationException("Piece.Awake() not found - Valheim version mismatch?");
			}
			MethodInfo methodInfo2 = AccessTools.Method(typeof(Piece), "SetCreator", (Type[])null, (Type[])null);
			if (methodInfo2 == null)
			{
				throw new InvalidOperationException("Piece.SetCreator(long) not found - Valheim version mismatch?");
			}
			harmony.Patch((MethodBase)methodInfo, (HarmonyMethod)null, new HarmonyMethod(typeof(PasswordRpcPatches), "Postfix_Piece_Awake", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			harmony.Patch((MethodBase)methodInfo2, (HarmonyMethod)null, new HarmonyMethod(typeof(PasswordRpcPatches), "Postfix_Piece_SetCreator", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		}

		private static void Postfix_Piece_Awake(Piece __instance)
		{
			try
			{
				RegisterRpcsIfNeeded(__instance);
				StampOwnerNameIfNeeded(__instance);
			}
			catch (Exception arg)
			{
				Log.Error($"Failed to init password storage for '{((__instance != null) ? ((Object)__instance).name : null)}': {arg}");
			}
		}

		private static void Postfix_Piece_SetCreator(Piece __instance)
		{
			try
			{
				StampOwnerNameIfNeeded(__instance);
			}
			catch (Exception arg)
			{
				Log.Error($"Failed to stamp password owner name for '{((__instance != null) ? ((Object)__instance).name : null)}': {arg}");
			}
		}

		private static void RegisterRpcsIfNeeded(Piece piece)
		{
			if ((Object)(object)piece == (Object)null || !ProtectedStorageRules.Pieces.HasAnyRules)
			{
				return;
			}
			string prefabName = Utils.GetPrefabName(((Component)piece).gameObject);
			if (ProtectedStorageRules.Pieces.Matches(prefabName))
			{
				ZNetView component = ((Component)piece).GetComponent<ZNetView>();
				if (!((Object)(object)component == (Object)null) && component.IsValid())
				{
					PasswordRpc.RegisterForPiece(piece, component);
				}
			}
		}

		private static void StampOwnerNameIfNeeded(Piece piece)
		{
			if ((Object)(object)piece == (Object)null || !ProtectedStorageRules.Pieces.HasAnyRules)
			{
				return;
			}
			string prefabName = Utils.GetPrefabName(((Component)piece).gameObject);
			if (!ProtectedStorageRules.Pieces.Matches(prefabName))
			{
				return;
			}
			ZNetView component = ((Component)piece).GetComponent<ZNetView>();
			if ((Object)(object)component == (Object)null || !component.IsValid() || !component.IsOwner())
			{
				return;
			}
			ZDO zDO = component.GetZDO();
			if (zDO != null && string.IsNullOrEmpty(PasswordZdo.GetOwnerName(zDO)))
			{
				long creator = piece.GetCreator();
				if (creator != 0L)
				{
					PasswordZdo.EnsureOwnerName(zDO, PlayerNameResolver.Resolve(creator));
				}
			}
		}
	}
	internal static class PasswordUiRestorePatches
	{
		internal static void Apply(Harmony harmony)
		{
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Expected O, but got Unknown
			MethodInfo methodInfo = AccessTools.Method(typeof(TextInput), "Hide", (Type[])null, (Type[])null);
			if (methodInfo == null)
			{
				throw new InvalidOperationException("TextInput.Hide() not found - Valheim version mismatch?");
			}
			harmony.Patch((MethodBase)methodInfo, (HarmonyMethod)null, new HarmonyMethod(typeof(PasswordUiRestorePatches), "Postfix_Hide", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		}

		private static void Postfix_Hide()
		{
			try
			{
				PasswordUI.OnTextInputHidden();
			}
			catch (Exception arg)
			{
				Log.Error($"Failed to restore TextInput state after password prompt: {arg}");
			}
		}
	}
	internal static class PatchInit
	{
		internal static void ApplyAll(Harmony harmony)
		{
			SafeApply(harmony, "Guild dual-membership prevention (Guilds.API.CreateGuild)", GuildCreateSafetyPatches.Apply);
			SafeApply(harmony, "Ownership stamping (Piece.Awake + SetCreator)", OwnershipPatches.Apply);
			SafeApply(harmony, "Door access control", DoorAccessPatches.Apply);
			SafeApply(harmony, "Door RPC server-side re-validation (Door.RPC_UseDoor)", DoorRpcAccessPatches.Apply);
			SafeApply(harmony, "Container access control", ContainerAccessPatches.Apply);
			SafeApply(harmony, "Guild container Interact gate (confident local deny)", ContainerGuildInteractPatches.Apply);
			SafeApply(harmony, "Access denial hover text (Door/Container.GetHoverText)", AccessHoverTextPatches.Apply);
			SafeApply(harmony, "Password storage RPC registration (Piece.Awake)", PasswordRpcPatches.Apply);
			SafeApply(harmony, "Password storage access control (Container.CheckAccess)", PasswordAccessPatches.Apply);
			SafeApply(harmony, "Password storage interaction (Container.Interact)", PasswordInteractPatches.Apply);
			SafeApply(harmony, "Password storage UI restore (TextInput.Hide)", PasswordUiRestorePatches.Apply);
			SafeApply(harmony, "Password storage hover text (Container.GetHoverText)", PasswordHoverTextPatches.Apply);
			SafeApply(harmony, "Password storage owner-only de-hammer (RemovePiece + RPC_Remove)", PasswordRemovePatches.Apply);
			SafeApply(harmony, "Guild protected piece de-hammer (RemovePiece + RPC_Remove)", GuildRemovePatches.Apply);
			SafeApply(harmony, "Container denial message rewrite (Open/Stack/TakeAll response)", ContainerDenialMessagePatches.Apply);
		}

		private static void SafeApply(Harmony harmony, string label, Action<Harmony> apply)
		{
			try
			{
				apply(harmony);
				Log.Info("[Patch OK] " + label);
			}
			catch (Exception ex)
			{
				Log.Error("[Patch FAILED] " + label + ": " + ex.Message + "\nThis feature will be inactive; every other Guild Structures feature keeps working. This usually means a Valheim/BepInEx update changed a method signature - report the full error below to the mod maintainer.\n" + ex);
			}
		}
	}
}
namespace GuildStructures.Ownership
{
	internal static class AccessEvaluator
	{
		internal static bool CanInteract(ZDO zdo, Player interactingPlayer, Piece piece = null)
		{
			if (!GuildZdo.IsGuildCheckEnabled(zdo))
			{
				return true;
			}
			long interactingPlayerUid = (((Object)(object)interactingPlayer != (Object)null) ? interactingPlayer.GetPlayerID() : 0);
			if (!TryOwnedOrPending(zdo, piece, interactingPlayerUid, out var allow))
			{
				return allow;
			}
			if ((Object)(object)interactingPlayer == (Object)null)
			{
				return GuildStructuresPlugin.Cfg.AllowAccessIfUnowned.Value;
			}
			return Decide(zdo, GuildBridge.Resolve(interactingPlayer));
		}

		internal static bool CanInteract(ZDO zdo, long interactingPlayerUid, Piece piece = null)
		{
			if (!GuildZdo.IsGuildCheckEnabled(zdo))
			{
				return true;
			}
			if (!TryOwnedOrPending(zdo, piece, interactingPlayerUid, out var allow))
			{
				return allow;
			}
			return Decide(zdo, GuildBridge.ResolvePreferLocal(interactingPlayerUid));
		}

		internal static bool CanInteract(ZDO zdo, long interactingPlayerUid, out string debugDetail, Piece piece = null)
		{
			debugDetail = null;
			bool isDebugEnabled = Log.IsDebugEnabled;
			if (!GuildZdo.IsGuildCheckEnabled(zdo))
			{
				if (isDebugEnabled)
				{
					debugDetail = "faction check disabled on piece => ALLOW";
				}
				return true;
			}
			if (!TryOwnedOrPending(zdo, piece, interactingPlayerUid, out var allow, out var debugDetail2))
			{
				if (isDebugEnabled)
				{
					debugDetail = debugDetail2;
				}
				return allow;
			}
			GuildMembership membership = GuildBridge.ResolvePreferLocal(interactingPlayerUid);
			bool flag = Decide(zdo, membership);
			if (isDebugEnabled)
			{
				debugDetail = Describe(zdo, membership, interactingPlayerUid.ToString(), flag);
			}
			return flag;
		}

		internal static bool IsConfidentLocalDeny(ZDO zdo, Player localPlayer, Piece piece)
		{
			if (zdo == null || (Object)(object)localPlayer == (Object)null || !GuildZdo.IsGuildCheckEnabled(zdo))
			{
				return false;
			}
			long playerID = localPlayer.GetPlayerID();
			if (!GuildZdo.IsOwned(zdo))
			{
				long num = (((Object)(object)piece != (Object)null) ? piece.GetCreator() : 0);
				if (num != 0L)
				{
					return playerID != num;
				}
				return false;
			}
			GuildMembership membership = GuildBridge.Resolve(localPlayer);
			if (membership.Kind == GuildMembershipKind.Unknown)
			{
				return false;
			}
			return !Decide(zdo, membership);
		}

		private static bool TryOwnedOrPending(ZDO zdo, Piece piece, long interactingPlayerUid, out bool allow)
		{
			string debugDetail;
			return TryOwnedOrPending(zdo, piece, interactingPlayerUid, out allow, out debugDetail);
		}

		private static bool TryOwnedOrPending(ZDO zdo, Piece piece, long interactingPlayerUid, out bool allow, out string debugDetail)
		{
			debugDetail = null;
			GuildStructuresConfig cfg = GuildStructuresPlugin.Cfg;
			if (GuildZdo.IsOwned(zdo))
			{
				allow = false;
				return true;
			}
			long num = (((Object)(object)piece != (Object)null) ? piece.GetCreator() : 0);
			if (num != 0L)
			{
				allow = interactingPlayerUid != 0L && interactingPlayerUid == num;
				debugDetail = (allow ? "pending stamp - creator only => ALLOW" : "pending stamp - not creator => DENY");
				return false;
			}
			allow = cfg.AllowAccessIfUnowned.Value;
			debugDetail = string.Format("piece unowned - AllowAccessIfUnowned={0} => {1}", allow, allow ? "ALLOW" : "DENY");
			return false;
		}

		private static bool Decide(ZDO zdo, GuildMembership membership)
		{
			GuildStructuresConfig cfg = GuildStructuresPlugin.Cfg;
			int guildId = GuildZdo.GetGuildId(zdo);
			int guildGen = GuildZdo.GetGuildGen(zdo);
			switch (membership.Kind)
			{
			case GuildMembershipKind.Unknown:
				return true;
			case GuildMembershipKind.None:
				return !cfg.DenyAccessIfGuildless.Value;
			case GuildMembershipKind.Member:
			{
				int currentGeneration = GuildGenerationTracker.GetCurrentGeneration(membership.GuildId);
				if (membership.GuildId == guildId)
				{
					return currentGeneration == guildGen;
				}
				return false;
			}
			default:
				return true;
			}
		}

		private static string Describe(ZDO zdo, GuildMembership membership, string label, bool allowed)
		{
			GuildStructuresConfig cfg = GuildStructuresPlugin.Cfg;
			int guildId = GuildZdo.GetGuildId(zdo);
			int guildGen = GuildZdo.GetGuildGen(zdo);
			switch (membership.Kind)
			{
			case GuildMembershipKind.Unknown:
				return string.Format("'{0}' guild membership UNKNOWN (piece owned by guild id {1} gen {2}) => {3}", label, guildId, guildGen, allowed ? "ALLOW" : "DENY");
			case GuildMembershipKind.None:
				return string.Format("'{0}' has no Guild (piece owned by guild id {1} gen {2}) - DenyAccessIfGuildless={3} => {4}", label, guildId, guildGen, cfg.DenyAccessIfGuildless.Value, allowed ? "ALLOW" : "DENY");
			default:
			{
				int currentGeneration = GuildGenerationTracker.GetCurrentGeneration(membership.GuildId);
				bool flag = membership.GuildId == guildId;
				string text = (allowed ? "ALLOW" : (flag ? "DENY (stale generation - guild id was recreated)" : "DENY"));
				return $"'{label}' guild id {membership.GuildId} gen {currentGeneration} vs piece owner guild id {guildId} gen {guildGen} => {text}";
			}
			}
		}
	}
	internal static class GuildRemoveGuard
	{
		internal static bool ShouldBlockRemove(Piece piece, long removerPlayerId)
		{
			if ((Object)(object)piece == (Object)null || !OwnershipPatches.ProtectedPieces.HasAnyRules)
			{
				return false;
			}
			string prefabName = Utils.GetPrefabName(((Component)piece).gameObject);
			if (!OwnershipPatches.ProtectedPieces.Matches(prefabName))
			{
				return false;
			}
			if (ProtectedStorageRules.Pieces.Matches(prefabName))
			{
				ZNetView component = ((Component)piece).GetComponent<ZNetView>();
				if ((Object)(object)component != (Object)null && component.IsValid())
				{
					ZDO zDO = component.GetZDO();
					if (zDO != null && PasswordZdo.HasPassword(zDO))
					{
						return false;
					}
				}
			}
			ZNetView component2 = ((Component)piece).GetComponent<ZNetView>();
			if ((Object)(object)component2 == (Object)null || !component2.IsValid())
			{
				return false;
			}
			ZDO zDO2 = component2.GetZDO();
			if (zDO2 == null || !GuildZdo.IsGuildCheckEnabled(zDO2))
			{
				return false;
			}
			if (!GuildZdo.IsOwned(zDO2))
			{
				long creator = piece.GetCreator();
				if (creator == 0L)
				{
					return false;
				}
				if (removerPlayerId != 0L)
				{
					return removerPlayerId != creator;
				}
				return true;
			}
			GuildMembership guildMembership = GuildBridge.ResolvePreferLocal(removerPlayerId);
			if (guildMembership.Kind != GuildMembershipKind.Member)
			{
				return true;
			}
			int guildId = GuildZdo.GetGuildId(zDO2);
			int guildGen = GuildZdo.GetGuildGen(zDO2);
			int currentGeneration = GuildGenerationTracker.GetCurrentGeneration(guildMembership.GuildId);
			return guildMembership.GuildId != guildId || currentGeneration != guildGen;
		}

		internal static void ShowDeniedMessage(Player player)
		{
			if (!((Object)(object)player == (Object)null))
			{
				((Character)player).Message((MessageType)2, "Only guild members can remove this.", 0, (Sprite)null);
			}
		}

		internal static void LogDenied(string prefab, long removerPlayerId, ZDO zdo, string gate)
		{
			if (Log.IsDebugEnabled)
			{
				int num = ((zdo != null) ? GuildZdo.GetGuildId(zdo) : (-1));
				int num2 = ((zdo != null) ? GuildZdo.GetGuildGen(zdo) : 0);
				Log.Debug("[Guild] Remove DENIED via " + gate + " on '" + prefab + "' " + $"(remover player id {removerPlayerId}, piece guild id {num} gen {num2}).");
			}
		}
	}
	internal static class GuildZdo
	{
		internal const string LockedFieldName = "GS_Locked";

		internal const string GuildIdFieldName = "GS_GuildId";

		internal const string BatchNoFieldName = "GS_BatchNo";

		internal const string GuildCheckEnabledFieldName = "GS_GuildCheckEnabled";

		internal const string GuildNameFieldName = "GS_GuildName";

		internal const string OwnerPlayerNameFieldName = "GS_OwnerPlayerName";

		private const string LegacyOwnedFieldName = "GS_Owned";

		private const string LegacyGuildGenFieldName = "GS_GuildGen";

		private const string LegacyOwnerGuildNameFieldName = "GS_OwnerGuildName";

		internal static readonly string[] AllFieldNames = new string[9] { "GS_Locked", "GS_GuildId", "GS_BatchNo", "GS_GuildCheckEnabled", "GS_GuildName", "GS_OwnerPlayerName", "GS_Owned", "GS_GuildGen", "GS_OwnerGuildName" };

		private static readonly int LockedHash = StringExtensionMethods.GetStableHashCode("GS_Locked");

		private static readonly int GuildIdHash = StringExtensionMethods.GetStableHashCode("GS_GuildId");

		private static readonly int BatchNoHash = StringExtensionMethods.GetStableHashCode("GS_BatchNo");

		private static readonly int GuildCheckEnabledHash = StringExtensionMethods.GetStableHashCode("GS_GuildCheckEnabled");

		private static readonly int GuildNameHash = StringExtensionMethods.GetStableHashCode("GS_GuildName");

		private static readonly int OwnerPlayerNameHash = StringExtensionMethods.GetStableHashCode("GS_OwnerPlayerName");

		private static readonly int LegacyOwnedHash = StringExtensionMethods.GetStableHashCode("GS_Owned");

		private static readonly int LegacyGuildGenHash = StringExtensionMethods.GetStableHashCode("GS_GuildGen");

		internal static bool IsOwned(ZDO zdo)
		{
			if (zdo == null)
			{
				return false;
			}
			if (!zdo.GetBool(LockedHash, false))
			{
				return zdo.GetBool(LegacyOwnedHash, false);
			}
			return true;
		}

		internal static int GetGuildId(ZDO zdo)
		{
			if (zdo != null)
			{
				return zdo.GetInt(GuildIdHash, -1);
			}
			return -1;
		}

		internal static int GetGuildGen(ZDO zdo)
		{
			if (zdo == null)
			{
				return 0;
			}
			int num = zdo.GetInt(BatchNoHash, int.MinValue);
			if (num != int.MinValue)
			{
				return num;
			}
			return zdo.GetInt(LegacyGuildGenHash, 0);
		}

		internal static bool IsGuildCheckEnabled(ZDO zdo)
		{
			if (zdo != null)
			{
				return zdo.GetBool(GuildCheckEnabledHash, true);
			}
			return true;
		}

		internal static void SetOwner(ZDO zdo, int guildId, int batchNo, string guildName, string ownerPlayerName)
		{
			if (zdo != null)
			{
				zdo.Set(GuildIdHash, guildId, false);
				zdo.Set(BatchNoHash, batchNo, false);
				zdo.Set(LockedHash, true);
				zdo.Set(GuildCheckEnabledHash, true);
				if (!string.IsNullOrEmpty(guildName))
				{
					zdo.Set(GuildNameHash, guildName);
				}
				if (!string.IsNullOrEmpty(ownerPlayerName))
				{
					zdo.Set(OwnerPlayerNameHash, ownerPlayerName);
				}
			}
		}
	}
	internal sealed class PrefabRuleSet
	{
		private readonly HashSet<string> _exact = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

		private readonly List<string> _contains = new List<string>();

		internal bool HasAnyRules
		{
			get
			{
				if (_exact.Count <= 0)
				{
					return _contains.Count > 0;
				}
				return true;
			}
		}

		internal void Reload(string exactCsv, string containsCsv)
		{
			_exact.Clear();
			_contains.Clear();
			foreach (string item in SplitCsv(exactCsv))
			{
				_exact.Add(item);
			}
			foreach (string item2 in SplitCsv(containsCsv))
			{
				_contains.Add(item2.ToLowerInvariant());
			}
		}

		internal bool Matches(string prefabName)
		{
			if (string.IsNullOrEmpty(prefabName))
			{
				return false;
			}
			if (_exact.Contains(prefabName))
			{
				return true;
			}
			if (_contains.Count == 0)
			{
				return false;
			}
			string text = prefabName.ToLowerInvariant();
			for (int i = 0; i < _contains.Count; i++)
			{
				if (text.Contains(_contains[i]))
				{
					return true;
				}
			}
			return false;
		}

		private static IEnumerable<string> SplitCsv(string csv)
		{
			if (string.IsNullOrWhiteSpace(csv))
			{
				return Enumerable.Empty<string>();
			}
			return from s in csv.Split(new char[1] { ',' })
				select s.Trim() into s
				where s.Length > 0
				select s;
		}
	}
}
namespace GuildStructures.Guilds
{
	internal static class GuildBridge
	{
		internal static bool IsAvailable()
		{
			try
			{
				return API.IsLoaded();
			}
			catch (Exception arg)
			{
				Log.Error($"[Guilds] IsLoaded() threw: {arg}");
				return false;
			}
		}

		internal static GuildMembership Resolve(Player player)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: 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 ((Object)(object)player == (Object)null || !IsAvailable())
			{
				return GuildMembership.Unknown;
			}
			try
			{
				PlayerReference val = ResolveReference(player);
				if (string.IsNullOrEmpty(val.id))
				{
					return GuildMembership.Unknown;
				}
				Guild val2 = FindGuildByPlatformId(val.id);
				return (val2?.General != null) ? GuildMembership.Member(val2.General.id) : GuildMembership.None;
			}
			catch (Exception arg)
			{
				Log.Error($"[Guilds] Resolve(Player) failed: {arg}");
				return GuildMembership.Unknown;
			}
		}

		internal static GuildMembership ResolveByUid(long playerUid)
		{
			//IL_003f: 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)
			if (playerUid == 0L || !IsAvailable())
			{
				return GuildMembership.Unknown;
			}
			try
			{
				Player val = FindLivePlayer(playerUid);
				if ((Object)(object)val != (Object)null)
				{
					return Resolve(val);
				}
				Guild val2 = FindGuildByPlatformId(playerUid.ToString()) ?? API.GetPlayerGuild(new PlayerReference
				{
					id = playerUid.ToString(),
					name = string.Empty
				});
				return (val2?.General != null) ? GuildMembership.Member(val2.General.id) : GuildMembership.None;
			}
			catch (Exception arg)
			{
				Log.Error($"[Guilds] ResolveByUid({playerUid}) failed: {arg}");
				return GuildMembership.Unknown;
			}
		}

		internal static GuildMembership ResolvePreferLocal(long playerUid)
		{
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer != (Object)null && localPlayer.GetPlayerID() == playerUid)
			{
				return Resolve(localPlayer);
			}
			return ResolveByUid(playerUid);
		}

		internal static int? GetGuildId(Player player)
		{
			return Resolve(player).AsNullableId;
		}

		private static Guild FindGuildByPlatformId(string platformId)
		{
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			if (string.IsNullOrEmpty(platformId))
			{
				return null;
			}
			foreach (Guild guild in API.GetGuilds())
			{
				foreach (PlayerReference key in guild.Members.Keys)
				{
					if (key.id == platformId)
					{
						return guild;
					}
				}
			}
			return null;
		}

		internal static int? GetGuildIdByUid(long playerUid)
		{
			return ResolveByUid(playerUid).AsNullableId;
		}

		private static Player FindLivePlayer(long playerUid)
		{
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer != (Object)null && localPlayer.GetPlayerID() == playerUid)
			{
				return localPlayer;
			}
			List<Player> allPlayers = Player.GetAllPlayers();
			if (allPlayers == null)
			{
				return null;
			}
			for (int i = 0; i < allPlayers.Count; i++)
			{
				Player val = allPlayers[i];
				if ((Object)(object)val != (Object)null && val.GetPlayerID() == playerUid)
				{
					return val;
				}
			}
			return null;
		}

		internal static int? GetGuildIdPreferLocal(long playerUid)
		{
			return ResolvePreferLocal(playerUid).AsNullableId;
		}

		internal static string GetGuildName(int guildId)
		{
			if (!IsAvailable())
			{
				return null;
			}
			try
			{
				return API.GetGuild(guildId)?.Name;
			}
			catch (Exception arg)
			{
				Log.Error($"[Guilds] GetGuildName({guildId}) failed: {arg}");
				return null;
			}
		}

		private static PlayerReference ResolveReference(Player player)
		{
			//IL_0021: 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)
			if ((Object)(object)Player.m_localPlayer != (Object)null && (Object)(object)player == (Object)(object)Player.m_localPlayer)
			{
				return PlayerReference.forOwnPlayer();
			}
			return PlayerReference.fromPlayer(player);
		}
	}
	internal static class GuildGenerationTracker
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static Action <0>__OnSyncedSnapshotChanged;

			public static GuildCreated <1>__OnGuildCreated;

			public static GuildDeleted <2>__OnGuildDeleted;
		}

		private static readonly Dictionary<int, int> Generations = new Dictionary<int, int>();

		private static readonly HashSet<int> Retired = new HashSet<int>();

		private static readonly object Lock = new object();

		private static bool _loaded;

		private static bool _registered;

		private static bool _syncReady;

		private static string _storePath;

		private static CustomSyncedValue<string> _syncedSnapshot;

		internal static void Initialize()
		{
			EnsureSyncValue();
			EnsureRegistered();
		}

		internal static int GetCurrentGeneration(int guildId)
		{
			EnsureSyncValue();
			EnsureRegistered();
			lock (Lock)
			{
				EnsureLoaded();
				int value;
				return Generations.TryGetValue(guildId, out value) ? value : 0;
			}
		}

		private static void EnsureSyncValue()
		{
			if (_syncReady)
			{
				return;
			}
			try
			{
				_syncedSnapshot = new CustomSyncedValue<string>(GuildStructuresSync.Instance, "GuildGenerations", string.Empty);
				_syncedSnapshot.ValueChanged += OnSyncedSnapshotChanged;
				_syncReady = true;
				if (IsServerAuthority())
				{
					lock (Lock)
					{
						EnsureLoaded();
						PublishLocked();
						return;
					}
				}
			}
			catch (Exception arg)
			{
				Log.Error($"[GuildGen] Failed to create CustomSyncedValue: {arg}");
			}
		}

		private static void OnSyncedSnapshotChanged()
		{
			if (IsServerAuthority())
			{
				return;
			}
			try
			{
				string raw = ((_syncedSnapshot != null) ? _syncedSnapshot.Value : null);
				lock (Lock)
				{
					ApplySnapshot(raw);
					_loaded = true;
				}
				if (Log.IsDebugEnabled)
				{
					Log.Debug($"[GuildGen] Applied server generation snapshot ({Generations.Count} id(s), {Retired.Count} retired).");
				}
			}
			catch (Exception arg)
			{
				Log.Error($"[GuildGen] Failed to apply server generation snapshot: {arg}");
			}
		}

		private static void EnsureRegistered()
		{
			//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_002c: Expected O, but got Unknown
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Expected O, but got Unknown
			if (_registered || !GuildBridge.IsAvailable())
			{
				return;
			}
			try
			{
				object obj = <>O.<1>__OnGuildCreated;
				if (obj == null)
				{
					GuildCreated val = OnGuildCreated;
					<>O.<1>__OnGuildCreated = val;
					obj = (object)val;
				}
				API.RegisterOnGuildCreated((GuildCreated)obj);
				object obj2 = <>O.<2>__OnGuildDeleted;
				if (obj2 == null)
				{
					GuildDeleted val2 = OnGuildDeleted;
					<>O.<2>__OnGuildDeleted = val2;
					obj2 = (object)val2;
				}
				API.RegisterOnGuildDeleted((GuildDeleted)obj2);
				_registered = true;
				if (Log.IsDebugEnabled)
				{
					Log.Debug("[GuildGen] Registered OnGuildCreated/OnGuildDeleted listeners for generation tracking.");
				}
				if (IsServerAuthority())
				{
					SeedLivingGuildsFromApi();
				}
			}
			catch (Exception arg)
			{
				Log.Error($"[GuildGen] Failed to register guild lifecycle listeners: {arg}");
			}
		}

		private static void SeedLivingGuildsFromApi()
		{
			try
			{
				bool flag = false;
				lock (Lock)
				{
					EnsureLoaded();
					foreach (Guild guild in API.GetGuilds())
					{
						int? num = guild?.General?.id;
						if (num.HasValue)
						{
							if (!Generations.ContainsKey(num.Value))
							{
								Generations[num.Value] = 0;
								flag = true;
							}
							Retired.Remove(num.Value);
						}
					}
					if (flag)
					{
						SaveLocked();
						PublishLocked();
					}
				}
			}
			catch (Exception arg)
			{
				Log.Error($"[GuildGen] SeedLivingGuildsFromApi failed: {arg}");
			}
		}

		private static void OnGuildCreated(Guild guild)
		{
			try
			{
				if (!IsServerAuthority())
				{
					return;
				}
				int? num = guild?.General?.id;
				if (!num.HasValue)
				{
					return;
				}
				lock (Lock)
				{
					EnsureLoaded();
					if (Retired.Remove(num.Value))
					{
						int value;
						int num2 = (Generations.TryGetValue(num.Value, out value) ? value : 0) + 1;
						Generations[num.Value] = num2;
						SaveLocked();
						PublishLocked();
						if (Log.IsDebugEnabled)
						{
							Log.Debug($"[GuildGen] Guild id {num.Value} ('{guild.Name}') recreated after delete - now generation {num2}.");
						}
					}
					else if (Generations.ContainsKey(num.Value))
					{
						if (Log.IsDebugEnabled)
						{
							Log.Debug($"[GuildGen] Ignoring sync recreate for living guild id {num.Value} ('{guild.Name}') gen {Generations[num.Value]}.");
						}
					}
					else
					{
						Generations[num.Value] = 0;
						SaveLocked();
						PublishLocked();
						if (Log.IsDebugEnabled)
						{
							Log.Debug($"[GuildGen] First sighting of guild id {num.Value} ('{guild.Name}') - generation 0.");
						}
					}
				}
			}
			catch (Exception arg)
			{
				Log.Error($"[GuildGen] OnGuildCreated handler failed: {arg}");
			}
		}

		private static void OnGuildDeleted(Guild guild)
		{
			try
			{
				if (!IsServerAuthority())
				{
					return;
				}
				int? num = guild?.General?.id;
				if (!num.HasValue)
				{
					return;
				}
				lock (Lock)
				{
					EnsureLoaded();
					if (Retired.Add(num.Value))
					{
						if (!Generations.ContainsKey(num.Value))
						{
							Generations[num.Value] = 0;
						}
						SaveLocked();
						PublishLocked();
						if (Log.IsDebugEnabled)
						{
							Log.Debug($"[GuildGen] Guild id {num.Value} ('{guild.Name}') deleted/retired (gen {Generations[num.Value]} held for reuse).");
						}
					}
				}
			}
			catch (Exception arg)
			{
				Log.Error($"[GuildGen] OnGuildDeleted handler failed: {arg}");
			}
		}

		private static bool IsServerAuthority()
		{
			try
			{
				return GuildStructuresSync.Instance.IsSourceOfTruth;
			}
			catch
			{
				return true;
			}
		}

		private static void PublishLocked()
		{
			if (_syncedSnapshot != null && IsServerAuthority())
			{
				string text = SerializeLocked();
				if (!(_syncedSnapshot.Value == text))
				{
					_syncedSnapshot.Value = text;
				}
			}
		}

		private static string SerializeLocked()
		{
			StringBuilder stringBuilder = new StringBuilder();
			foreach (KeyValuePair<int, int> generation in Generations)
			{
				stringBuilder.Append(generation.Key.ToString(CultureInfo.InvariantCulture));
				stringBuilder.Append('=');
				stringBuilder.Append(generation.Value.ToString(CultureInfo.InvariantCulture));
				stringBuilder.Append('\n');
			}
			if (Retired.Count > 0)
			{
				stringBuilder.Append("#retired\n");
				foreach (int item in Retired)
				{
					stringBuilder.Append(item.ToString(CultureInfo.InvariantCulture));
					stringBuilder.Append('\n');
				}
			}
			return stringBuilder.ToString();
		}

		private static void ApplySnapshot(string raw)
		{
			Generations.Clear();
			Retired.Clear();
			if (string.IsNullOrEmpty(raw))
			{
				return;
			}
			bool flag = false;
			using StringReader stringReader = new StringReader(raw);
			string text;
			while ((text = stringReader.ReadLine()) != null)
			{
				if (text.Length == 0)
				{
					continue;
				}
				if (text == "#retired")
				{
					flag = true;
					continue;
				}
				if (flag)
				{
					if (int.TryParse(text, NumberStyles.Integer, CultureInfo.InvariantCulture, out var result))
					{
						Retired.Add(result);
					}
					continue;
				}
				int num = text.IndexOf('=');
				if (num > 0 && int.TryParse(text.Substring(0, num), NumberStyles.Integer, CultureInfo.InvariantCulture, out var result2) && int.TryParse(text.Substring(num + 1), NumberStyles.Integer, CultureInfo.InvariantCulture, out var result3))
				{
					Generations[result2] = result3;
				}
			}
		}

		private static void EnsureLoaded()
		{
			if (_loaded)
			{
				return;
			}
			_loaded = true;
			if (!IsServerAuthority() && _syncedSnapshot != null && !string.IsNullOrEmpty(_syncedSnapshot.Value))
			{
				ApplySnapshot(_syncedSnapshot.Value);
				return;
			}
			try
			{
				string storePath = GetStorePath();
				if (File.Exists(storePath))
				{
					ApplySnapshot(File.ReadAllText(storePath));
				}
			}
			catch (Exception arg)
			{
				Log.Error($"[GuildGen] Failed to load persisted generation table: {arg}");
			}
		}

		private static void SaveLocked()
		{
			if (!IsServerAuthority())
			{
				return;
			}
			try
			{
				File.WriteAllText(GetStorePath(), SerializeLocked());
			}
			catch (Exception arg)
			{
				Log.Error($"[GuildGen] Failed to persist generation table: {arg}");
			}
		}

		private static string GetStorePath()
		{
			if (_storePath != null)
			{
				return _storePath;
			}
			_storePath = Path.Combine(Paths.ConfigPath, "com.rdmods.guildstructures.guild-generations.txt");
			return _storePath;
		}
	}
	internal enum GuildMembershipKind : byte
	{
		Unknown,
		None,
		Member
	}
	internal readonly struct GuildMembership
	{
		internal readonly GuildMembershipKind Kind;

		internal readonly int GuildId;

		internal static GuildMembership Unknown => new GuildMembership(GuildMembershipKind.Unknown, 0);

		internal static GuildMembership None => new GuildMembership(GuildMembershipKind.None, 0);

		internal int? AsNullableId
		{
			get
			{
				if (Kind != GuildMembershipKind.Member)
				{
					return null;
				}
				return GuildId;
			}
		}

		private GuildMembership(GuildMembershipKind kind, int guildId)
		{
			Kind = kind;
			GuildId = guildId;
		}

		internal static GuildMembership Member(int guildId)
		{
			return new GuildMembership(GuildMembershipKind.Member, guildId);
		}
	}
}
namespace GuildStructures.Config
{
	internal static class ConfigLiveReload
	{
		private const float DebounceSeconds = 1f;

		private static ConfigFile _config;

		private static MonoBehaviour _host;

		private static FileSystemWatcher _watcher;

		private static Coroutine _debounceRoutine;

		internal static void Begin(MonoBehaviour host, ConfigFile config, Harmony harmony)
		{
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Expected O, but got Unknown
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Expected O, but got Unknown
			_host = host;
			_config = config;
			MethodInfo methodInfo = AccessTools.Method(typeof(ZNet), "Awake", (Type[])null, (Type[])null);
			if (methodInfo == null)
			{
				throw new InvalidOperationException("ZNet.Awake() not found - Valheim version mismatch?");
			}
			MethodInfo methodInfo2 = AccessTools.Method(typeof(ZNet), "Shutdown", (Type[])null, (Type[])null);
			if (methodInfo2 == null)
			{
				throw new InvalidOperationException("ZNet.Shutdown() not found - Valheim version mismatch?");
			}
			harmony.Patch((MethodBase)methodInfo, (HarmonyMethod)null, new HarmonyMethod(typeof(ConfigLiveReload), "Postfix_ZNet_Awake", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			harmony.Patch((MethodBase)methodInfo2, (HarmonyMethod)null, new HarmonyMethod(typeof(ConfigLiveReload), "Postfix_ZNet_Shutdown", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		}

		internal static void Dispose()
		{
			StopWatcher();
			_host = null;
			_config = null;
		}

		private static void Postfix_ZNet_Awake(ZNet __instance)
		{
			if ((Object)(object)__instance != (Object)null && __instance.IsServer())
			{
				StartWatcher();
			}
			else
			{
				StopWatcher();
			}
		}

		private static void Postfix_ZNet_Shutdown()
		{
			StopWatcher();
		}

		private static void StartWatcher()
		{
			if (_watcher != null || _config == null || (Object)(object)_host == (Object)null)
			{
				return;
			}
			string configFilePath = _config.ConfigFilePath;
			if (string.IsNullOrEmpty(configFilePath))
			{
				Log.Warn("[Config Live Reload] Config path empty; live CFG reload disabled.");
				return;
			}
			string directoryName = Path.GetDirectoryName(configFilePath);
			string fileName = Path.GetFileName(configFilePath);
			if (string.IsNullOrEmpty(directoryName) || string.IsNullOrEmpty(fileName) || !Directory.Exists(directoryName))
			{
				Log.Warn("[Config Live Reload] Config directory missing; live CFG reload disabled.");
				return;
			}
			try
			{
				_watcher = new FileSystemWatcher(directoryName, fileName)
				{
					NotifyFilter = (NotifyFilters.FileName | NotifyFilters.Size | NotifyFilters.LastWrite),
					IncludeSubdirectories = false,
					SynchronizingObject = ThreadingHelper.SynchronizingObject
				};
				_watcher.Changed += OnFileEvent;
				_watcher.Created += OnFileEvent;
				_watcher.Renamed += OnFileEvent;
				_watcher.EnableRaisingEvents = true;
				Log.Info("[Config Live Reload] Watching server CFG for live edits (no restart needed).");
			}
			catch (Exception ex)
			{
				Log.Error("[Config Live Reload] Failed to start watcher: " + ex.Message);
				StopWatcher();
			}
		}

		private static void StopWatcher()
		{
			if (_debounceRoutine != null && (Object)(object)_host != (Object)null)
			{
				try
				{
					_host.StopCoroutine(_debounceRoutine);
				}
				catch
				{
				}
				_debounceRoutine = null;
			}
			if (_watcher != null)
			{
				try
				{
					_watcher.EnableRaisingEvents = false;
					_watcher.Changed -= OnFileEvent;
					_watcher.Created -= OnFileEvent;
					_watcher.Renamed -= OnFileEvent;
					_watcher.Dispose();
				}
				catch
				{
				}
				_watcher = null;
			}
		}

		private static void OnFileEvent(object sender, FileSystemEventArgs e)
		{
			if (!((Object)(object)_host == (Object)null) && _config != null && !((Object)(object)ZNet.instance == (Object)null) && ZNet.instance.IsServer())
			{
				if (_debounceRoutine != null)
				{
					_host.StopCoroutine(_debounceRoutine);
				}
				_debounceRoutine = _host.StartCoroutine(DebouncedReload());
			}
		}

		private static IEnumerator DebouncedReload()
		{
			yield return (object)new WaitForSecondsRealtime(1f);
			_debounceRoutine = null;
			TryReload();
		}

		private static void TryReload()
		{
			if (_config == null || (Object)(object)ZNet.instance == (Object)null || !ZNet.instance.IsServer())
			{
				return;
			}
			try
			{
				if (File.Exists(_config.ConfigFilePath))
				{
					_config.Reload();
					Log.Info("[Config Live Reload] Reloaded server CFG from disk. Changed synced settings are pushed to clients automatically.");
				}
			}
			catch (Exception ex)
			{
				Log.Error("[Config Live Reload] Reload failed (keeping previous in-memory values): " + ex.Message);
			}
		}
	}
	internal sealed class GuildStructuresConfig
	{
		internal readonly ConfigEntry<bool> Enabled;

		internal readonly ConfigEntry<bool> DebugLogging;

		internal readonly ConfigEntry<bool> LockConfiguration;

		internal readonly ConfigEntry<string> ProtectedExactNames;

		internal readonly ConfigEntry<string> ProtectedContainsNames;

		internal readonly ConfigEntry<bool> DenyAccessIfGuildless;

		internal readonly ConfigEntry<bool> AllowAccessIfUnowned;

		internal readonly ConfigEntry<string> ProtectedStorageExactNames;

		internal readonly ConfigEntry<string> ProtectedStorageContainsNames;

		internal GuildStructuresConfig(ConfigFile file)
		{
			Enabled = file.Bind<bool>("1 - General", "Enabled", true, "Master on/off switch for the whole mod.");
			DebugLogging = file.Bind<bool>("1 - General", "Debug Logging", false, "Enables verbose per-interaction / per-placement debug log lines. Leave off in normal play, turn on temporarily while tuning the prefab lists below.");
			LockConfiguration = file.Bind<bool>("1 - General", "Lock Configuration", true, "When enabled, only the server admin can change the settings below marked 'Server-synced' - connected clients get the server's values forced onto them and can't override them locally (via their own config file or the in-game config manager) for as long as they stay connected. Leave this on; it's the whole point of the sync feature. This setting itself is always server-controlled by design.");
			GuildStructuresSync.Instance.AddLockingConfigEntry<bool>(LockConfiguration);
			ProtectedExactNames = file.Bind<string>("2 - Access Control", "Protected Prefabs (Exact Names)", "", "Comma separated, EXACT (case sensitive) prefab names of Gates/Containers/etc. that should be locked to the placing player's Guild instead of (or on top of) BetterWards. Example: metalgate,reinforced_gate,FactionArmoryChest\nLeave empty and use the 'Contains' option below if you don't know exact names yet.\nServer-synced: once a client connects to a server running this mod, this value is forced to match the server's and can't be changed locally while connected.");
			GuildStructuresSync.Instance.AddConfigEntry<string>(ProtectedExactNames);
			ProtectedContainsNames = file.Bind<string>("2 - Access Control", "Protected Prefabs (Name Contains)", "", "Comma separated, case-insensitive substrings. Any placed piece whose prefab name contains one of these becomes Guild-protected. Example: gate,siegecamp,armory\nThis is the easiest way to catch every current AND future WackysDatabase variant at once (e.g. 'gate' matches metalgate, reinforced_gate, cityGate_01, etc.).\nServer-synced: same as the exact-name list above.");
			GuildStructuresSync.Instance.AddConfigEntry<string>(ProtectedContainsNames);
			DenyAccessIfGuildless = file.Bind<bool>("2 - Access Control", "Deny Access If Player Has No Guild", true, "If the interacting player is not in any Guild, deny access to protected pieces. Should normally stay true on servers where every player is expected to be in a Guild.\nServer-synced.");
			GuildStructuresSync.Instance.AddConfigEntry<bool>(DenyAccessIfGuildless);
			AllowAccessIfUnowned = file.Bind<bool>("2 - Access Control", "Allow Access If Piece Has No Recorded Owner", true, "Fail-open safety net: if a protected piece has not been stamped with an owning Guild yet (e.g. placed before this mod was installed, or ownership resolution failed), allow access instead of locking everyone out. Recommended to keep true for the first few days on a live server, then optionally set to false once you trust ownership stamping.\nServer-synced.");
			GuildStructuresSync.Instance.AddConfigEntry<bool>(AllowAccessIfUnowned);
			ProtectedStorageExactNames = file.Bind<string>("4 - Protected Storage", "Password-Protected Prefabs (Exact Names)", "", "Comma separated, EXACT (case sensitive) prefab names that get the SHIFT+E password-lock feature (e.g. a cloned 'Protected Storage' piece_chest variant). Completely independent from the Guild-based '2 - Access Control' list above - there is NO faction check on these pieces at all. The owner (whoever built it) can always open it and can press SHIFT+E to set/change/remove its password; anyone else who is told the current password can open it too, regardless of Guild membership. Leave empty to leave this whole feature inactive.\nExample: piece_chest_protected,FactionVault\nServer-synced: once a client connects to a server running this mod, this value is forced to match the server's and can't be changed locally while connected.");
			GuildStructuresSync.Instance.AddConfigEntry<string>(ProtectedStorageExactNames);
			ProtectedStorageContainsNames = file.Bind<string>("4 - Protected Storage", "Password-Protected Prefabs (Name Contains)", "", "Comma separated, case-insensitive substrings - same matching rules as the '2 - Access Control' equivalent above, just for the password-lock feature instead of Guild checks.\nServer-synced: same as the exact-name list above.");
			GuildStructuresSync.Instance.AddConfigEntry<string>(ProtectedStorageContainsNames);
		}
	}
}
namespace GuildStructures.Compat
{
	internal static class WecCompat
	{
		private enum RegisterResult
		{
			Success,
			WaitingForWec,
			PermanentFailure
		}

		private const string WecAssemblyName = "WorldEditCommands";

		private const string ZdoKeysTypeName = "Data.ZDOKeys";

		private const string HashMethodName = "Hash";

		private const float RetryIntervalSeconds = 2f;

		private const int MaxAttempts = 15;

		internal static void BeginRegistration(MonoBehaviour host, params string[][] fieldNameGroups)
		{
			if (!((Object)(object)host == (Object)null))
			{
				RegisterResult registerResult = TryRegisterFieldNames(fieldNameGroups);
				if (registerResult != RegisterResult.Success && registerResult != RegisterResult.PermanentFailure)
				{
					host.StartCoroutine(RetryRegister(host, fieldNameGroups));
				}
			}
		}

		private static IEnumerator RetryRegister(MonoBehaviour host, string[][] fieldNameGroups)
		{
			for (int attempt = 2; attempt <= 15; attempt++)
			{
				yield return (object)new WaitForSecondsRealtime(2f);
				if ((Object)(object)host == (Object)null)
				{
					yield break;
				}
				RegisterResult registerResult = TryRegisterFieldNames(fieldNameGroups);
				if (registerResult == RegisterResult.Success || registerResult == RegisterResult.PermanentFailure)
				{
					yield break;
				}
			}
			if (Log.IsDebugEnabled)
			{
				Log.Debug("[WEC Compat] World Edit Commands was not detected after startup retries - skipping field-name registration (cosmetic only; this mod is unaffected).");
			}
		}

		private static RegisterResult TryRegisterFieldNames(string[][] fieldNameGroups)
		{
			try
			{
				Assembly assembly = AppDomain.CurrentDomain.GetAssemblies().FirstOrDefault((Assembly a) => string.Equals(a.GetName().Name, "WorldEditCommands", StringComparison.OrdinalIgnoreCase));
				if (assembly == null)
				{
					return RegisterResult.WaitingForWec;
				}
				MethodInfo methodInfo = assembly.GetType("Data.ZDOKeys")?.GetMethod("Hash", BindingFlags.Static | BindingFlags.Public);
				if (methodInfo == null)
				{
					Log.Warn("[WEC Compat] World Edit Commands is loaded, but its Data.ZDOKeys.Hash(string) method was not found (it may have changed internals in a newer version) - its dump/print output will show raw hash numbers for our fields instead of names. This does not affect this mod's own access control in any way.");
					return RegisterResult.PermanentFailure;
				}
				int num = 0;
				foreach (string[] array in fieldNameGroups)
				{
					if (array != null)
					{
						string[] array2 = array;
						foreach (string text in array2)
						{
							methodInfo.Invoke(null, new object[1] { text });
							num++;
						}
					}
				}
				Log.Info($"[WEC Compat] World Edit Commands detected - registered {num} " + "field name(s) so its 'data dump'/'data print' commands display them by name.");
				return RegisterResult.Success;
			}
			catch (Exception ex)
			{
				Log.Warn("[WEC Compat] Failed to register field names with World Edit Commands (non-fatal, purely cosmetic - this mod's own functionality is unaffected): " + ex.Message);
				return RegisterResult.PermanentFailure;
			}
		}
	}
}