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.Text;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using JetBrains.Annotations;
using Microsoft.CodeAnalysis;
using ServerSync;
using TMPro;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: AssemblyCompany("isimp")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyCopyright("Copyright (c) 2026 isimp")]
[assembly: AssemblyDescription("Mark a chest and the container-automation mods leave it alone.")]
[assembly: AssemblyFileVersion("0.2.1.0")]
[assembly: AssemblyInformationalVersion("0.2.1+f94d33f7cd171b726f436fa83003a2ff9eedd2c3")]
[assembly: AssemblyProduct("Hoard")]
[assembly: AssemblyTitle("Hoard")]
[assembly: AssemblyVersion("0.2.1.0")]
[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
{
	[PublicAPI]
	public abstract class OwnConfigEntryBase
	{
		public object? LocalBaseValue;

		public bool SynchronizedConfig = true;

		public abstract ConfigEntryBase BaseConfig { get; }
	}
	[PublicAPI]
	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;
			};
		}
	}
	[PublicAPI]
	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
	{
		[UsedImplicitly]
		public bool? ReadOnly = false;
	}
	[PublicAPI]
	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(0L, (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(0L, 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 SortedDictionary<int, byte[]> 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 != 0L)
			{
				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();
		}
	}
	[PublicAPI]
	[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>, string>((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 Hoard
{
	internal sealed class Target
	{
		internal string AssemblyName;

		internal MethodInfo Add;

		internal MethodInfo Remove;

		internal ConfigEntry<bool> Enabled;

		internal bool Patched;

		internal bool Broken;

		internal List<FieldInfo> Registries = new List<FieldInfo>();

		internal readonly HashSet<Container> Held = new HashSet<Container>();

		internal string Key => AssemblyName + "::" + Add.DeclaringType?.FullName + "::" + Add.Name;

		internal string Describe()
		{
			string text = (Broken ? "broken" : (Patched ? "active" : "off"));
			string text2 = ((Remove != null) ? Remove.Name : "(none)");
			return "[" + text + "] " + Key + "  evict via " + text2;
		}
	}
	internal static class Discovery
	{
		internal static readonly List<Target> Targets = new List<Target>();

		internal static readonly List<string> Lost = new List<string>();

		private static readonly HashSet<string> _seen = new HashSet<string>();

		private static bool _done;

		private static readonly string[] RemoveVerbs = new string[9] { "remove", "deregister", "unregister", "unwatch", "untrack", "forget", "drop", "purge", "clear" };

		private static readonly string[] AddVerbs = new string[4] { "add", "register", "track", "watch" };

		private static readonly string[] SkippedAssemblyNames = new string[10] { "mscorlib", "netstandard", "System", "0Harmony", "HarmonyX", "MonoMod", "Newtonsoft.Json", "YamlDotNet", "ICSharpCode.SharpZipLib", "SemanticVersioning" };

		private static readonly string[] SkippedAssemblyPrefixes = new string[10] { "assembly_", "UnityEngine", "Unity.", "System.", "BepInEx", "Mono.", "MonoMod.", "Microsoft.", "Valheim.", "Splatform" };

		internal static void EnsureDiscovered()
		{
			if (_done)
			{
				return;
			}
			_done = true;
			try
			{
				Scan();
			}
			catch (Exception arg)
			{
				Plugin.Log.LogError((object)$"Discovery failed, Hoard will do nothing this session: {arg}");
				return;
			}
			Interception.ApplyAll();
			try
			{
				FindLostTargets();
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("Could not compare with earlier sessions: " + ex.Message));
			}
		}

		private static void FindLostTargets()
		{
			Dictionary<ConfigDefinition, string> dictionary = Plugin.OrphanedConfigEntries();
			if (dictionary == null || dictionary.Count == 0)
			{
				return;
			}
			HashSet<string> hashSet = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
			Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
			foreach (Assembly assembly in assemblies)
			{
				try
				{
					hashSet.Add(assembly.GetName().Name);
				}
				catch
				{
				}
			}
			HashSet<string> hashSet2 = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
			foreach (Target target in Targets)
			{
				if (target.Patched)
				{
					hashSet2.Add(target.AssemblyName);
				}
			}
			foreach (KeyValuePair<ConfigDefinition, string> item2 in dictionary)
			{
				if (item2.Key.Section != "Targets")
				{
					continue;
				}
				string key = item2.Key.Key;
				int num = key.IndexOf("::", StringComparison.Ordinal);
				if (num > 0)
				{
					string item = key.Substring(0, num);
					if (hashSet.Contains(item) && !hashSet2.Contains(item) && bool.TryParse(item2.Value?.Trim(), out var result) && result)
					{
						Lost.Add(key);
						Plugin.Log.LogWarning((object)(key.Substring(0, num) + " is installed, but Hoard no longer recognises " + key.Substring(num + 2) + ". Sealed chests are not protected from that mod. Its update probably changed how it keeps its chests."));
					}
				}
			}
		}

		private static void Scan()
		{
			Stopwatch stopwatch = Stopwatch.StartNew();
			int num = 0;
			Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
			foreach (Assembly assembly in assemblies)
			{
				if (assembly.IsDynamic || IsSkipped(assembly))
				{
					continue;
				}
				num++;
				foreach (Type item in TypesOf(assembly))
				{
					try
					{
						if (!(item == null) && HoldsContainerCollection(item))
						{
							CollectFrom(assembly, item);
						}
					}
					catch (Exception ex)
					{
						Plugin.Log.LogWarning((object)("Skipped " + item?.FullName + " while scanning: " + ex.Message));
					}
				}
			}
			stopwatch.Stop();
			Plugin.Log.LogInfo((object)($"Scanned {num} assemblies in {stopwatch.ElapsedMilliseconds}ms, " + $"found {Targets.Count} container registration point(s)."));
			foreach (Target target in Targets)
			{
				Plugin.Log.LogInfo((object)("  " + target.Key + ((target.Remove != null) ? ("  (evict: " + target.Remove.Name + ")") : "  (no evict method)")));
			}
		}

		private static void CollectFrom(Assembly asm, Type type)
		{
			MethodInfo[] array;
			try
			{
				array = type.GetMethods(BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic).Where(TakesOneContainer).ToArray();
			}
			catch
			{
				return;
			}
			MethodInfo remove = array.FirstOrDefault((MethodInfo m) => StartsWithAny(m.Name, RemoveVerbs));
			MethodInfo[] array2 = array;
			foreach (MethodInfo methodInfo in array2)
			{
				if (StartsWithAny(methodInfo.Name, RemoveVerbs))
				{
					continue;
				}
				string name = asm.GetName().Name;
				Target target = new Target
				{
					AssemblyName = name,
					Add = methodInfo,
					Remove = remove,
					Registries = RegistryFields(type)
				};
				if (_seen.Add(target.Key))
				{
					target.Enabled = Plugin.BindTargetToggle(target, DefaultFor(name, methodInfo));
					target.Enabled.SettingChanged += delegate
					{
						Interception.ApplyPatchState(target);
					};
					Targets.Add(target);
				}
			}
		}

		private static bool DefaultFor(string assemblyName, MethodInfo add)
		{
			if (Plugin.IsDefaultOffAssembly(assemblyName))
			{
				return false;
			}
			return StartsWithAny(add.Name, AddVerbs);
		}

		private static bool TakesOneContainer(MethodInfo m)
		{
			if (m.IsAbstract || m.IsGenericMethodDefinition || m.ContainsGenericParameters)
			{
				return false;
			}
			if (m.ReturnType != typeof(void))
			{
				return false;
			}
			ParameterInfo[] parameters = m.GetParameters();
			if (parameters.Length == 1)
			{
				return parameters[0].ParameterType == typeof(Container);
			}
			return false;
		}

		private static bool HoldsContainerCollection(Type type)
		{
			FieldInfo[] fields;
			try
			{
				fields = type.GetFields(BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
			}
			catch
			{
				return false;
			}
			FieldInfo[] array = fields;
			for (int i = 0; i < array.Length; i++)
			{
				Type fieldType = array[i].FieldType;
				if (!fieldType.IsGenericType)
				{
					continue;
				}
				Type[] genericArguments = fieldType.GetGenericArguments();
				for (int j = 0; j < genericArguments.Length; j++)
				{
					if (genericArguments[j] == typeof(Container))
					{
						return true;
					}
				}
			}
			return false;
		}

		private static List<FieldInfo> RegistryFields(Type type)
		{
			List<FieldInfo> list = new List<FieldInfo>();
			try
			{
				FieldInfo[] fields = type.GetFields(BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
				foreach (FieldInfo fieldInfo in fields)
				{
					Type fieldType = fieldInfo.FieldType;
					if (fieldType.IsGenericType && fieldInfo.Name.IndexOf("remove", StringComparison.OrdinalIgnoreCase) < 0 && fieldType.GetGenericArguments().Contains<Type>(typeof(Container)))
					{
						list.Add(fieldInfo);
					}
				}
			}
			catch
			{
			}
			return list;
		}

		private static IEnumerable<Type> TypesOf(Assembly asm)
		{
			try
			{
				return asm.GetTypes();
			}
			catch (ReflectionTypeLoadException ex)
			{
				return ex.Types.Where((Type t) => t != null);
			}
			catch
			{
				return Array.Empty<Type>();
			}
		}

		private static bool IsSkipped(Assembly asm)
		{
			if (asm == typeof(Plugin).Assembly)
			{
				return true;
			}
			string name;
			try
			{
				name = asm.GetName().Name;
			}
			catch
			{
				return true;
			}
			string[] skippedAssemblyNames = SkippedAssemblyNames;
			foreach (string b in skippedAssemblyNames)
			{
				if (string.Equals(name, b, StringComparison.OrdinalIgnoreCase))
				{
					return true;
				}
			}
			skippedAssemblyNames = SkippedAssemblyPrefixes;
			foreach (string value in skippedAssemblyNames)
			{
				if (name.StartsWith(value, StringComparison.OrdinalIgnoreCase))
				{
					return true;
				}
			}
			return false;
		}

		private static bool StartsWithAny(string name, string[] verbs)
		{
			foreach (string value in verbs)
			{
				if (name.StartsWith(value, StringComparison.OrdinalIgnoreCase))
				{
					return true;
				}
			}
			return false;
		}
	}
	internal static class Exemption
	{
		internal const string ZdoKey = "isimp.Hoard.sealed";

		internal static readonly int ZdoHash = StringExtensionMethods.GetStableHashCode("isimp.Hoard.sealed");

		private const string SeidrChestName = "$piece_neobotics_sc_seidr_chest";

		private static FieldRef<Container, ZNetView> _nviewRef;

		private static bool _nviewRefResolved;

		internal static ZNetView Nview(Container container)
		{
			if ((Object)(object)container == (Object)null)
			{
				return null;
			}
			if (!_nviewRefResolved)
			{
				_nviewRefResolved = true;
				try
				{
					_nviewRef = AccessTools.FieldRefAccess<Container, ZNetView>("m_nview");
				}
				catch (Exception ex)
				{
					Plugin.Log.LogError((object)("Container.m_nview could not be resolved, so no chest can be read as sealed: " + ex.Message));
				}
			}
			if (_nviewRef == null)
			{
				return null;
			}
			try
			{
				return _nviewRef.Invoke(container);
			}
			catch
			{
				return null;
			}
		}

		internal static bool IsSealed(Container container)
		{
			if ((Object)(object)container == (Object)null)
			{
				return false;
			}
			if (Plugin.AutoSealSeidrChest && container.m_name == "$piece_neobotics_sc_seidr_chest")
			{
				return true;
			}
			ZNetView val = Nview(container);
			if ((Object)(object)val == (Object)null || !val.IsValid())
			{
				return false;
			}
			ZDO zDO = val.GetZDO();
			if (zDO != null)
			{
				return zDO.GetBool(ZdoHash, false);
			}
			return false;
		}

		internal static bool IsSealedBySeidrRule(Container container)
		{
			if ((Object)(object)container != (Object)null && Plugin.AutoSealSeidrChest)
			{
				return container.m_name == "$piece_neobotics_sc_seidr_chest";
			}
			return false;
		}

		internal static bool SetSealed(Container container, bool isSealed)
		{
			ZNetView val = Nview(container);
			if ((Object)(object)val == (Object)null || !val.IsValid())
			{
				return false;
			}
			val.ClaimOwnership();
			ZDO zDO = val.GetZDO();
			if (zDO == null)
			{
				return false;
			}
			zDO.Set(ZdoHash, isSealed);
			return true;
		}
	}
	internal static class Interception
	{
		private static readonly MethodInfo PrefixMethod = AccessTools.Method(typeof(Interception), "RegistrationPrefix", (Type[])null, (Type[])null);

		private static readonly Dictionary<MethodBase, Target> ByMethod = new Dictionary<MethodBase, Target>();

		private static bool RegistrationPrefix(Container __0, MethodBase __originalMethod)
		{
			if (!Exemption.IsSealed(__0))
			{
				return true;
			}
			if ((Object)(object)__0 != (Object)null && __originalMethod != null && ByMethod.TryGetValue(__originalMethod, out Target value))
			{
				value.Held.Add(__0);
			}
			return false;
		}

		internal static void ApplyAll()
		{
			foreach (Target target in Discovery.Targets)
			{
				ApplyPatchState(target);
			}
		}

		internal static void ApplyPatchState(Target target)
		{
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Expected O, but got Unknown
			bool flag = Plugin.Enabled && target.Enabled.Value && !target.Broken;
			if (flag == target.Patched)
			{
				return;
			}
			try
			{
				if (flag)
				{
					ByMethod[target.Add] = target;
					Plugin.Harmony.Patch((MethodBase)target.Add, new HarmonyMethod(PrefixMethod), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
					target.Patched = true;
					Plugin.Log.LogInfo((object)("Sealing honoured by " + target.Key));
					{
						foreach (Container item in SealSync.SealedContainers())
						{
							Evict(target, item);
						}
						return;
					}
				}
				Plugin.Harmony.Unpatch((MethodBase)target.Add, PrefixMethod);
				target.Patched = false;
				ByMethod.Remove(target.Add);
				Plugin.Log.LogInfo((object)("No longer intercepting " + target.Key));
				ReleaseAll(target);
			}
			catch (Exception ex)
			{
				target.Broken = true;
				target.Patched = false;
				ByMethod.Remove(target.Add);
				Plugin.Log.LogWarning((object)("Could not patch " + target.Key + ", that mod will keep seeing sealed chests: " + ex.Message));
			}
		}

		internal static void OnSealChanged(Container container, bool isSealed)
		{
			if ((Object)(object)container == (Object)null)
			{
				return;
			}
			foreach (Target target in Discovery.Targets)
			{
				if (target.Patched)
				{
					if (isSealed)
					{
						Evict(target, container);
					}
					else
					{
						Restore(target, container);
					}
				}
			}
		}

		internal static void Forget(Container container)
		{
			foreach (Target target in Discovery.Targets)
			{
				target.Held.Remove(container);
			}
		}

		private static void Evict(Target t, Container container)
		{
			if (!IsTracked(t, container))
			{
				return;
			}
			if (t.Remove == null)
			{
				Plugin.Log.LogInfo((object)(t.AssemblyName + " has no de-registration method; the seal takes effect there after the chest next unloads and reloads."));
				return;
			}
			try
			{
				t.Remove.Invoke(null, new object[1] { container });
				t.Held.Add(container);
				if (IsTracked(t, container))
				{
					Scrub(t, container);
				}
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)(t.Key + " refused a live update: " + ex.Message));
			}
		}

		private static void Restore(Target t, Container container)
		{
			if (!t.Held.Remove(container) || (Object)(object)container == (Object)null)
			{
				return;
			}
			try
			{
				t.Add.Invoke(null, new object[1] { container });
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)(t.Key + " refused a live update: " + ex.Message));
			}
		}

		private static void ReleaseAll(Target t)
		{
			List<Container> list = new List<Container>(t.Held);
			t.Held.Clear();
			foreach (Container item in list)
			{
				if (!((Object)(object)item == (Object)null))
				{
					try
					{
						t.Add.Invoke(null, new object[1] { item });
					}
					catch (Exception ex)
					{
						Plugin.Log.LogWarning((object)(t.Key + " refused a live update: " + ex.Message));
						break;
					}
				}
			}
		}

		private static void Scrub(Target t, Container container)
		{
			foreach (FieldInfo registry in t.Registries)
			{
				try
				{
					object value = registry.GetValue(null);
					if (value is ICollection<Container> { IsReadOnly: false } collection)
					{
						collection.Remove(container);
					}
					else if (value is IDictionary { IsReadOnly: false } dictionary)
					{
						dictionary.Remove(container);
					}
				}
				catch (Exception ex)
				{
					Plugin.Log.LogWarning((object)("Could not clear a sealed chest from " + t.Key + "." + registry.Name + ": " + ex.Message));
				}
			}
		}

		private static bool IsTracked(Target t, Container container)
		{
			if (t.Registries.Count == 0)
			{
				return true;
			}
			try
			{
				foreach (FieldInfo registry in t.Registries)
				{
					object value = registry.GetValue(null);
					if (value is ICollection<Container> collection && collection.Contains(container))
					{
						return true;
					}
					if (value is IDictionary dictionary && dictionary.Contains(container))
					{
						return true;
					}
				}
				return false;
			}
			catch
			{
				return true;
			}
		}
	}
	internal static class KeyLabels
	{
		private static readonly Dictionary<KeyCode, string> Cache = new Dictionary<KeyCode, string>();

		public unsafe static string Of(KeyCode key)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			if (Cache.TryGetValue(key, out string value))
			{
				return value;
			}
			string text = ((object)(*(KeyCode*)(&key))/*cast due to .constrained prefix*/).ToString();
			try
			{
				string text2 = ZInput.KeyCodeToDisplayName(key);
				if (text2 == null || text2.StartsWith("$KeyCode ", StringComparison.Ordinal))
				{
					return text;
				}
				string text3 = Pick(text2.Trim(), text);
				Cache[key] = text3;
				return text3;
			}
			catch
			{
				return text;
			}
		}

		private static string Pick(string shown, string name)
		{
			if (shown.Length != 1)
			{
				return name;
			}
			char c = shown[0];
			if (char.IsWhiteSpace(c) || char.IsControl(c))
			{
				return name;
			}
			return char.ToUpperInvariant(c).ToString();
		}
	}
	internal static class Marking
	{
		[HarmonyPatch(typeof(Container), "GetHoverText")]
		internal static class ContainerGetHoverTextPatch
		{
			[HarmonyPriority(0)]
			[HarmonyAfter(new string[] { "shudnal.MyLittleUI" })]
			private static void Postfix(Container __instance, ref string __result)
			{
				if (!Plugin.Enabled || !Plugin.ShowHoverHint || (Object)(object)__instance == (Object)null)
				{
					return;
				}
				if (Exemption.IsSealedBySeidrRule(__instance))
				{
					__result += "\n<color=#8fd3ff>Sealed while bound as a Seidr chest</color>";
					return;
				}
				bool num = Exemption.IsSealed(__instance);
				bool flag = HasAccess(__instance, flash: false);
				if (num)
				{
					__result += (flag ? ("\n<color=#8fd3ff>Sealed</color> — " + KeyLabel() + " unseal") : "\n<color=#8fd3ff>Sealed</color>");
				}
				else if (flag)
				{
					__result = __result + "\n" + KeyLabel() + " Seal from automation";
				}
			}
		}

		private const string SealSoundPrefab = "sfx_shieldgenerator_startup";

		private const string UnsealSoundPrefab = "sfx_shieldgenerator_shutdown";

		internal static void Poll()
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			if (Plugin.Enabled && !((Object)(object)Player.m_localPlayer == (Object)null) && Input.GetKeyDown(Plugin.MarkKey))
			{
				KeyCode markModifier = Plugin.MarkModifier;
				if (((int)markModifier == 0 || Input.GetKey(markModifier)) && InputAllowed())
				{
					ToggleHovered();
				}
			}
		}

		private static void ToggleHovered()
		{
			Player localPlayer = Player.m_localPlayer;
			Container val = HoveredContainer(localPlayer);
			if ((Object)(object)val == (Object)null)
			{
				return;
			}
			if (Exemption.IsSealedBySeidrRule(val))
			{
				Message(localPlayer, "Sealed automatically while bound as a Seidr chest.");
				return;
			}
			if (!HasAccess(val, flash: true))
			{
				Message(localPlayer, "$msg_cantopen");
				return;
			}
			if (InUse(val))
			{
				Message(localPlayer, "$msg_inuse");
				return;
			}
			bool flag = !Exemption.IsSealed(val);
			if (!Exemption.SetSealed(val, flag))
			{
				Message(localPlayer, "That container is not ready yet.");
				return;
			}
			SealSync.Refresh(val);
			PlaySound(val, flag);
			Message(localPlayer, flag ? "Chest sealed: automation mods will leave it alone." : "Chest unsealed: automation mods can use it again.");
		}

		private static bool InUse(Container container)
		{
			if (container.IsInUse())
			{
				return true;
			}
			ZNetView val = Exemption.Nview(container);
			ZDO val2 = (((Object)(object)val != (Object)null && val.IsValid()) ? val.GetZDO() : null);
			if (val2 != null)
			{
				return val2.GetInt(ZDOVars.s_inUse, 0) == 1;
			}
			return false;
		}

		private static Container HoveredContainer(Player player)
		{
			GameObject hoverObject = ((Humanoid)player).GetHoverObject();
			if ((Object)(object)hoverObject == (Object)null)
			{
				return null;
			}
			Container componentInParent = hoverObject.GetComponentInParent<Container>();
			if ((Object)(object)componentInParent != (Object)null)
			{
				return componentInParent;
			}
			Transform root = hoverObject.transform.root;
			if (!((Object)(object)root != (Object)null))
			{
				return null;
			}
			return ((Component)root).GetComponentInChildren<Container>();
		}

		internal static bool HasAccess(Container container, bool flash)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Invalid comparison between Unknown and I4
			if (!PrivateArea.CheckAccess(((Component)container).transform.position, 0f, flash, false))
			{
				return false;
			}
			PrivacySetting privacy = container.m_privacy;
			if ((int)privacy != 0)
			{
				if ((int)privacy == 2)
				{
					return true;
				}
				return false;
			}
			Piece val = ((Component)container).GetComponent<Piece>() ?? ((Component)container).GetComponentInParent<Piece>();
			if ((Object)(object)val != (Object)null)
			{
				return val.IsCreator();
			}
			return false;
		}

		private static bool InputAllowed()
		{
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)Chat.instance != (Object)null && Chat.instance.HasFocus())
			{
				return false;
			}
			if (Console.IsVisible() || TextInput.IsVisible() || StoreGui.IsVisible() || InventoryGui.IsVisible())
			{
				return false;
			}
			if ((Object)(object)TextViewer.instance != (Object)null && TextViewer.instance.IsVisible())
			{
				return false;
			}
			if (Minimap.IsOpen() || GameCamera.InFreeFly())
			{
				return false;
			}
			if (!((Character)localPlayer).InCutscene() && !((Character)localPlayer).InBed() && !((Character)localPlayer).IsTeleporting() && !((Character)localPlayer).IsDead())
			{
				return !((Character)localPlayer).InPlaceMode();
			}
			return false;
		}

		private static string KeyLabel()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			KeyCode markModifier = Plugin.MarkModifier;
			string text = (((int)markModifier == 0) ? KeyLabels.Of(Plugin.MarkKey) : (KeyLabels.Of(markModifier) + " + " + KeyLabels.Of(Plugin.MarkKey)));
			return "[<color=yellow><b>" + text + "</b></color>]";
		}

		private static void PlaySound(Container container, bool sealing)
		{
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			string text = (sealing ? "sfx_shieldgenerator_startup" : "sfx_shieldgenerator_shutdown");
			GameObject val = (((Object)(object)ZNetScene.instance != (Object)null) ? ZNetScene.instance.GetPrefab(text) : null);
			if ((Object)(object)val == (Object)null)
			{
				Plugin.Log.LogWarning((object)(text + " was not found, the seal is changed without a sound."));
			}
			else
			{
				Object.Instantiate<GameObject>(val, ((Component)container).transform.position, Quaternion.identity);
			}
		}

		private static void Message(Player player, string text)
		{
			((Character)player).Message((MessageType)2, text, 0, (Sprite)null, false);
		}
	}
	[BepInPlugin("isimp.Hoard", "Hoard", "0.2.1")]
	[BepInProcess("valheim.exe")]
	[BepInProcess("valheim_server.exe")]
	public class Plugin : BaseUnityPlugin
	{
		[HarmonyPatch(typeof(Player), "OnSpawned")]
		private static class LostTargetNotice
		{
			private static bool _shown;

			private static void Postfix(Player __instance)
			{
				if (_shown || (Object)(object)__instance != (Object)(object)Player.m_localPlayer)
				{
					return;
				}
				int num = 0;
				foreach (Target target in Discovery.Targets)
				{
					if (target.Broken)
					{
						num++;
					}
				}
				int num2 = Discovery.Lost.Count + num;
				if (num2 == 0)
				{
					return;
				}
				_shown = true;
				((Character)__instance).Message((MessageType)1, "Hoard: " + num2 + " supported mod(s) no longer honour seals. Type /hoard for details.", 0, (Sprite)null, false);
				if (!((Object)(object)Chat.instance != (Object)null))
				{
					return;
				}
				foreach (string item in Discovery.Lost)
				{
					((Terminal)Chat.instance).AddString("Hoard: no longer recognised, seals not honoured: " + item);
				}
				foreach (Target target2 in Discovery.Targets)
				{
					if (target2.Broken)
					{
						((Terminal)Chat.instance).AddString("Hoard: could not be patched, seals not honoured: " + target2.Key);
					}
				}
			}
		}

		[HarmonyPatch]
		private static class Bootstrap
		{
			[HarmonyPostfix]
			[HarmonyPatch(typeof(FejdStartup), "Awake")]
			private static void AfterMenu()
			{
				Discovery.EnsureDiscovered();
			}

			[HarmonyPostfix]
			[HarmonyPatch(typeof(Game), "Start")]
			private static void AfterGameStart()
			{
				Discovery.EnsureDiscovered();
			}
		}

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

			public static EventHandler <>9__39_0;

			public static EventHandler <>9__39_1;

			public static EventHandler <>9__39_2;

			public static EventHandler <>9__39_3;

			public static EventHandler <>9__39_4;

			public static ConsoleEvent <>9__46_0;

			internal void <Awake>b__39_0(object _, EventArgs __)
			{
				SealGlow.ApplyAll();
			}

			internal void <Awake>b__39_1(object _, EventArgs __)
			{
				SealGlow.ApplyAll();
			}

			internal void <Awake>b__39_2(object _, EventArgs __)
			{
				SealGlow.ApplyAll();
			}

			internal void <Awake>b__39_3(object _, EventArgs __)
			{
				SealGlow.ApplyAll();
			}

			internal void <Awake>b__39_4(object _, EventArgs __)
			{
				Interception.ApplyAll();
				SealGlow.ApplyAll();
			}

			internal void <RegisterConsoleCommand>b__46_0(ConsoleEventArgs args)
			{
				List<Target> targets = Discovery.Targets;
				if (targets.Count == 0 && Discovery.Lost.Count == 0)
				{
					Terminal context = args.Context;
					if (context != null)
					{
						context.AddString("Hoard: nothing discovered (no container-automation mods loaded).");
					}
					return;
				}
				StringBuilder stringBuilder = new StringBuilder();
				stringBuilder.Append("Hoard: ").Append(targets.Count).Append(" registration point(s)");
				foreach (Target item in targets)
				{
					stringBuilder.Append('\n').Append("  ").Append(item.Describe());
				}
				foreach (string item2 in Discovery.Lost)
				{
					stringBuilder.Append('\n').Append("  [no longer found] ").Append(item2);
				}
				string text = stringBuilder.ToString();
				Terminal context2 = args.Context;
				if (context2 != null)
				{
					context2.AddString(text);
				}
				Log.LogInfo((object)text);
			}
		}

		public const string Guid = "isimp.Hoard";

		public const string Name = "Hoard";

		public const string Version = "0.2.1";

		private const string MinimumVersion = "0.1.0";

		public static ManualLogSource Log;

		internal static Harmony Harmony;

		private static ConfigFile _config;

		private static ConfigSync _sync;

		private static ConfigEntry<bool> _lockConfig;

		private static ConfigEntry<bool> _enabled;

		private static ConfigEntry<KeyCode> _markKey;

		private static ConfigEntry<KeyCode> _markModifier;

		private static ConfigEntry<bool> _autoSealSeidrChest;

		private static ConfigEntry<bool> _showHoverHint;

		private static ConfigEntry<bool> _showSealGlow;

		private static ConfigEntry<bool> _showSealEffect;

		private static ConfigEntry<Color> _sealGlowColor;

		private static ConfigEntry<float> _sealGlowStrength;

		private static ConfigEntry<string> _defaultOffAssemblies;

		private static readonly Color SealGlowDefault = new Color(0.47058824f, 19f / 51f, 0.6901961f, 0f);

		internal static bool Enabled
		{
			get
			{
				if (_enabled != null)
				{
					return _enabled.Value;
				}
				return true;
			}
		}

		internal static KeyCode MarkKey => (KeyCode)(((??)_markKey?.Value) ?? 107);

		internal static KeyCode MarkModifier => (KeyCode)(((??)_markModifier?.Value) ?? 0);

		internal static bool AutoSealSeidrChest
		{
			get
			{
				if (_autoSealSeidrChest != null)
				{
					return _autoSealSeidrChest.Value;
				}
				return false;
			}
		}

		internal static bool ShowHoverHint
		{
			get
			{
				if (_showHoverHint != null)
				{
					return _showHoverHint.Value;
				}
				return true;
			}
		}

		internal static bool ShowSealGlow
		{
			get
			{
				if (_showSealGlow != null)
				{
					return _showSealGlow.Value;
				}
				return true;
			}
		}

		internal static bool ShowSealEffect
		{
			get
			{
				if (_showSealEffect != null)
				{
					return _showSealEffect.Value;
				}
				return true;
			}
		}

		internal static Color SealGlowColor => _sealGlowColor?.Value ?? SealGlowDefault;

		internal static float SealGlowStrength => _sealGlowStrength?.Value ?? 0.25f;

		private ConfigEntry<T> Rule<T>(string group, string name, T value, string description)
		{
			ConfigEntry<T> val = ((BaseUnityPlugin)this).Config.Bind<T>(group, name, value, description);
			_sync.AddConfigEntry<T>(val).SynchronizedConfig = true;
			return val;
		}

		private void Awake()
		{
			//IL_0193: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01df: Expected O, but got Unknown
			//IL_02b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c0: Expected O, but got Unknown
			Log = ((BaseUnityPlugin)this).Logger;
			_config = ((BaseUnityPlugin)this).Config;
			_sync = new ConfigSync("isimp.Hoard")
			{
				DisplayName = "Hoard",
				CurrentVersion = ((BaseUnityPlugin)this).Info.Metadata.Version.ToString(),
				MinimumRequiredVersion = "0.1.0",
				ModRequired = true
			};
			_lockConfig = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "LockConfiguration", true, "Whether the server's sealing rules override local settings. Admins are exempt. The key and hover text settings always stay local.");
			_sync.AddLockingConfigEntry<bool>(_lockConfig);
			_enabled = Rule("General", "Enabled", value: true, "Whether seals are honoured. Turning this off releases every sealed chest to the automation mods without clearing the seals, so turning it back on restores them.");
			_markKey = ((BaseUnityPlugin)this).Config.Bind<KeyCode>("General", "MarkKey", (KeyCode)107, "Look at a chest and press this to seal or unseal it.");
			_markModifier = ((BaseUnityPlugin)this).Config.Bind<KeyCode>("General", "MarkModifier", (KeyCode)0, "Optional key that must be held along with MarkKey, such as LeftAlt.");
			_autoSealSeidrChest = Rule("General", "AutoSealSeidrChest", value: false, "Automatically seal the chest SeidrChest currently has bound. SeidrChest keeps that chest loaded at its real position, so automation mods near your base treat it as an ordinary chest. The seal lifts when the chest is unbound.");
			_showHoverHint = ((BaseUnityPlugin)this).Config.Bind<bool>("Display", "ShowHoverHint", true, "Show the key and whether the chest is sealed in a chest's hover text. The message on sealing or unsealing shows either way.");
			_defaultOffAssemblies = Rule("Targets", "DefaultOffAssemblies", "CarturMapPins", "Comma-separated assembly names whose registration points start switched off when discovered. The default covers a map pin mod that only reads chests. This only sets the initial value; each target's own entry below takes over afterwards.");
			_showSealGlow = ((BaseUnityPlugin)this).Config.Bind<bool>("Display", "ShowSealGlow", true, "Give sealed chests a faint, steady tint, so they can be told apart without hovering over them. A building or storage highlight takes precedence while it lasts.");
			_showSealEffect = ((BaseUnityPlugin)this).Config.Bind<bool>("Display", "ShowSealEffect", true, "Show a small shimmer above sealed chests.");
			_sealGlowColor = ((BaseUnityPlugin)this).Config.Bind<Color>("Display", "SealGlowColor", SealGlowDefault, "The colour of the tint.");
			_sealGlowStrength = ((BaseUnityPlugin)this).Config.Bind<float>("Display", "SealGlowStrength", 0.25f, new ConfigDescription("How strong the tint is. The building highlight uses about 0.4.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.01f, 1f), Array.Empty<object>()));
			_showSealGlow.SettingChanged += delegate
			{
				SealGlow.ApplyAll();
			};
			_showSealEffect.SettingChanged += delegate
			{
				SealGlow.ApplyAll();
			};
			_sealGlowColor.SettingChanged += delegate
			{
				SealGlow.ApplyAll();
			};
			_sealGlowStrength.SettingChanged += delegate
			{
				SealGlow.ApplyAll();
			};
			_enabled.SettingChanged += delegate
			{
				Interception.ApplyAll();
				SealGlow.ApplyAll();
			};
			Harmony = new Harmony("isimp.Hoard");
			try
			{
				Harmony.PatchAll(typeof(Marking.ContainerGetHoverTextPatch));
				Harmony.PatchAll(typeof(SealSync.ContainerAwakePatch));
				Harmony.PatchAll(typeof(LostTargetNotice));
				Harmony.PatchAll(typeof(Bootstrap));
			}
			catch (Exception arg)
			{
				Log.LogError((object)$"Failed to apply own patches, Hoard will do nothing this session: {arg}");
				return;
			}
			RegisterConsoleCommand();
			Log.LogInfo((object)"Hoard 0.2.1 loaded.");
		}

		private void Update()
		{
			Marking.Poll();
			SealSync.Tick();
		}

		private void OnDestroy()
		{
			((BaseUnityPlugin)this).Config.Save();
		}

		internal static ConfigEntry<bool> BindTargetToggle(Target target, bool defaultValue)
		{
			ConfigEntry<bool> val = _config.Bind<bool>("Targets", target.Key, defaultValue, "Whether a sealed chest is hidden from this registration point. " + ((target.Remove == null) ? "This mod has no de-registration method, so changes here take effect after the chest reloads." : "Sealing or unsealing a chest takes effect here immediately."));
			if (_sync != null)
			{
				_sync.AddConfigEntry<bool>(val).SynchronizedConfig = true;
			}
			return val;
		}

		internal static bool IsDefaultOffAssembly(string assemblyName)
		{
			string text = _defaultOffAssemblies?.Value;
			if (string.IsNullOrEmpty(text))
			{
				return false;
			}
			string[] array = text.Split(new char[1] { ',' });
			for (int i = 0; i < array.Length; i++)
			{
				if (string.Equals(array[i].Trim(), assemblyName, StringComparison.OrdinalIgnoreCase))
				{
					return true;
				}
			}
			return false;
		}

		internal static Dictionary<ConfigDefinition, string> OrphanedConfigEntries()
		{
			try
			{
				return AccessTools.Property(typeof(ConfigFile), "OrphanedEntries")?.GetValue(_config, null) as Dictionary<ConfigDefinition, string>;
			}
			catch (Exception ex)
			{
				Log.LogWarning((object)("Could not read earlier config entries: " + ex.Message));
				return null;
			}
		}

		private static void RegisterConsoleCommand()
		{
			//IL_0033: 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_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Expected O, but got Unknown
			object obj = <>c.<>9__46_0;
			if (obj == null)
			{
				ConsoleEvent val = delegate(ConsoleEventArgs args)
				{
					List<Target> targets = Discovery.Targets;
					if (targets.Count == 0 && Discovery.Lost.Count == 0)
					{
						Terminal context = args.Context;
						if (context != null)
						{
							context.AddString("Hoard: nothing discovered (no container-automation mods loaded).");
						}
					}
					else
					{
						StringBuilder stringBuilder = new StringBuilder();
						stringBuilder.Append("Hoard: ").Append(targets.Count).Append(" registration point(s)");
						foreach (Target item in targets)
						{
							stringBuilder.Append('\n').Append("  ").Append(item.Describe());
						}
						foreach (string item2 in Discovery.Lost)
						{
							stringBuilder.Append('\n').Append("  [no longer found] ").Append(item2);
						}
						string text = stringBuilder.ToString();
						Terminal context2 = args.Context;
						if (context2 != null)
						{
							context2.AddString(text);
						}
						Log.LogInfo((object)text);
					}
				};
				<>c.<>9__46_0 = val;
				obj = (object)val;
			}
			new ConsoleCommand("hoard", "List the container registration points Hoard found.", (ConsoleEvent)obj, false, false, false, false, false, false, (ConsoleOptionsFetcher)null, false, false, false);
		}
	}
	internal static class SealGlow
	{
		private const string EffectName = "Hoard_SealEffect";

		private const string EffectPrefab = "vfx_TrollPheromones";

		private const float EffectScale = 0.5f;

		private const float EffectHeight = 0.9f;

		private const float EffectLightDistance = 30f;

		private static readonly int EmissionColor = Shader.PropertyToID("_EmissionColor");

		private static readonly bool Headless = Application.isBatchMode;

		private static GameObject _effectSource;

		private static bool _effectMissing;

		internal static void Apply(Container container, bool isSealed)
		{
			if (!Headless && !((Object)(object)container == (Object)null))
			{
				bool flag = isSealed && Plugin.Enabled;
				ApplyTint(container, flag && Plugin.ShowSealGlow);
				ApplyEffect(container, flag && Plugin.ShowSealEffect);
			}
		}

		internal static void Maintain(Container container)
		{
			if (!Headless && !((Object)(object)container == (Object)null) && Plugin.Enabled && Plugin.ShowSealGlow)
			{
				WearNTear componentInParent = ((Component)container).GetComponentInParent<WearNTear>();
				if (!((Object)(object)componentInParent != (Object)null) || !((MonoBehaviour)componentInParent).IsInvoking("ResetHighlight"))
				{
					ApplyTint(container, on: true);
				}
			}
		}

		internal static void ApplyAll()
		{
			foreach (Container item in SealSync.SealedContainers())
			{
				Apply(item, isSealed: true);
			}
		}

		private static void ApplyTint(Container container, bool on)
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			MaterialMan instance = MaterialMan.instance;
			GameObject val = TintTarget(container);
			if (!((Object)(object)instance == (Object)null) && !((Object)(object)val == (Object)null))
			{
				if (on)
				{
					instance.SetValue<Color>(val, EmissionColor, Plugin.SealGlowColor * Plugin.SealGlowStrength, false);
				}
				else
				{
					instance.ResetValue(val, EmissionColor);
				}
			}
		}

		private static GameObject TintTarget(Container container)
		{
			WearNTear componentInParent = ((Component)container).GetComponentInParent<WearNTear>();
			GameObject val = (((Object)(object)componentInParent != (Object)null) ? ((Component)componentInParent).gameObject : ((Component)container).gameObject);
			if (!((Object)(object)val == (Object)(object)((Component)container).gameObject))
			{
				return null;
			}
			return val;
		}

		private static void ApplyEffect(Container container, bool on)
		{
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Expected O, but got Unknown
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			//IL_010f: Unknown result type (might be due to invalid IL or missing references)
			Transform val = ((Component)container).transform.Find("Hoard_SealEffect");
			if (!on)
			{
				if ((Object)(object)val != (Object)null)
				{
					Object.Destroy((Object)(object)((Component)val).gameObject);
				}
			}
			else
			{
				if ((Object)(object)val != (Object)null)
				{
					return;
				}
				GameObject val2 = EffectSource();
				if ((Object)(object)val2 == (Object)null)
				{
					return;
				}
				GameObject val3 = new GameObject("Hoard_SealEffectHolder");
				val3.SetActive(false);
				GameObject val4 = Object.Instantiate<GameObject>(val2, val3.transform, false);
				StripToVisuals(val4);
				Light[] componentsInChildren = val4.GetComponentsInChildren<Light>(true);
				foreach (Light val5 in componentsInChildren)
				{
					if ((Object)(object)((Component)val5).GetComponent<LightLod>() == (Object)null)
					{
						LightLod obj = ((Component)val5).gameObject.AddComponent<LightLod>();
						obj.m_lightDistance = 30f;
						obj.m_shadowLod = false;
					}
				}
				((Object)val4).name = "Hoard_SealEffect";
				val4.transform.SetParent(((Component)container).transform, false);
				val4.transform.localPosition = Vector3.up * 0.9f;
				val4.transform.localRotation = Quaternion.identity;
				val4.transform.localScale = Vector3.one * 0.5f;
				Object.Destroy((Object)(object)val3);
				val4.SetActive(true);
			}
		}

		private static GameObject EffectSource()
		{
			if ((Object)(object)_effectSource != (Object)null || _effectMissing)
			{
				return _effectSource;
			}
			_effectSource = (((Object)(object)ZNetScene.instance != (Object)null) ? ZNetScene.instance.GetPrefab("vfx_TrollPheromones") : null);
			if ((Object)(object)_effectSource == (Object)null && (Object)(object)ZNetScene.instance != (Object)null)
			{
				_effectMissing = true;
				Plugin.Log.LogWarning((object)"vfx_TrollPheromones was not found, sealed chests get the tint only.");
			}
			return _effectSource;
		}

		private static void StripToVisuals(GameObject copy)
		{
			string[][] array = new string[3][]
			{
				new string[3] { "script", "Joint", "AudioSource" },
				new string[1] { "Collider" },
				new string[1] { "Rigidbody" }
			};
			foreach (string[] array2 in array)
			{
				Component[] componentsInChildren = copy.GetComponentsInChildren<Component>(true);
				foreach (Component val in componentsInChildren)
				{
					if ((Object)(object)val == (Object)null || val is Transform)
					{
						continue;
					}
					string name = ((object)val).GetType().Name;
					bool flag = val is MonoBehaviour && name != "LightFlicker" && name != "LightLod";
					string[] array3 = array2;
					foreach (string text in array3)
					{
						if ((text == "script") ? flag : name.EndsWith(text, StringComparison.Ordinal))
						{
							Object.DestroyImmediate((Object)(object)val);
							break;
						}
					}
				}
			}
		}
	}
	internal static class SealSync
	{
		[HarmonyPatch(typeof(Container), "Awake")]
		internal static class ContainerAwakePatch
		{
			private static void Postfix(Container __instance)
			{
				if ((Object)(object)__instance != (Object)null && !Known.ContainsKey(__instance))
				{
					bool flag = Exemption.IsSealed(__instance);
					Known[__instance] = flag;
					if (flag)
					{
						SealGlow.Apply(__instance, isSealed: true);
					}
				}
			}
		}

		private const float Interval = 0.5f;

		private static readonly Dictionary<Container, bool> Known = new Dictionary<Container, bool>();

		private static readonly List<Container> Scratch = new List<Container>();

		private static float _nextCheck;

		internal static void Tick()
		{
			if (Known.Count == 0 || Time.unscaledTime < _nextCheck)
			{
				return;
			}
			_nextCheck = Time.unscaledTime + 0.5f;
			Scratch.Clear();
			Scratch.AddRange(Known.Keys);
			foreach (Container item in Scratch)
			{
				if ((Object)(object)item == (Object)null)
				{
					Known.Remove(item);
					Interception.Forget(item);
					continue;
				}
				Refresh(item);
				if (Known.TryGetValue(item, out var value) && value)
				{
					SealGlow.Maintain(item);
				}
			}
		}

		internal static void Refresh(Container container)
		{
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)container == (Object)null))
			{
				bool flag = Exemption.IsSealed(container);
				if (!Known.TryGetValue(container, out var value) || value != flag)
				{
					Known[container] = flag;
					Plugin.Log.LogInfo((object)string.Format("Chest {0}: {1} at {2}", flag ? "sealed" : "unsealed", ((Object)container).name, ((Component)container).transform.position));
					Interception.OnSealChanged(container, flag);
					SealGlow.Apply(container, flag);
				}
			}
		}

		internal static List<Container> SealedContainers()
		{
			List<Container> list = new List<Container>();
			foreach (KeyValuePair<Container, bool> item in Known)
			{
				if (item.Value && (Object)(object)item.Key != (Object)null)
				{
					list.Add(item.Key);
				}
			}
			return list;
		}
	}
}