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 System.Threading;
using BFVCombatPrio.Claim;
using BFVCombatPrio.Commands;
using BFVCombatPrio.Config;
using BFVCombatPrio.Diagnostics;
using BFVCombatPrio.Patches;
using BFVCombatPrio.Rank;
using BFVCombatPrio.Sync;
using BFVCombatPrio.Util;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
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.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: AssemblyVersion("0.0.0.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
{
	public abstract class OwnConfigEntryBase
	{
		public object? LocalBaseValue;

		public bool SynchronizedConfig = true;

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

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

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

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

		public readonly string Identifier;

		public readonly Type Type;

		private object? boxedValue;

		protected bool localIsOwner;

		public readonly int Priority;

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

		public event Action? ValueChanged;

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

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

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

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

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

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

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

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

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

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

				public volatile int versionMatchQueued = -1;

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

				public readonly ISocket Original;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

		private class PackageEntry
		{
			public string section;

			public string key;

			public Type type;

			public object? value;
		}

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

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

		private class InvalidDeserializationTypeException : Exception
		{
			public string expected;

			public string received;

			public string field = "";
		}

		public static bool ProcessingServerUpdate;

		public readonly string Name;

		public string? DisplayName;

		public string? CurrentVersion;

		public string? MinimumRequiredVersion;

		public bool ModRequired;

		private bool? forceConfigLocking;

		private bool isSourceOfTruth = true;

		private static readonly HashSet<ConfigSync> configSyncs;

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

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

		private static bool isServer;

		private static bool lockExempt;

		private OwnConfigEntryBase? lockedConfig;

		private const byte PARTIAL_CONFIGS = 1;

		private const byte FRAGMENTED_CONFIG = 2;

		private const byte COMPRESSED_CONFIG = 4;

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

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

		private static long packageCounter;

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

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

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

		public bool InitialSyncDone { get; private set; }

		public event Action<bool>? SourceOfTruthChanged;

		private event Action? lockedConfigChanged;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

		private static readonly Dictionary<string, string> notProcessedNames;

		public string Name;

		private string? displayName;

		private string? currentVersion;

		private string? minimumRequiredVersion;

		public bool ModRequired = true;

		private string? ReceivedCurrentVersion;

		private string? ReceivedMinimumRequiredVersion;

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

		private ConfigSync? ConfigSync;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

		internal static CombatPrioConfig Cfg { get; private set; }

		private void Awake()
		{
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Expected O, but got Unknown
			Cfg = new CombatPrioConfig(((BaseUnityPlugin)this).Config);
			Log.Init(((BaseUnityPlugin)this).Logger, () => Cfg.DebugLogging.Value);
			CombatClassifier.Init();
			ClaimList.Init();
			((BaseUnityPlugin)this).Config.SettingChanged += OnSettingChanged;
			_harmony = new Harmony("com.bfv.CombatPrio");
			PatchInit.ApplyAll(_harmony);
			try
			{
				CombatPrioCommands.Register();
			}
			catch
			{
			}
			try
			{
				ConfigLiveReload.Begin((MonoBehaviour)(object)this, ((BaseUnityPlugin)this).Config, _harmony);
				Log.Info("[Patch OK] Server CFG live reload (FileSystemWatcher)");
			}
			catch (Exception ex)
			{
				Log.Error("[Patch FAILED] Server CFG live reload: " + ex.Message + " — Config Manager and restart still work.");
			}
			Log.Info("BFV Combat Priority 1.3.0 loaded. Send order Player→Ram→Combat→Proj→Rest is " + (Cfg.Enabled.Value ? "ON" : "OFF") + ". Abandoned ram claim is " + (Cfg.AbandonedClaimEnabled.Value ? "ON" : "OFF") + " (" + (string.IsNullOrWhiteSpace(Cfg.AbandonedClaimExactNames.Value) ? "no ram names" : "names set") + "). Listed ram names also get ram-tier send even if claim is off. Send-order never Prefixes Serialize. Claim only SetOwner(0) on listed rams at death/DC/stale use.");
		}

		private static void OnSettingChanged(object sender, EventArgs e)
		{
			CombatClassifier.Rebuild();
			ClaimList.Rebuild();
		}

		private void OnDestroy()
		{
			try
			{
				ConfigLiveReload.Dispose();
			}
			catch
			{
			}
			try
			{
				Harmony harmony = _harmony;
				if (harmony != null)
				{
					harmony.UnpatchSelf();
				}
			}
			catch (Exception ex)
			{
				Log.Error("Unpatch failed: " + ex.Message);
			}
		}
	}
	internal static class PluginInfo
	{
		public const string PLUGIN_GUID = "com.bfv.CombatPrio";

		public const string PLUGIN_NAME = "BFV Combat Priority";

		public const string PLUGIN_VERSION = "1.3.0";

		public const string FgnGuid = "com.Fire.FiresGhettoNetworkMod";

		public const string ReplicaGuid = "com.bfv.PlayerReplica";

		public const string SiegeFreezeGuid = "com.bfv.SiegeFreeze";
	}
}
namespace BFVCombatPrio.Util
{
	internal static class Log
	{
		private static ManualLogSource _source;

		private static Func<bool> _debugEnabled;

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

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

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

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

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

		internal static void Debug(string message)
		{
			if (IsDebugEnabled)
			{
				ManualLogSource source = _source;
				if (source != null)
				{
					source.LogInfo((object)("[Debug] " + message));
				}
			}
		}
	}
}
namespace BFVCombatPrio.Sync
{
	internal static class CombatPrioSync
	{
		internal static readonly ConfigSync Instance = new ConfigSync("com.bfv.CombatPrio")
		{
			DisplayName = "BFV Combat Priority",
			CurrentVersion = "1.3.0",
			ModRequired = false
		};
	}
}
namespace BFVCombatPrio.Rank
{
	internal static class CombatClassifier
	{
		internal const byte Player = 0;

		internal const byte Ram = 1;

		internal const byte Combat = 2;

		internal const byte Projectile = 3;

		internal const byte Rest = 4;

		internal const int RankCount = 5;

		private static int _playerHash;

		private static HashSet<int> _ramExact = new HashSet<int>();

		private static HashSet<int> _exact = new HashSet<int>();

		private static string[] _contains = Array.Empty<string>();

		private static Dictionary<int, byte> _cache = new Dictionary<int, byte>(256);

		private static Dictionary<int, string> _names = new Dictionary<int, string>(256);

		internal static string RankLabel(byte rank)
		{
			return rank switch
			{
				0 => "Player", 
				1 => "Ram", 
				2 => "Combat", 
				3 => "Proj", 
				_ => "Rest", 
			};
		}

		internal static string PrefabLabel(int prefab)
		{
			Dictionary<int, string> names = _names;
			if (names.TryGetValue(prefab, out var value))
			{
				return value;
			}
			if ((Object)(object)ZNetScene.instance == (Object)null)
			{
				return "hash=" + prefab;
			}
			string text = "hash=" + prefab;
			GameObject prefab2 = ZNetScene.instance.GetPrefab(prefab);
			if ((Object)(object)prefab2 != (Object)null && !string.IsNullOrEmpty(((Object)prefab2).name))
			{
				text = ((Object)prefab2).name;
			}
			names[prefab] = text;
			return text;
		}

		internal static void Init()
		{
			_playerHash = StringExtensionMethods.GetStableHashCode("Player");
			Rebuild();
		}

		internal static void Rebuild()
		{
			HashSet<int> hashSet = new HashSet<int>();
			HashSet<int> hashSet2 = new HashSet<int>();
			List<string> list = new List<string>();
			CombatPrioConfig cfg = Plugin.Cfg;
			if (cfg != null)
			{
				SplitAddExact(cfg.AbandonedClaimExactNames.Value, hashSet);
				SplitAddExact(cfg.CombatStructureExactNames.Value, hashSet2);
				SplitAddContains(cfg.CombatStructureNameContains.Value, list);
			}
			_ramExact = hashSet;
			_exact = hashSet2;
			_contains = list.ToArray();
			_cache = new Dictionary<int, byte>(256);
			_names = new Dictionary<int, string>(256);
		}

		internal static byte Of(ZDO zdo)
		{
			if (zdo == null)
			{
				return 4;
			}
			int prefab = zdo.GetPrefab();
			if (_playerHash != 0 && prefab == _playerHash)
			{
				return 0;
			}
			Dictionary<int, byte> cache = _cache;
			if (cache.TryGetValue(prefab, out var value))
			{
				return value;
			}
			bool flag = (Object)(object)ZNetScene.instance != (Object)null;
			byte b = Classify(zdo, prefab, flag);
			if (flag)
			{
				cache[prefab] = b;
			}
			return b;
		}

		private static byte Classify(ZDO zdo, int prefab, bool sceneReady)
		{
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Invalid comparison between Unknown and I4
			if (_ramExact.Contains(prefab))
			{
				return 1;
			}
			if (_exact.Contains(prefab))
			{
				return 2;
			}
			if (sceneReady)
			{
				GameObject prefab2 = ZNetScene.instance.GetPrefab(prefab);
				if ((Object)(object)prefab2 != (Object)null)
				{
					if (NameMatches(((Object)prefab2).name))
					{
						return 2;
					}
					if ((Object)(object)prefab2.GetComponent<Projectile>() != (Object)null)
					{
						return 3;
					}
					if (IsCombatPrefab(prefab2))
					{
						return 2;
					}
				}
			}
			if ((int)zdo.Type == 1)
			{
				return 2;
			}
			return 4;
		}

		private static bool IsCombatPrefab(GameObject go)
		{
			if ((Object)(object)go.GetComponent<Character>() != (Object)null)
			{
				return true;
			}
			if ((Object)(object)go.GetComponent<Aoe>() != (Object)null)
			{
				return true;
			}
			if ((Object)(object)go.GetComponent<Ship>() != (Object)null)
			{
				return true;
			}
			if ((Object)(object)go.GetComponent<Turret>() != (Object)null)
			{
				return true;
			}
			if ((Object)(object)go.GetComponent<Trap>() != (Object)null)
			{
				return true;
			}
			return false;
		}

		private static bool NameMatches(string name)
		{
			if (string.IsNullOrEmpty(name) || _contains.Length == 0)
			{
				return false;
			}
			for (int i = 0; i < _contains.Length; i++)
			{
				if (name.IndexOf(_contains[i], StringComparison.OrdinalIgnoreCase) >= 0)
				{
					return true;
				}
			}
			return false;
		}

		private static void SplitAddExact(string raw, HashSet<int> into)
		{
			if (string.IsNullOrWhiteSpace(raw))
			{
				return;
			}
			string[] array = raw.Split(new char[3] { ',', ';', '\n' }, StringSplitOptions.RemoveEmptyEntries);
			for (int i = 0; i < array.Length; i++)
			{
				string text = array[i].Trim();
				if (text.Length != 0)
				{
					into.Add(StringExtensionMethods.GetStableHashCode(text));
				}
			}
		}

		private static void SplitAddContains(string raw, List<string> into)
		{
			if (string.IsNullOrWhiteSpace(raw))
			{
				return;
			}
			string[] array = raw.Split(new char[3] { ',', ';', '\n' }, StringSplitOptions.RemoveEmptyEntries);
			for (int i = 0; i < array.Length; i++)
			{
				string text = array[i].Trim();
				if (text.Length != 0)
				{
					into.Add(text);
				}
			}
		}
	}
}
namespace BFVCombatPrio.Patches
{
	[HarmonyPatch]
	internal static class ClaimPatches
	{
		[HarmonyPatch(typeof(Player), "OnDeath")]
		[HarmonyPostfix]
		private static void Player_OnDeath_Postfix(Player __instance)
		{
			if (!ClaimList.IsActive || (Object)(object)__instance == (Object)null)
			{
				return;
			}
			try
			{
				ZNetView view = VanillaCalls.GetView((Component)(object)__instance);
				if (!((Object)(object)view == (Object)null) && view.IsOwner())
				{
					RamRelease.OnPlayerAbandoned(__instance, "death-client");
				}
			}
			catch (Exception ex)
			{
				ClaimList.FailOpen(ex.GetType().Name + ": " + ex.Message);
			}
		}

		[HarmonyPatch(typeof(Player), "RPC_OnDeath")]
		[HarmonyPostfix]
		private static void Player_RPC_OnDeath_Postfix(Player __instance)
		{
			if (!ClaimList.IsActive || (Object)(object)__instance == (Object)null)
			{
				return;
			}
			try
			{
				if (!((Object)(object)ZNet.instance == (Object)null) && ZNet.instance.IsServer())
				{
					RamRelease.OnPlayerAbandoned(__instance, "death-server");
				}
			}
			catch (Exception ex)
			{
				ClaimList.FailOpen(ex.GetType().Name + ": " + ex.Message);
			}
		}

		[HarmonyPatch(typeof(ZNet), "Disconnect")]
		[HarmonyPrefix]
		private static void ZNet_Disconnect_Prefix(ZNetPeer peer)
		{
			if (!ClaimList.IsActive || peer == null)
			{
				return;
			}
			try
			{
				if (!((Object)(object)ZNet.instance == (Object)null) && ZNet.instance.IsServer())
				{
					RamRelease.OnPeerDisconnected(peer);
				}
			}
			catch (Exception ex)
			{
				ClaimList.FailOpen(ex.GetType().Name + ": " + ex.Message);
			}
		}

		[HarmonyPatch(typeof(Chair), "Interact")]
		[HarmonyPrefix]
		private static bool Chair_Interact_Prefix(Chair __instance, Humanoid human, bool hold, bool alt, ref bool __result)
		{
			//IL_0080: 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)
			if (hold || !ClaimList.IsActive || (Object)(object)__instance == (Object)null)
			{
				return true;
			}
			try
			{
				ZNetView val = ClaimList.FindView((Component)(object)__instance);
				if ((Object)(object)val == (Object)null || !ClaimList.IsListed(val))
				{
					return true;
				}
				RamRelease.TryReleaseIfStale(val.GetZDO());
				Player val2 = (Player)(object)((human is Player) ? human : null);
				if ((Object)(object)val2 == (Object)null || (Object)(object)val2 != (Object)(object)Player.m_localPlayer)
				{
					return true;
				}
				Transform attachPoint = __instance.m_attachPoint;
				if ((Object)(object)attachPoint == (Object)null)
				{
					return true;
				}
				Player closestPlayer = Player.GetClosestPlayer(attachPoint.position, 0.1f);
				if ((Object)(object)closestPlayer == (Object)null || (Object)(object)closestPlayer == (Object)(object)val2 || !((Character)closestPlayer).IsDead())
				{
					return true;
				}
				if (!VanillaCalls.ChairInUseDistance(__instance, human))
				{
					__result = false;
					return false;
				}
				if (Time.time - VanillaCalls.GetChairLastSitTime() < 2f)
				{
					__result = false;
					return false;
				}
				if (((Character)val2).IsEncumbered())
				{
					__result = false;
					return false;
				}
				((Character)val2).AttachStart(attachPoint, (GameObject)null, false, false, __instance.m_inShip, __instance.m_attachAnimation, __instance.m_detachOffset, (Transform)null);
				VanillaCalls.SetChairLastSitTime(Time.time);
				__result = false;
				return false;
			}
			catch (Exception ex)
			{
				ClaimList.FailOpen(ex.GetType().Name + ": " + ex.Message);
				return true;
			}
		}

		[HarmonyPatch(typeof(Sadle), "RPC_RequestControl")]
		[HarmonyPrefix]
		private static void Sadle_RequestControl_Prefix(Sadle __instance)
		{
			ReleaseIfListedStale((Component)(object)__instance);
		}

		[HarmonyPatch(typeof(ShipControlls), "RPC_RequestControl")]
		[HarmonyPrefix]
		private static void ShipControlls_RequestControl_Prefix(ShipControlls __instance)
		{
			ReleaseIfListedStale((Component)(object)__instance);
		}

		[HarmonyPatch(typeof(Vagon), "Interact")]
		[HarmonyPrefix]
		private static void Vagon_Interact_Prefix(Vagon __instance)
		{
			if (!ClaimList.IsActive || (Object)(object)__instance == (Object)null)
			{
				return;
			}
			try
			{
				ZNetView val = ClaimList.FindView((Component)(object)__instance);
				if (!((Object)(object)val == (Object)null) && ClaimList.IsListed(val) && RamRelease.TryReleaseIfStale(val) && !val.IsOwner())
				{
					val.ClaimOwnership();
				}
			}
			catch (Exception ex)
			{
				ClaimList.FailOpen(ex.GetType().Name + ": " + ex.Message);
			}
		}

		[HarmonyPatch(typeof(Vagon), "RPC_RequestOwn")]
		[HarmonyPrefix]
		private static void Vagon_RequestOwn_Prefix(Vagon __instance)
		{
			if (!ClaimList.IsActive || (Object)(object)__instance == (Object)null)
			{
				return;
			}
			try
			{
				ZNetView val = ClaimList.FindView((Component)(object)__instance);
				if ((Object)(object)val == (Object)null || !ClaimList.IsListed(val))
				{
					return;
				}
				Player localPlayer = Player.m_localPlayer;
				bool flag = (Object)(object)localPlayer != (Object)null && ((Character)localPlayer).IsDead() && __instance.IsAttached((Character)(object)localPlayer);
				if (RamRelease.OwnerIsStale(val.GetZDO()) || flag)
				{
					try
					{
						VanillaCalls.DetachVagon(__instance);
					}
					catch
					{
					}
					RamRelease.ReleaseZdo(val.GetZDO());
					ClaimStats.NoteStaleInteract();
				}
			}
			catch (Exception ex)
			{
				ClaimList.FailOpen(ex.GetType().Name + ": " + ex.Message);
			}
		}

		[HarmonyPatch(typeof(ZNetView), "ClaimOwnership")]
		[HarmonyPrefix]
		private static void ZNetView_ClaimOwnership_Prefix(ZNetView __instance)
		{
			if (!ClaimList.IsActive || (Object)(object)__instance == (Object)null || !__instance.IsValid())
			{
				return;
			}
			try
			{
				if (ClaimList.IsListed(__instance))
				{
					RamRelease.TryReleaseIfStale(__instance);
				}
			}
			catch (Exception ex)
			{
				ClaimList.FailOpen(ex.GetType().Name + ": " + ex.Message);
			}
		}

		private static void ReleaseIfListedStale(Component component)
		{
			if (!ClaimList.IsActive || (Object)(object)component == (Object)null)
			{
				return;
			}
			try
			{
				ZNetView val = ClaimList.FindView(component);
				if (!((Object)(object)val == (Object)null) && ClaimList.IsListed(val))
				{
					RamRelease.TryReleaseIfStale(val);
				}
			}
			catch (Exception ex)
			{
				ClaimList.FailOpen(ex.GetType().Name + ": " + ex.Message);
			}
		}
	}
	internal static class PatchInit
	{
		internal static void ApplyAll(Harmony harmony)
		{
			SafeApply(harmony, "Player/ram/combat/projectile ZDO send partition", delegate(Harmony h)
			{
				h.PatchAll(typeof(SortPatches));
			});
			SafeApply(harmony, "Abandoned ram claim (death/DC/stale interact)", delegate(Harmony h)
			{
				h.PatchAll(typeof(ClaimPatches));
			});
			SafeApply(harmony, "Admin command (Terminal.InitTerminal)", delegate(Harmony h)
			{
				h.PatchAll(typeof(TerminalInitCommandPatch));
			});
		}

		private static void SafeApply(Harmony harmony, string label, Action<Harmony> apply)
		{
			try
			{
				apply(harmony);
				Log.Info("[Patch OK] " + label);
			}
			catch (Exception ex)
			{
				Log.Error("[Patch FAILED] " + label + ": " + ex.Message + "\nThis feature is inactive; the rest of Combat Priority keeps working. Fail-open.\n" + ex);
			}
		}
	}
	[HarmonyPatch]
	internal static class SortPatches
	{
		private static readonly List<ZDO>[] Buckets = new List<ZDO>[5]
		{
			new List<ZDO>(32),
			new List<ZDO>(16),
			new List<ZDO>(128),
			new List<ZDO>(64),
			new List<ZDO>(512)
		};

		private static readonly int[] Counts = new int[5];

		private static bool _latched;

		private static string _reason = "";

		internal static bool Latched => _latched;

		internal static string Reason => _reason ?? "";

		[HarmonyPatch(typeof(ZDOMan), "ServerSortSendZDOS")]
		[HarmonyPostfix]
		[HarmonyPriority(0)]
		[HarmonyAfter(new string[] { "com.Fire.FiresGhettoNetworkMod", "com.bfv.PlayerReplica", "com.bfv.SiegeFreeze" })]
		private static void ServerSortSendZDOS_Postfix(List<ZDO> objects)
		{
			Partition(objects, server: true);
		}

		[HarmonyPatch(typeof(ZDOMan), "ClientSortSendZDOS")]
		[HarmonyPostfix]
		[HarmonyPriority(0)]
		[HarmonyAfter(new string[] { "com.Fire.FiresGhettoNetworkMod", "com.bfv.PlayerReplica", "com.bfv.SiegeFreeze" })]
		private static void ClientSortSendZDOS_Postfix(List<ZDO> objects)
		{
			Partition(objects, server: false);
		}

		internal static void ClearLatch()
		{
			_latched = false;
			_reason = "";
		}

		private static void Partition(List<ZDO> objects, bool server)
		{
			if (_latched)
			{
				return;
			}
			CombatPrioConfig cfg = Plugin.Cfg;
			if (cfg == null || !cfg.Enabled.Value || objects == null)
			{
				return;
			}
			int count = objects.Count;
			if (count < 2)
			{
				return;
			}
			try
			{
				for (int i = 0; i < 5; i++)
				{
					Buckets[i].Clear();
					Counts[i] = 0;
				}
				bool flag = true;
				byte b = 0;
				for (int j = 0; j < count; j++)
				{
					ZDO val = objects[j];
					byte b2 = CombatClassifier.Of(val);
					if (b2 > 4)
					{
						b2 = 4;
					}
					if (b2 < b)
					{
						flag = false;
					}
					b = b2;
					Buckets[b2].Add(val);
					Counts[b2]++;
				}
				if (!flag)
				{
					int num = 0;
					for (int k = 0; k < 5; k++)
					{
						List<ZDO> list = Buckets[k];
						for (int l = 0; l < list.Count; l++)
						{
							objects[num++] = list[l];
						}
					}
				}
				PrioDiagnostics.Note(server, objects, count, Counts[0], Counts[1], Counts[2], Counts[3], Counts[4], !flag);
			}
			catch (Exception ex)
			{
				_latched = true;
				_reason = ex.GetType().Name + ": " + ex.Message;
				Log.Error("[CombatPrio FAIL-OPEN] Send reorder disabled after error. Vanilla ZDO order is left as-is. Ownership, ExtraData, Freeze, FGN, and Guilds were not written. `combatprio on` clears this latch. " + _reason);
			}
		}
	}
}
namespace BFVCombatPrio.Diagnostics
{
	internal static class PrioDiagnostics
	{
		internal const int HeadSize = 20;

		private const float DebugIntervalSeconds = 5f;

		private static long _sortPasses;

		private static long _serverPasses;

		private static long _clientPasses;

		private static long _changedPasses;

		private static long _sumPlayers;

		private static long _sumRams;

		private static long _sumCombat;

		private static long _sumProjectiles;

		private static long _sumRest;

		private static int _lastList;

		private static int _lastPlayers;

		private static int _lastRams;

		private static int _lastCombat;

		private static int _lastProjectiles;

		private static int _lastRest;

		private static int _lastChanged;

		private static int _lastHeadPlayer;

		private static int _lastServer;

		private static int _headCount;

		private static readonly byte[] HeadRanks = new byte[20];

		private static readonly int[] HeadPrefabs = new int[20];

		private static readonly ObjectType[] HeadTypes = (ObjectType[])(object)new ObjectType[20];

		private static readonly string[] HeadNames = new string[20];

		private static float _nextDebugLog;

		internal static void Note(bool server, List<ZDO> objects, int listCount, int players, int rams, int combat, int projectiles, int rest, bool changed)
		{
			Interlocked.Increment(ref _sortPasses);
			if (server)
			{
				Interlocked.Increment(ref _serverPasses);
			}
			else
			{
				Interlocked.Increment(ref _clientPasses);
			}
			if (changed)
			{
				Interlocked.Increment(ref _changedPasses);
			}
			Interlocked.Add(ref _sumPlayers, players);
			Interlocked.Add(ref _sumRams, rams);
			Interlocked.Add(ref _sumCombat, combat);
			Interlocked.Add(ref _sumProjectiles, projectiles);
			Interlocked.Add(ref _sumRest, rest);
			Interlocked.Exchange(ref _lastList, listCount);
			Interlocked.Exchange(ref _lastPlayers, players);
			Interlocked.Exchange(ref _lastRams, rams);
			Interlocked.Exchange(ref _lastCombat, combat);
			Interlocked.Exchange(ref _lastProjectiles, projectiles);
			Interlocked.Exchange(ref _lastRest, rest);
			Interlocked.Exchange(ref _lastChanged, changed ? 1 : 0);
			Interlocked.Exchange(ref _lastServer, server ? 1 : 0);
			CaptureHead(objects, listCount);
			if (Log.IsDebugEnabled && Time.unscaledTime >= _nextDebugLog)
			{
				_nextDebugLog = Time.unscaledTime + 5f;
				Log.Debug(LastPassLine());
			}
		}

		internal static void Reset()
		{
			Interlocked.Exchange(ref _sortPasses, 0L);
			Interlocked.Exchange(ref _serverPasses, 0L);
			Interlocked.Exchange(ref _clientPasses, 0L);
			Interlocked.Exchange(ref _changedPasses, 0L);
			Interlocked.Exchange(ref _sumPlayers, 0L);
			Interlocked.Exchange(ref _sumRams, 0L);
			Interlocked.Exchange(ref _sumCombat, 0L);
			Interlocked.Exchange(ref _sumProjectiles, 0L);
			Interlocked.Exchange(ref _sumRest, 0L);
			Interlocked.Exchange(ref _lastList, 0);
			Interlocked.Exchange(ref _lastPlayers, 0);
			Interlocked.Exchange(ref _lastRams, 0);
			Interlocked.Exchange(ref _lastCombat, 0);
			Interlocked.Exchange(ref _lastProjectiles, 0);
			Interlocked.Exchange(ref _lastRest, 0);
			Interlocked.Exchange(ref _lastChanged, 0);
			Interlocked.Exchange(ref _lastHeadPlayer, 0);
			Interlocked.Exchange(ref _lastServer, 0);
			_headCount = 0;
			_nextDebugLog = 0f;
		}

		internal static string Snapshot()
		{
			CombatPrioConfig cfg = Plugin.Cfg;
			string text = ((cfg != null && cfg.Enabled.Value) ? "ON" : "OFF");
			string text2 = (SortPatches.Latched ? ("FAIL-OPEN (" + SortPatches.Reason + ")") : "ok");
			string text3 = (((Object)(object)ZNet.instance != (Object)null && ZNet.instance.IsServer()) ? "server" : "client");
			string text4 = ClaimStats.Snapshot();
			return "[CombatPrio] " + text + "  role=" + text3 + "  latch=" + text2 + "  sorts=" + Interlocked.Read(in _sortPasses) + "  changed=" + Interlocked.Read(in _changedPasses) + "  server=" + Interlocked.Read(in _serverPasses) + "  client=" + Interlocked.Read(in _clientPasses) + "  sumP=" + Interlocked.Read(in _sumPlayers) + "  sumRam=" + Interlocked.Read(in _sumRams) + "  sumC=" + Interlocked.Read(in _sumCombat) + "  sumProj=" + Interlocked.Read(in _sumProjectiles) + "  sumR=" + Interlocked.Read(in _sumRest) + "  " + LastPassLine() + "  |  " + text4;
		}

		internal static void Print(string reason)
		{
			string message = Snapshot() + "  (" + reason + ")";
			Log.Info(message);
			PrioFeedback.TellLocal(message);
		}

		internal static void PrintDump()
		{
			Print("dump");
			string message = FormatHead();
			Log.Info(message);
			PrioFeedback.TellLocal(message);
		}

		private static string LastPassLine()
		{
			bool flag = Interlocked.CompareExchange(ref _lastHeadPlayer, 0, 0) != 0;
			bool flag2 = Interlocked.CompareExchange(ref _lastChanged, 0, 0) != 0;
			bool flag3 = Interlocked.CompareExchange(ref _lastServer, 0, 0) != 0;
			string text = ((_headCount > 0) ? HeadNames[0] : "-");
			return "lastList=" + Interlocked.CompareExchange(ref _lastList, 0, 0) + "  lastP=" + Interlocked.CompareExchange(ref _lastPlayers, 0, 0) + "  lastRam=" + Interlocked.CompareExchange(ref _lastRams, 0, 0) + "  lastC=" + Interlocked.CompareExchange(ref _lastCombat, 0, 0) + "  lastProj=" + Interlocked.CompareExchange(ref _lastProjectiles, 0, 0) + "  lastR=" + Interlocked.CompareExchange(ref _lastRest, 0, 0) + "  lastRewrote=" + (flag2 ? "yes" : "no") + "  lastPath=" + (flag3 ? "server" : "client") + "  headPlayer=" + (flag ? "yes" : "no") + "  first=" + text;
		}

		private static void CaptureHead(List<ZDO> objects, int listCount)
		{
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			if (objects == null)
			{
				_headCount = 0;
				Interlocked.Exchange(ref _lastHeadPlayer, 0);
				return;
			}
			int num = listCount;
			if (num > objects.Count)
			{
				num = objects.Count;
			}
			if (num > 20)
			{
				num = 20;
			}
			byte b = 4;
			for (int i = 0; i < num; i++)
			{
				ZDO val = objects[i];
				byte b2 = CombatClassifier.Of(val);
				int num2 = ((val != null) ? val.GetPrefab() : 0);
				HeadRanks[i] = b2;
				HeadPrefabs[i] = num2;
				HeadTypes[i] = (ObjectType)((val != null) ? ((int)val.Type) : 0);
				HeadNames[i] = CombatClassifier.PrefabLabel(num2);
				if (i == 0)
				{
					b = b2;
				}
			}
			_headCount = num;
			Interlocked.Exchange(ref _lastHeadPlayer, (b == 0) ? 1 : 0);
		}

		private static string FormatHead()
		{
			StringBuilder stringBuilder = new StringBuilder(512);
			stringBuilder.Append("[CombatPrio dump] head ").Append(_headCount).Append('/')
				.Append(20);
			stringBuilder.Append(" (send order: Player then Ram then Combat then Proj then Rest)");
			if (_headCount == 0)
			{
				stringBuilder.AppendLine().Append("  (no send list captured yet — be in a world with other players)");
				return stringBuilder.ToString();
			}
			for (int i = 0; i < _headCount; i++)
			{
				stringBuilder.AppendLine();
				stringBuilder.Append("  ").Append(i.ToString("00"));
				stringBuilder.Append("  ").Append(CombatClassifier.RankLabel(HeadRanks[i]).PadRight(6));
				stringBuilder.Append("  ").Append(((object)Unsafe.As<ObjectType, ObjectType>(ref HeadTypes[i])/*cast due to .constrained prefix*/).ToString().PadRight(12));
				stringBuilder.Append("  ").Append(HeadNames[i]);
			}
			return stringBuilder.ToString();
		}
	}
	internal static class PrioFeedback
	{
		internal static void TellLocal(string message)
		{
			if ((Object)(object)Console.instance != (Object)null)
			{
				((Terminal)Console.instance).AddString(message);
			}
			if ((Object)(object)Chat.instance != (Object)null)
			{
				((Terminal)Chat.instance).AddString(message);
			}
		}

		internal static bool IsLocalAdmin()
		{
			if ((Object)(object)ZNet.instance == (Object)null)
			{
				return false;
			}
			if (ZNet.instance.IsServer() && ZNet.instance.IsDedicated())
			{
				return true;
			}
			return ZNet.instance.LocalPlayerIsAdminOrHost();
		}
	}
}
namespace BFVCombatPrio.Config
{
	internal sealed class CombatPrioConfig
	{
		private const string LegacyContainsDefault = "gate,ram,catapult,ballista,trebuchet,powerstone";

		internal readonly ConfigEntry<bool> Enabled;

		internal readonly ConfigEntry<bool> LockConfiguration;

		internal readonly ConfigEntry<bool> DebugLogging;

		internal readonly ConfigEntry<string> CombatStructureExactNames;

		internal readonly ConfigEntry<string> CombatStructureNameContains;

		internal readonly ConfigEntry<bool> AbandonedClaimEnabled;

		internal readonly ConfigEntry<string> AbandonedClaimExactNames;

		internal CombatPrioConfig(ConfigFile file)
		{
			Enabled = file.Bind<bool>("1 - General", "Enabled", true, "Master on/off for Player → Ram → Combat → Projectile → Rest ZDO send order. Live — Harmony stays loaded. False leaves vanilla (and FGN) ZDO send order as-is. Does not change ExtraData, world saves, or which ZDOs are selected to send. Server-synced.");
			CombatPrioSync.Instance.AddConfigEntry<bool>(Enabled);
			LockConfiguration = file.Bind<bool>("1 - General", "Lock Configuration", true, "When enabled, only the server admin can change server-synced settings. Connected clients get the dedi values. Leave on.");
			CombatPrioSync.Instance.AddLockingConfigEntry<bool>(LockConfiguration);
			DebugLogging = file.Bind<bool>("1 - General", "Debug Logging", false, "When true, logs a throttled last-pass proof line every 5s (headPlayer, last ranks, first prefab) and claim release lines. Local, not server-synced. Leave false on live BFV; use `combatprio dump` instead.");
			CombatStructureExactNames = file.Bind<string>("2 - Combat send order", "Exact Names", "", "Comma-separated EXACT prefab names that stay in the combat send band (after players and listed rams, before projectiles). Use this for gates and other siege pieces — not battering rams. Empty = Character/Aoe/Ship/Turret/Trap plus ObjectType.Prioritized. Does not sleep, freeze, or take ownership. Server-synced.");
			CombatPrioSync.Instance.AddConfigEntry<string>(CombatStructureExactNames);
			CombatStructureNameContains = file.Bind<string>("2 - Combat send order", "Name Contains", "", "Comma-separated case-insensitive substrings. Prefab names containing one of these stay in the combat send band (after players/rams, before projectiles). Empty by default. Do not put ram here. Server-synced.");
			CombatPrioSync.Instance.AddConfigEntry<string>(CombatStructureNameContains);
			AbandonedClaimEnabled = file.Bind<bool>("3 - Abandoned ram claim", "Enable", false, "When true, listed battering rams drop ZDO owner + in-use fields the instant the driver dies or disconnects, so the next player can hop on during the death screen. Live drivers keep ownership (required for smooth movement). Leave false until Exact Names is filled. Send-order still uses Exact Names for the ram band even when this is false. Server-synced.");
			CombatPrioSync.Instance.AddConfigEntry<bool>(AbandonedClaimEnabled);
			AbandonedClaimExactNames = file.Bind<string>("3 - Abandoned ram claim", "Exact Names", "", "Comma-separated EXACT Wacky/prefab names of battering rams only. These always sit in the ram send band (immediately after Player, before combat/projectiles), even when claim Enable is false. Enable only controls death/DC unstick. Do not put gates, chests, or doors here. Empty = no ram-tier send and claim does nothing. Server-synced.");
			CombatPrioSync.Instance.AddConfigEntry<string>(AbandonedClaimExactNames);
			if (string.Equals(CombatStructureNameContains.Value, "gate,ram,catapult,ballista,trebuchet,powerstone", StringComparison.Ordinal))
			{
				CombatStructureNameContains.Value = "";
			}
			CombatStructureExactNames.SettingChanged += delegate
			{
				CombatClassifier.Rebuild();
			};
			CombatStructureNameContains.SettingChanged += delegate
			{
				CombatClassifier.Rebuild();
			};
			AbandonedClaimEnabled.SettingChanged += delegate
			{
				ClaimList.Rebuild();
			};
			AbandonedClaimExactNames.SettingChanged += delegate
			{
				ClaimList.Rebuild();
				CombatClassifier.Rebuild();
			};
		}
	}
	internal static class ConfigLiveReload
	{
		private const float DebounceSeconds = 1f;

		private static ConfigFile _config;

		private static MonoBehaviour _host;

		private static FileSystemWatcher _watcher;

		private static Coroutine _debounceRoutine;

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

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

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

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

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

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

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

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

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

		private static bool _registered;

		internal static void Register()
		{
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Expected O, but got Unknown
			if (_registered)
			{
				return;
			}
			try
			{
				object obj = <>O.<0>__Run;
				if (obj == null)
				{
					ConsoleEvent val = Run;
					<>O.<0>__Run = val;
					obj = (object)val;
				}
				new ConsoleCommand("combatprio", "BFV Combat Priority. Admin. on | off | stats | stats reset | dump | claim", (ConsoleEvent)obj, false, false, false, false, false, (ConsoleOptionsFetcher)null, false, false, false);
				_registered = true;
			}
			catch
			{
			}
		}

		private static void Run(ConsoleEventArgs args)
		{
			string text = ((args.Length >= 2) ? args[1] : "stats");
			if (text.Equals("help", StringComparison.OrdinalIgnoreCase))
			{
				PrioFeedback.TellLocal("Usage: combatprio on | off | stats | stats reset | dump | claim");
			}
			else if (text.Equals("claim", StringComparison.OrdinalIgnoreCase))
			{
				if (!PrioFeedback.IsLocalAdmin())
				{
					PrioFeedback.TellLocal("[CombatPrio] Admin only.");
					return;
				}
				if (((args.Length >= 3) ? args[2] : string.Empty).Equals("reset", StringComparison.OrdinalIgnoreCase))
				{
					ClaimList.ClearLatch();
					ClaimStats.Reset();
				}
				string message = ClaimStats.Snapshot();
				Log.Info(message);
				PrioFeedback.TellLocal(message);
			}
			else if (text.Equals("dump", StringComparison.OrdinalIgnoreCase))
			{
				if (!PrioFeedback.IsLocalAdmin())
				{
					PrioFeedback.TellLocal("[CombatPrio] Admin only.");
				}
				else
				{
					PrioDiagnostics.PrintDump();
				}
			}
			else if (text.Equals("stats", StringComparison.OrdinalIgnoreCase))
			{
				if (((args.Length >= 3) ? args[2] : string.Empty).Equals("reset", StringComparison.OrdinalIgnoreCase))
				{
					PrioDiagnostics.Reset();
					PrioDiagnostics.Print("manual reset");
				}
				else
				{
					PrioDiagnostics.Print("manual stats");
				}
			}
			else if (text.Equals("on", StringComparison.OrdinalIgnoreCase))
			{
				SetEnabled(on: true);
			}
			else if (text.Equals("off", StringComparison.OrdinalIgnoreCase))
			{
				SetEnabled(on: false);
			}
			else
			{
				PrioFeedback.TellLocal("Usage: combatprio on | off | stats | stats reset | dump | claim");
			}
		}

		private static void SetEnabled(bool on)
		{
			if (!PrioFeedback.IsLocalAdmin())
			{
				PrioFeedback.TellLocal("[CombatPrio] Admin only.");
				return;
			}
			if (Plugin.Cfg == null)
			{
				PrioFeedback.TellLocal("[CombatPrio] Config not loaded.");
				return;
			}
			if (on)
			{
				SortPatches.ClearLatch();
				ClaimList.ClearLatch();
			}
			Plugin.Cfg.Enabled.Value = on;
			CombatClassifier.Rebuild();
			ClaimList.Rebuild();
			string message = (on ? "[CombatPrio] ON. Send order is Player then listed rams then combat then projectiles then buildings/terrain. Pieces are delayed, not dropped. Claim latch cleared (unstick still needs Enable + ram names)." : "[CombatPrio] OFF. Vanilla (and FGN, if it sorts) ZDO order is left as-is. Abandoned ram claim is unchanged.");
			PrioFeedback.TellLocal(message);
			Log.Info(message);
		}
	}
	[HarmonyPatch(typeof(Terminal), "InitTerminal")]
	internal static class TerminalInitCommandPatch
	{
		private static void Postfix()
		{
			CombatPrioCommands.Register();
		}
	}
}
namespace BFVCombatPrio.Claim
{
	internal static class ClaimList
	{
		private static HashSet<int> _exact = new HashSet<int>();

		private static int _nameCount;

		private static bool _latched;

		private static string _reason = "";

		internal static bool Latched => _latched;

		internal static string Reason => _reason ?? "";

		internal static int NameCount => _nameCount;

		internal static bool IsActive
		{
			get
			{
				if (_latched)
				{
					return false;
				}
				CombatPrioConfig cfg = Plugin.Cfg;
				if (cfg == null || !cfg.AbandonedClaimEnabled.Value)
				{
					return false;
				}
				return _nameCount > 0;
			}
		}

		internal static void Init()
		{
			Rebuild();
		}

		internal static void Rebuild()
		{
			HashSet<int> hashSet = new HashSet<int>();
			int names = 0;
			CombatPrioConfig cfg = Plugin.Cfg;
			if (cfg != null)
			{
				SplitAddExact(cfg.AbandonedClaimExactNames.Value, hashSet, ref names);
			}
			_exact = hashSet;
			_nameCount = names;
			_latched = false;
			_reason = "";
		}

		internal static void FailOpen(string reason)
		{
			if (!_latched)
			{
				_latched = true;
				_reason = reason ?? "";
				Log.Error("[CombatPrio CLAIM FAIL-OPEN] Abandoned ram claim disabled after error. Send-order is unchanged. Ownership was not written after this fault. " + _reason);
			}
		}

		internal static void ClearLatch()
		{
			_latched = false;
			_reason = "";
		}

		internal static bool IsListed(ZDO zdo)
		{
			if (zdo == null || _nameCount == 0)
			{
				return false;
			}
			return _exact.Contains(zdo.GetPrefab());
		}

		internal static bool IsListed(ZNetView nview)
		{
			if ((Object)(object)nview == (Object)null || !nview.IsValid())
			{
				return false;
			}
			return IsListed(nview.GetZDO());
		}

		internal static bool IsListed(Component component)
		{
			if ((Object)(object)component == (Object)null)
			{
				return false;
			}
			ZNetView val = component.GetComponent<ZNetView>();
			if ((Object)(object)val == (Object)null)
			{
				val = component.GetComponentInParent<ZNetView>();
			}
			return IsListed(val);
		}

		internal static ZNetView FindView(Component component)
		{
			if ((Object)(object)component == (Object)null)
			{
				return null;
			}
			ZNetView component2 = component.GetComponent<ZNetView>();
			if ((Object)(object)component2 != (Object)null)
			{
				return component2;
			}
			return component.GetComponentInParent<ZNetView>();
		}

		private static void SplitAddExact(string raw, HashSet<int> into, ref int names)
		{
			if (string.IsNullOrWhiteSpace(raw))
			{
				return;
			}
			string[] array = raw.Split(new char[3] { ',', ';', '\n' }, StringSplitOptions.RemoveEmptyEntries);
			for (int i = 0; i < array.Length; i++)
			{
				string text = array[i].Trim();
				if (text.Length != 0)
				{
					into.Add(StringExtensionMethods.GetStableHashCode(text));
					names++;
				}
			}
		}
	}
	internal static class ClaimStats
	{
		private static long _releases;

		private static long _staleInteract;

		private static int _lastReleased;

		private static string _lastReason = "-";

		internal static void NoteRelease(int count, string reason)
		{
			if (count > 0)
			{
				Interlocked.Add(ref _releases, count);
				Interlocked.Exchange(ref _lastReleased, count);
				_lastReason = reason ?? "-";
			}
		}

		internal static void NoteStaleInteract()
		{
			Interlocked.Increment(ref _staleInteract);
		}

		internal static void Reset()
		{
			Interlocked.Exchange(ref _releases, 0L);
			Interlocked.Exchange(ref _staleInteract, 0L);
			Interlocked.Exchange(ref _lastReleased, 0);
			_lastReason = "-";
		}

		internal static string Snapshot()
		{
			CombatPrioConfig cfg = Plugin.Cfg;
			string text = (ClaimList.IsActive ? "ON" : "OFF");
			string text2 = (ClaimList.Latched ? ("FAIL-OPEN (" + ClaimList.Reason + ")") : "ok");
			string.IsNullOrWhiteSpace((cfg != null) ? cfg.AbandonedClaimExactNames.Value : "");
			return "[CombatPrio claim] " + text + "  latch=" + text2 + "  names=" + ClaimList.NameCount + "  releases=" + Interlocked.Read(in _releases) + "  staleInteract=" + Interlocked.Read(in _staleInteract) + "  lastReleased=" + Interlocked.CompareExchange(ref _lastReleased, 0, 0) + "  last=" + _lastReason;
		}
	}
	internal static class RamRelease
	{
		internal const float OccupyingDistance = 12f;

		private const int SectorArea = 1;

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

		internal static void OnPlayerAbandoned(Player player, string reason)
		{
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			if (!ClaimList.IsActive || (Object)(object)player == (Object)null)
			{
				return;
			}
			ZNetView view = VanillaCalls.GetView((Component)(object)player);
			ZDO val = (((Object)(object)view != (Object)null && view.IsValid()) ? view.GetZDO() : null);
			long ownerUid = ((val != null) ? val.GetOwner() : 0);
			long playerID = player.GetPlayerID();
			long userId = 0L;
			if (val != null)
			{
				userId = ((ZDOID)(ref val.m_uid)).UserID;
			}
			try
			{
				if (((Character)player).IsAttached())
				{
					((Character)player).AttachStop();
				}
			}
			catch
			{
			}
			ReleaseNear(((Component)player).transform.position, ownerUid, playerID, userId, reason);
		}

		internal static void OnPeerDisconnected(ZNetPeer peer)
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			if (ClaimList.IsActive && peer != null)
			{
				long uid = peer.m_uid;
				long userID = ((ZDOID)(ref peer.m_characterID)).UserID;
				ReleaseNear(peer.GetRefPos(), uid, 0L, userID, "disconnect");
			}
		}

		internal static int ReleaseNear(Vector3 pos, long ownerUid, long playerId, long userId, string reason)
		{
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			if (!ClaimList.IsActive)
			{
				return 0;
			}
			if (ownerUid == 0L && playerId == 0L && userId == 0L)
			{
				return 0;
			}
			if (ZDOMan.instance == null || (Object)(object)ZoneSystem.instance == (Object)null)
			{
				return 0;
			}
			Scratch.Clear();
			Vector2i zone = ZoneSystem.GetZone(pos);
			ZDOMan.instance.FindSectorObjects(zone, 1, 0, Scratch, (List<ZDO>)null);
			int num = 0;
			for (int i = 0; i < Scratch.Count; i++)
			{
				ZDO val = Scratch[i];
				if (ClaimList.IsListed(val) && MatchesIds(val, ownerUid, playerId, userId) && ReleaseZdo(val))
				{
					num++;
				}
			}
			Scratch.Clear();
			if (num > 0)
			{
				ClaimStats.NoteRelease(num, reason);
				Log.Debug("[CombatPrio claim] released " + num + " ram(s) (" + reason + ")");
			}
			return num;
		}

		internal static bool ReleaseZdo(ZDO zdo)
		{
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			if (zdo == null)
			{
				return false;
			}
			DetachLive(zdo);
			bool num = zdo.HasOwner();
			long num2 = zdo.GetLong(ZDOVars.s_user, 0L);
			bool flag = zdo.GetBool(ZDOVars.s_inUse, false);
			bool flag2 = zdo.GetBool(ZDOVars.s_attachJointHash, false);
			zdo.Set(ZDOVars.s_user, 0L);
			zdo.Set(ZDOVars.s_inUse, false);
			zdo.Set(ZDOVars.s_attachJointHash, false);
			zdo.Set(ZDOVars.s_zdoidUser, ZDOID.None);
			if (num)
			{
				zdo.SetOwner(0L);
			}
			return num || num2 != 0 || flag || flag2;
		}

		internal static bool OwnerIsStale(ZDO zdo)
		{
			if (zdo == null || !ClaimList.IsListed(zdo))
			{
				return false;
			}
			long num = zdo.GetLong(ZDOVars.s_user, 0L);
			if (!zdo.HasOwner() && num == 0L)
			{
				return false;
			}
			if (HasLivingOccupant(zdo))
			{
				return false;
			}
			return true;
		}

		internal static bool TryReleaseIfStale(ZDO zdo)
		{
			if (!ClaimList.IsActive || zdo == null)
			{
				return false;
			}
			if (!OwnerIsStale(zdo))
			{
				return false;
			}
			if (ReleaseZdo(zdo))
			{
				ClaimStats.NoteStaleInteract();
				ClaimStats.NoteRelease(1, "stale-interact");
				return true;
			}
			return false;
		}

		internal static bool TryReleaseIfStale(ZNetView nview)
		{
			if ((Object)(object)nview == (Object)null || !nview.IsValid())
			{
				return false;
			}
			return TryReleaseIfStale(nview.GetZDO());
		}

		private static bool HasLivingOccupant(ZDO ram)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			List<Player> allPlayers = Player.GetAllPlayers();
			if (allPlayers == null)
			{
				return false;
			}
			Vector3 position = ram.GetPosition();
			long owner = ram.GetOwner();
			long user = ram.GetLong(ZDOVars.s_user, 0L);
			for (int i = 0; i < allPlayers.Count; i++)
			{
				Player val = allPlayers[i];
				if (!((Object)(object)val == (Object)null) && !((Character)val).IsDead() && PlayerMatchesRam(val, owner, user))
				{
					float num = Vector3.Distance(((Component)val).transform.position, position);
					if (((Character)val).IsAttached())
					{
						return true;
					}
					if (num <= 12f)
					{
						return true;
					}
				}
			}
			return false;
		}

		private static bool PlayerMatchesRam(Player player, long owner, long user)
		{
			ZNetView view = VanillaCalls.GetView((Component)(object)player);
			ZDO val = (((Object)(object)view != (Object)null && view.IsValid()) ? view.GetZDO() : null);
			long num = ((val != null) ? val.GetOwner() : 0);
			long playerID = player.GetPlayerID();
			long num2 = ((val != null) ? ((ZDOID)(ref val.m_uid)).UserID : 0);
			if (owner != 0L && (num == owner || playerID == owner || num2 == owner))
			{
				return true;
			}
			if (user != 0L && (num == user || playerID == user || num2 == user))
			{
				return true;
			}
			return false;
		}

		private static bool MatchesIds(ZDO ram, long ownerUid, long playerId, long userId)
		{
			long owner = ram.GetOwner();
			long value = ram.GetLong(ZDOVars.s_user, 0L);
			if (!IdHit(owner, ownerUid, playerId, userId))