using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.IO.Compression;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Serialization;
using System.Runtime.Versioning;
using System.Text;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using JetBrains.Annotations;
using Microsoft.CodeAnalysis;
using ServerSync;
using TMPro;
using UnityEngine;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: AssemblyCompany("isimp")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyCopyright("Copyright (c) 2026 isimp")]
[assembly: AssemblyDescription("Holds a character far ahead of the group in fight skills near the rest, without touching saved levels.")]
[assembly: AssemblyFileVersion("0.2.0.0")]
[assembly: AssemblyInformationalVersion("0.2.0+27765f54c8db42a666ac57617b80fdd69f63012f")]
[assembly: AssemblyProduct("Kinsmen")]
[assembly: AssemblyTitle("Kinsmen")]
[assembly: InternalsVisibleTo("Kinsmen.SelfTest")]
[assembly: AssemblyVersion("0.2.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
{
	[PublicAPI]
	public abstract class OwnConfigEntryBase
	{
		public object? LocalBaseValue;

		public bool SynchronizedConfig = true;

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

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

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

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

		public readonly string Identifier;

		public readonly Type Type;

		private object? boxedValue;

		protected bool localIsOwner;

		public readonly int Priority;

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

		public event Action? ValueChanged;

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

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

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

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

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

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

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

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

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

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

				public volatile int versionMatchQueued = -1;

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

				public readonly ISocket Original;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

		private class PackageEntry
		{
			public string section;

			public string key;

			public Type type;

			public object? value;
		}

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

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

		private class InvalidDeserializationTypeException : Exception
		{
			public string expected;

			public string received;

			public string field = "";
		}

		public static bool ProcessingServerUpdate;

		public readonly string Name;

		public string? DisplayName;

		public string? CurrentVersion;

		public string? MinimumRequiredVersion;

		public bool ModRequired;

		private bool? forceConfigLocking;

		private bool isSourceOfTruth = true;

		private static readonly HashSet<ConfigSync> configSyncs;

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

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

		private static bool isServer;

		private static bool lockExempt;

		private OwnConfigEntryBase? lockedConfig;

		private const byte PARTIAL_CONFIGS = 1;

		private const byte FRAGMENTED_CONFIG = 2;

		private const byte COMPRESSED_CONFIG = 4;

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

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

		private static long packageCounter;

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

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

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

		public bool InitialSyncDone { get; private set; }

		public event Action<bool>? SourceOfTruthChanged;

		private event Action? lockedConfigChanged;

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

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

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

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

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

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

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

		private bool HandleConfigSyncRPC(long sender, ZPackage package, bool clientUpdate)
		{
			//IL_0209: Unknown result type (might be due to invalid IL or missing references)
			//IL_0210: Expected O, but got Unknown
			//IL_01b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bf: Expected O, but got Unknown
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Expected O, but got Unknown
			try
			{
				if (isServer && IsLocked)
				{
					ZRpc? currentRpc = SnatchCurrentlyHandlingRPC.currentRpc;
					object obj;
					if (currentRpc == null)
					{
						obj = null;
					}
					else
					{
						ISocket socket = currentRpc.GetSocket();
						obj = ((socket != null) ? socket.GetHostName() : null);
					}
					string text = (string)obj;
					if (text != null)
					{
						MethodInfo methodInfo = AccessTools.DeclaredMethod(typeof(ZNet), "ListContainsId", (Type[])null, (Type[])null);
						SyncedList val = (SyncedList)AccessTools.DeclaredField(typeof(ZNet), "m_adminList").GetValue(ZNet.instance);
						if (!(((object)methodInfo == null) ? val.Contains(text) : ((bool)methodInfo.Invoke(ZNet.instance, new object[2] { val, text }))))
						{
							return false;
						}
					}
				}
				cacheExpirations.RemoveAll(delegate(KeyValuePair<long, string> kv)
				{
					if (kv.Key < DateTimeOffset.Now.Ticks)
					{
						configValueCache.Remove(kv.Value);
						return true;
					}
					return false;
				});
				byte b = package.ReadByte();
				if ((b & 2) != 0)
				{
					long num = package.ReadLong();
					string text2 = sender.ToString() + num;
					if (!configValueCache.TryGetValue(text2, out 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 != 0L)
			{
				list = list.Where((ZNetPeer p) => p.m_uid == target).ToList();
			}
			return sendZPackage(list, package);
		}

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

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

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

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

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

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

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

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

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

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

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

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

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

		private static readonly Dictionary<string, string> notProcessedNames;

		public string Name;

		private string? displayName;

		private string? currentVersion;

		private string? minimumRequiredVersion;

		public bool ModRequired = true;

		private string? ReceivedCurrentVersion;

		private string? ReceivedMinimumRequiredVersion;

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

		private ConfigSync? ConfigSync;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

		[HarmonyPatch(typeof(FejdStartup), "ShowConnectError")]
		[HarmonyPostfix]
		private static void ShowConnectionError(FejdStartup __instance)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Invalid comparison between Unknown and I4
			//IL_014e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0153: Unknown result type (might be due to invalid IL or missing references)
			//IL_0161: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01be: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01de: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ee: Unknown result type (might be due to invalid IL or missing references)
			if (!__instance.m_connectionFailedPanel.activeSelf || (int)ZNet.GetConnectionStatus() != 3)
			{
				return;
			}
			bool flag = false;
			VersionCheck[] failedClient = GetFailedClient();
			if (failedClient.Length != 0)
			{
				string text = string.Join("\n", failedClient.Select((VersionCheck check) => check.Error()));
				TMP_Text connectionFailedError = __instance.m_connectionFailedError;
				connectionFailedError.text = connectionFailedError.text + "\n" + text;
				flag = true;
			}
			foreach (KeyValuePair<string, string> item in notProcessedNames.OrderBy((KeyValuePair<string, string> 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 Kinsmen
{
	internal static class Bronze
	{
		private static readonly float[] Dark = new float[3] { 36f, 25f, 11f };

		private static readonly float[] Middle = new float[3] { 200f, 140f, 60f };

		private static readonly float[] Light = new float[3] { 250f, 175f, 75f };

		private const float Lift = 1.6f;

		public static void Recolour(byte[] pixels)
		{
			for (int i = 0; i + 3 < pixels.Length; i += 4)
			{
				float val = (0.299f * (float)(int)pixels[i] + 0.587f * (float)(int)pixels[i + 1] + 0.114f * (float)(int)pixels[i + 2]) * 1.6f;
				float num = Math.Min(255f, val) / 255f;
				for (int j = 0; j < 3; j++)
				{
					float num2 = ((num < 0.5f) ? (Dark[j] + (Middle[j] - Dark[j]) * (num / 0.5f)) : (Middle[j] + (Light[j] - Middle[j]) * ((num - 0.5f) / 0.5f)));
					pixels[i + j] = (byte)Math.Round(num2);
				}
			}
		}
	}
	[HarmonyPatch(typeof(SEMan), "ModifySkillLevel")]
	internal static class CapHook
	{
		private static readonly FieldRef<SEMan, Character> CharacterOf = AccessTools.FieldRefAccess<SEMan, Character>("m_character");

		private static void Prefix(SEMan __instance, SkillType skill, ref float level)
		{
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Expected I4, but got Unknown
			try
			{
				CountingTable table = RecordClient.Table;
				if (!table.Holds)
				{
					return;
				}
				Player localPlayer = Player.m_localPlayer;
				if (!((Object)(object)localPlayer == (Object)null) && !((Object)(object)CharacterOf.Invoke(__instance) != (Object)(object)localPlayer))
				{
					float num = table.Lower((int)skill, level);
					if (num < level)
					{
						level = num;
					}
				}
			}
			catch (Exception failure)
			{
				Plugin.WarnOnce("lowering a skill", failure);
			}
		}
	}
	internal sealed class CountingTable
	{
		public static readonly CountingTable None = new CountingTable();

		private readonly Dictionary<int, Standing[]> _steps = new Dictionary<int, Standing[]>();

		private readonly Dictionary<int, float> _fixed = new Dictionary<int, float>();

		private readonly LadderSettings _settings;

		private readonly bool _exempt;

		public bool Holds
		{
			get
			{
				if (!_exempt)
				{
					if (_steps.Count <= 0)
					{
						return _fixed.Count > 0;
					}
					return true;
				}
				return false;
			}
		}

		public bool Exempt => _exempt;

		public IEnumerable<int> Capped => _steps.Keys.Concat(_fixed.Keys).Distinct();

		private CountingTable()
		{
		}

		public CountingTable(Record record, long self, ISet<int> held, LadderSettings settings, IDictionary<int, float> fixedCaps = null, bool exempt = false)
		{
			_settings = settings;
			_exempt = exempt;
			if (fixedCaps != null)
			{
				foreach (KeyValuePair<int, float> fixedCap in fixedCaps)
				{
					_fixed[fixedCap.Key] = fixedCap.Value;
				}
			}
			foreach (int item in held)
			{
				if (!_fixed.ContainsKey(item))
				{
					_steps[item] = (from s in record.Others(item, self)
						orderby s.Level
						select s).ThenByDescending<Standing, string>((Standing s) => s.Name, StringComparer.Ordinal).ToArray();
				}
			}
		}

		public float Lower(int skill, float level)
		{
			if (_exempt)
			{
				return level;
			}
			if (_fixed.TryGetValue(skill, out var value))
			{
				return Ladder.Lower(level, value, _settings.Rate);
			}
			Standing standing = BestBelowGap(skill, level);
			if (standing != null)
			{
				return Ladder.Lower(level, Ladder.Limit(standing.Level, _settings.Gap, _settings.Minimum), _settings.Rate);
			}
			return level;
		}

		public Ceiling Why(int skill, float level)
		{
			if (_exempt)
			{
				return null;
			}
			if (_fixed.TryGetValue(skill, out var value))
			{
				if (!(level > value))
				{
					return null;
				}
				return new Ceiling(value, null, 0f);
			}
			Standing standing = BestBelowGap(skill, level);
			if (standing == null)
			{
				return null;
			}
			float num = Ladder.Limit(standing.Level, _settings.Gap, _settings.Minimum);
			if (level <= num)
			{
				return null;
			}
			if (!Ladder.ByMinimum(standing.Level, _settings.Gap, _settings.Minimum))
			{
				return new Ceiling(num, standing.Name, standing.Level);
			}
			return new Ceiling(num, null, 0f);
		}

		public Cap Cap(int skill, float level)
		{
			if (_fixed.TryGetValue(skill, out var value))
			{
				return new Cap(value, null, 0f, setByHand: true);
			}
			if (!_steps.TryGetValue(skill, out Standing[] value2))
			{
				return null;
			}
			Standing standing = new Standing(long.MinValue, null, level);
			Standing standing2 = Ladder.GroupBest(value2.Concat(new Standing[1] { standing }), _settings.Gap);
			return new Cap(Ladder.Limit(standing2.Level, _settings.Gap, _settings.Minimum), standing2.Name, standing2.Level, setByHand: false, Ladder.ByMinimum(standing2.Level, _settings.Gap, _settings.Minimum));
		}

		private Standing BestBelowGap(int skill, float level)
		{
			if (!_steps.TryGetValue(skill, out Standing[] value))
			{
				return null;
			}
			float gap = _settings.Gap;
			bool flag = false;
			float? num = null;
			Standing result = null;
			Standing[] array = value;
			foreach (Standing standing in array)
			{
				if (!flag && level <= standing.Level)
				{
					flag = true;
					if (level < standing.Level)
					{
						if (num.HasValue && level - num.Value > gap)
						{
							return result;
						}
						num = level;
						result = null;
					}
				}
				if (num.HasValue && standing.Level - num.Value > gap)
				{
					if (!(level >= standing.Level))
					{
						return null;
					}
					return result;
				}
				num = standing.Level;
				result = standing;
			}
			if (!flag && num.HasValue && level - num.Value > gap)
			{
				return result;
			}
			return null;
		}
	}
	internal sealed class Exemptions
	{
		private readonly HashSet<string> _names = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

		private readonly HashSet<long> _ids = new HashSet<long>();

		private Exemptions()
		{
		}

		public static Exemptions Parse(string text)
		{
			Exemptions exemptions = new Exemptions();
			string[] array = (text ?? "").Split(new char[1] { ',' });
			for (int i = 0; i < array.Length; i++)
			{
				string text2 = array[i].Trim();
				if (text2.Length != 0)
				{
					if (long.TryParse(text2, NumberStyles.Integer, CultureInfo.InvariantCulture, out var result))
					{
						exemptions._ids.Add(result);
					}
					else
					{
						exemptions._names.Add(text2);
					}
				}
			}
			return exemptions;
		}

		public bool Covers(long id, string name)
		{
			if (!_ids.Contains(id))
			{
				if (name != null)
				{
					return _names.Contains(name.Trim());
				}
				return false;
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(SEMan), "GetHUDStatusEffects")]
	internal static class HeldEffect
	{
		private const float CountEvery = 1f;

		private static readonly FieldRef<SEMan, Character> CharacterOf = AccessTools.FieldRefAccess<SEMan, Character>("m_character");

		private static KinsmenIcon _icon;

		private static int _held;

		private static float _nextCount;

		public static void Refresh()
		{
			_nextCount = 0f;
		}

		private static void Postfix(SEMan __instance, List<StatusEffect> effects)
		{
			try
			{
				if (!Plugin.ShowEffectIcon)
				{
					return;
				}
				Player localPlayer = Player.m_localPlayer;
				if ((Object)(object)localPlayer == (Object)null || (Object)(object)CharacterOf.Invoke(__instance) != (Object)(object)localPlayer)
				{
					return;
				}
				if (Time.unscaledTime >= _nextCount)
				{
					_nextCount = Time.unscaledTime + 1f;
					_held = RecordClient.HeldCount();
				}
				if (_held > 0)
				{
					KinsmenIcon kinsmenIcon = Icon(localPlayer);
					if (!((Object)(object)kinsmenIcon == (Object)null))
					{
						kinsmenIcon.Held = _held;
						effects.Add((StatusEffect)(object)kinsmenIcon);
					}
				}
			}
			catch (Exception failure)
			{
				Plugin.WarnOnce("showing the effect icon", failure);
			}
		}

		internal static KinsmenIcon IconFor(Player player)
		{
			return Icon(player);
		}

		private static KinsmenIcon Icon(Player player)
		{
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Invalid comparison between Unknown and I4
			if ((Object)(object)_icon != (Object)null)
			{
				return _icon;
			}
			Sprite val = KnotIcon.Make();
			if ((Object)(object)val == (Object)null)
			{
				foreach (SkillDef skill in ((Character)player).GetSkills().m_skills)
				{
					if ((int)skill.m_skill == 6)
					{
						val = skill.m_icon;
					}
				}
			}
			if ((Object)(object)val == (Object)null)
			{
				return null;
			}
			_icon = ScriptableObject.CreateInstance<KinsmenIcon>();
			((Object)_icon).name = "Kinsmen";
			((StatusEffect)_icon).m_name = "Kinsmen";
			((StatusEffect)_icon).m_icon = val;
			return _icon;
		}
	}
	internal static class KnotIcon
	{
		private static Sprite _made;

		public static Sprite Make()
		{
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Expected O, but got Unknown
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fe: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_made != (Object)null)
			{
				return _made;
			}
			ObjectDB obj = ObjectDB.instance.OrNull<ObjectDB>();
			StatusEffect val = ((obj != null) ? obj.GetStatusEffect(SEMan.s_statusEffectRested) : null);
			Sprite val2 = (((Object)(object)val != (Object)null) ? val.m_icon : null);
			if ((Object)(object)val2 == (Object)null || (Object)(object)val2.texture == (Object)null)
			{
				return null;
			}
			RenderTexture val3 = null;
			RenderTexture active = RenderTexture.active;
			try
			{
				Rect val4 = (val2.packed ? val2.textureRect : val2.rect);
				Texture2D texture = val2.texture;
				val3 = RenderTexture.GetTemporary(((Texture)texture).width, ((Texture)texture).height, 0, (RenderTextureFormat)0, (RenderTextureReadWrite)2);
				Graphics.Blit((Texture)(object)texture, val3);
				RenderTexture.active = val3;
				int num = Mathf.RoundToInt(((Rect)(ref val4)).width);
				int num2 = Mathf.RoundToInt(((Rect)(ref val4)).height);
				Texture2D val5 = new Texture2D(num, num2, (TextureFormat)4, false)
				{
					name = "Kinsmen knot"
				};
				val5.ReadPixels(new Rect(((Rect)(ref val4)).x, ((Rect)(ref val4)).y, (float)num, (float)num2), 0, 0);
				Color32[] pixels = val5.GetPixels32();
				byte[] array = new byte[pixels.Length * 4];
				for (int i = 0; i < pixels.Length; i++)
				{
					array[i * 4] = pixels[i].r;
					array[i * 4 + 1] = pixels[i].g;
					array[i * 4 + 2] = pixels[i].b;
					array[i * 4 + 3] = pixels[i].a;
				}
				Bronze.Recolour(array);
				for (int j = 0; j < pixels.Length; j++)
				{
					pixels[j] = new Color32(array[j * 4], array[j * 4 + 1], array[j * 4 + 2], array[j * 4 + 3]);
				}
				val5.SetPixels32(pixels);
				val5.Apply(false, false);
				_made = Sprite.Create(val5, new Rect(0f, 0f, (float)num, (float)num2), new Vector2(0.5f, 0.5f), val2.pixelsPerUnit);
				((Object)_made).name = "Kinsmen knot";
				return _made;
			}
			catch (Exception failure)
			{
				Plugin.WarnOnce("making the bronze knot from the game's Rested icon, the Blocking icon stands in", failure);
				return null;
			}
			finally
			{
				RenderTexture.active = active;
				if ((Object)(object)val3 != (Object)null)
				{
					RenderTexture.ReleaseTemporary(val3);
				}
			}
		}
	}
	internal sealed class KinsmenIcon : StatusEffect
	{
		public int Held { get; set; }

		public override string GetIconText()
		{
			return Words.HeldIcon(Held);
		}
	}
	public static class KinsmenApi
	{
		public const int Version = 1;

		public static bool TryCounted(int skill, float savedLevel, out float counted, out string why)
		{
			counted = savedLevel;
			why = null;
			CountingTable table = RecordClient.Table;
			Ceiling ceiling = table.Why(skill, savedLevel);
			if (ceiling == null)
			{
				return false;
			}
			counted = table.Lower(skill, savedLevel);
			why = Words.Tooltip(RecordClient.Name((SkillType)skill), RecordClient.Whole(counted), ceiling.Holder, RecordClient.Whole(ceiling.HolderLevel), RecordClient.Whole(ceiling.Limit), Plugin.Settings.Rate);
			return true;
		}

		public static bool TryHolder(int skill, float savedLevel, out float counted, out string holder, out float holderLevel)
		{
			counted = savedLevel;
			holder = null;
			holderLevel = 0f;
			CountingTable table = RecordClient.Table;
			Ceiling ceiling = table.Why(skill, savedLevel);
			if (ceiling == null)
			{
				return false;
			}
			counted = table.Lower(skill, savedLevel);
			holder = ceiling.Holder;
			holderLevel = ((ceiling.Holder == null) ? ceiling.Limit : ceiling.HolderLevel);
			return true;
		}
	}
	internal sealed class Standing
	{
		public long Id { get; }

		public string Name { get; }

		public float Level { get; }

		public Standing(long id, string name, float level)
		{
			Id = id;
			Name = name;
			Level = level;
		}
	}
	internal sealed class Ceiling
	{
		public float Limit { get; }

		public string Holder { get; }

		public float HolderLevel { get; }

		public Ceiling(float limit, string holder, float holderLevel)
		{
			Limit = limit;
			Holder = holder;
			HolderLevel = holderLevel;
		}
	}
	internal sealed class LadderSettings
	{
		public float Gap { get; }

		public float Rate { get; }

		public float Minimum { get; }

		public LadderSettings(float gap, float rate, float minimum = 0f)
		{
			Gap = gap;
			Rate = rate;
			Minimum = minimum;
		}
	}
	internal static class Ladder
	{
		public static float Lower(float level, float? limit, float rate)
		{
			if (!limit.HasValue || level <= limit.Value)
			{
				return level;
			}
			float num = Math.Min(1f, Math.Max(0f, rate));
			return limit.Value + (level - limit.Value) * num;
		}

		public static float Lower(float level, Ceiling ceiling, float rate)
		{
			return Lower(level, ceiling?.Limit, rate);
		}

		public static float Limit(float best, float gap, float minimum)
		{
			return Math.Max(best + gap, minimum);
		}

		public static bool ByMinimum(float best, float gap, float minimum)
		{
			return minimum > best + gap;
		}

		public static Ceiling CeilingFor(IEnumerable<Standing> others, float level, float gap, float minimum)
		{
			Standing standing = new Standing(long.MinValue, null, level);
			(float, Standing)? tuple = Split(others.Concat(new Standing[1] { standing }), gap);
			if (!tuple.HasValue || standing.Level < tuple.Value.Item1)
			{
				return null;
			}
			Standing item = tuple.Value.Item2;
			float limit = Limit(item.Level, gap, minimum);
			if (!ByMinimum(item.Level, gap, minimum))
			{
				return new Ceiling(limit, item.Name, item.Level);
			}
			return new Ceiling(limit, null, 0f);
		}

		public static Dictionary<long, float> CountAll(IEnumerable<Standing> standings, float gap, float rate, float minimum)
		{
			List<Standing> list = standings.ToList();
			(float, Standing)? tuple = Split(list, gap);
			Dictionary<long, float> dictionary = new Dictionary<long, float>();
			foreach (Standing item in list)
			{
				bool flag = tuple.HasValue && item.Level >= tuple.Value.Item1;
				dictionary[item.Id] = (flag ? Lower(item.Level, Limit(tuple.Value.Item2.Level, gap, minimum), rate) : item.Level);
			}
			return dictionary;
		}

		public static Standing GroupBest(IEnumerable<Standing> standings, float gap)
		{
			List<Standing> list = standings.ToList();
			(float, Standing)? tuple = Split(list, gap);
			if (tuple.HasValue)
			{
				return tuple.Value.Item2;
			}
			return list.OrderByDescending((Standing s) => s.Level).ThenBy<Standing, string>((Standing s) => s.Name, StringComparer.Ordinal).FirstOrDefault();
		}

		private static (float Above, Standing Best)? Split(IEnumerable<Standing> standings, float gap)
		{
			Standing standing = null;
			foreach (Standing item in standings.OrderBy((Standing s) => s.Level).ThenByDescending<Standing, string>((Standing s) => s.Name, StringComparer.Ordinal))
			{
				if (standing != null && item.Level - standing.Level > gap)
				{
					return (item.Level, standing);
				}
				standing = item;
			}
			return null;
		}
	}
	internal sealed class Cap
	{
		public float Limit { get; }

		public string Holder { get; }

		public float HolderLevel { get; }

		public bool SetByHand { get; }

		public bool ByMinimum { get; }

		public Cap(float limit, string holder, float holderLevel, bool setByHand, bool byMinimum = false)
		{
			Limit = limit;
			Holder = holder;
			HolderLevel = holderLevel;
			SetByHand = setByHand;
			ByMinimum = byMinimum;
		}
	}
	[BepInPlugin("isimp.Kinsmen", "Kinsmen", "0.2.0")]
	[BepInProcess("valheim.exe")]
	[BepInProcess("valheim_server.exe")]
	public class Plugin : BaseUnityPlugin
	{
		[Serializable]
		[CompilerGenerated]
		private sealed class <>c
		{
			public static readonly <>c <>9 = new <>c();

			public static EventHandler <>9__36_0;

			public static Action<ConsoleEventArgs> <>9__40_0;

			public static Action<ConsoleEventArgs> <>9__40_1;

			public static Action<ConsoleEventArgs> <>9__40_2;

			public static Action<ConsoleEventArgs> <>9__40_3;

			public static ConsoleEvent <>9__40_4;

			internal void <Awake>b__36_0(object _, EventArgs __)
			{
				HeldEffect.Refresh();
			}

			internal void <RegisterCommand>b__40_0(ConsoleEventArgs args)
			{
				string text = ((args.Length >= 3) ? string.Join(" ", args.Args, 2, args.Args.Length - 2) : "");
				if (text.Length == 0)
				{
					Terminal obj = args.Context.OrNull<Terminal>();
					if (obj != null)
					{
						obj.AddString("Name the character to forget: /kinsmen forget Name");
					}
				}
				else
				{
					RecordClient.AskToForget(text);
				}
			}

			internal void <RegisterCommand>b__40_1(ConsoleEventArgs args)
			{
				Terminal obj = args.Context.OrNull<Terminal>();
				if (obj != null)
				{
					obj.AddString(RecordClient.DescribeRecord());
				}
			}

			internal void <RegisterCommand>b__40_2(ConsoleEventArgs args)
			{
				Terminal obj = args.Context.OrNull<Terminal>();
				if (obj != null)
				{
					obj.AddString(RecordClient.DescribeCaps());
				}
			}

			internal void <RegisterCommand>b__40_3(ConsoleEventArgs args)
			{
				Terminal obj = args.Context.OrNull<Terminal>();
				if (obj != null)
				{
					obj.AddString(RecordClient.DescribeHeld());
				}
			}

			internal void <RegisterCommand>b__40_4(ConsoleEventArgs args)
			{
				if (args.Length >= 2 && CommandWords.TryGetValue(args[1], out Action<ConsoleEventArgs> value))
				{
					value(args);
					return;
				}
				string unknown = ((args.Length >= 2) ? args[1] : null);
				Terminal obj = args.Context.OrNull<Terminal>();
				if (obj != null)
				{
					obj.AddString(Words.Help(CommandWords.ContainsKey("selftest"), unknown));
				}
			}
		}

		public const string Guid = "isimp.Kinsmen";

		public const string Name = "Kinsmen";

		public const string Version = "0.2.0";

		private const string MinimumVersion = "0.2.0";

		internal static ManualLogSource Log;

		internal static Harmony Harmony;

		private static ConfigSync _sync;

		private static ConfigEntry<bool> _lockConfig;

		private static ConfigEntry<bool> _enabled;

		private static ConfigEntry<string> _skills;

		private static ConfigEntry<float> _gap;

		private static ConfigEntry<float> _rate;

		private static ConfigEntry<float> _minimumCap;

		private static ConfigEntry<int> _forgetAfterDays;

		private static ConfigEntry<string> _fixedCaps;

		private static ConfigEntry<string> _exempt;

		private static ConfigEntry<bool> _showEffectIcon;

		private static ConfigEntry<bool> _showJoinMessage;

		private static readonly HashSet<string> Warned = new HashSet<string>(StringComparer.Ordinal);

		internal static readonly Dictionary<string, Action<ConsoleEventArgs>> CommandWords = new Dictionary<string, Action<ConsoleEventArgs>>(StringComparer.OrdinalIgnoreCase);

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

		internal static string SkillNames => _skills?.Value ?? "Swords, Knives, Clubs, Polearms, Spears, Axes, Bows, Crossbows, Unarmed, Pickaxes, ElementalMagic, BloodMagic, Blocking, Run, Jump, Dodge, Sneak, Swim, Ride, Crafting, Cooking";

		internal static int ForgetAfterDays => _forgetAfterDays?.Value ?? 30;

		internal static string FixedCaps => _fixedCaps?.Value ?? "";

		internal static string ExemptNames => _exempt?.Value ?? "";

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

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

		internal static LadderSettings Settings => new LadderSettings(_gap?.Value ?? 15f, _rate?.Value ?? 0.25f, _minimumCap?.Value ?? 30f);

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

		private void Awake()
		{
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Expected O, but got Unknown
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Expected O, but got Unknown
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0105: Expected O, but got Unknown
			//IL_0133: Unknown result type (might be due to invalid IL or missing references)
			//IL_013d: Expected O, but got Unknown
			//IL_016b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0175: Expected O, but got Unknown
			//IL_0195: Unknown result type (might be due to invalid IL or missing references)
			//IL_019f: Expected O, but got Unknown
			//IL_01bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c9: Expected O, but got Unknown
			//IL_01f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fa: Expected O, but got Unknown
			//IL_026d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0277: Expected O, but got Unknown
			Log = ((BaseUnityPlugin)this).Logger;
			_sync = new ConfigSync("isimp.Kinsmen")
			{
				DisplayName = "Kinsmen",
				CurrentVersion = ((BaseUnityPlugin)this).Info.Metadata.Version.ToString(),
				MinimumRequiredVersion = "0.2.0",
				ModRequired = true
			};
			_lockConfig = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "LockConfiguration", true, "Whether the server's rules override local settings. Admins are exempt. The display settings always stay local.");
			_sync.AddLockingConfigEntry<bool>(_lockConfig);
			_enabled = Rule("General", "Enabled", value: true, new ConfigDescription("Whether held skills count lower. Off, every skill counts in full and the record is still kept.", (AcceptableValueBase)null, Array.Empty<object>()));
			_skills = Rule("Rule", "Skills", "Swords, Knives, Clubs, Polearms, Spears, Axes, Bows, Crossbows, Unarmed, Pickaxes, ElementalMagic, BloodMagic, Blocking, Run, Jump, Dodge, Sneak, Swim, Ride, Crafting, Cooking", new ConfigDescription("The skills that can be held, separated by commas, by the game's own names as in the default value, such as ElementalMagic, Unarmed and Ride (not the window's Fists and Riding); case and spaces do not matter. A number stands for a skill another mod adds, by its id. A name Kinsmen does not know is named in the log and left free.", (AcceptableValueBase)null, Array.Empty<object>()));
			_gap = Rule("Rule", "OutlierGap", 15f, new ConfigDescription("Walking up everyone's levels in a skill, the first step up wider than this splits off the characters far ahead; everyone below it counts in full. A character far ahead counts in full up to the best level below the step plus this many levels, and RateAbove for each level beyond, so one more level of training never lowers what a skill counts as. Smaller holds characters far ahead tighter, but also catches a normal step between two players sooner.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(1f, 100f), Array.Empty<object>()));
			_rate = Rule("Rule", "RateAbove", 0.25f, new ConfigDescription("What each level beyond that counts as: 0.25 is a quarter of a level, 0 holds the character there, 1 holds nobody.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 1f), Array.Empty<object>()));
			_minimumCap = Rule("Rule", "MinimumCap", 30f, new ConfigDescription("However low the rest of the group stands, a character far ahead always counts in full up to at least this level, and RateAbove for each level beyond: with everyone else at 1 Riding, a 35 counts as 31 rather than 20. It only raises the group's cap where that is lower; caps in FixedCaps stay as set. 0 turns it off.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 100f), Array.Empty<object>()));
			_fixedCaps = Rule("Rule", "FixedCaps", "", new ConfigDescription("Caps set by hand, replacing the group's cap for their skill, as Skill=level separated by commas, such as \"Swords=50, ElementalMagic=30\", with skill names as in Skills. Anyone above such a cap counts in full up to it and RateAbove beyond, whatever the group's levels; it holds a skill missing from Skills too. An entry Kinsmen cannot read is named in the log and left out. Empty by default.", (AcceptableValueBase)null, Array.Empty<object>()));
			_exempt = Rule("Rule", "Exempt", "", new ConfigDescription("Characters whose skills always count in full, by name (any case) or by id for two of the same name, separated by commas. Their real levels still go into the record and still count for everyone else's limits. Empty by default.", (AcceptableValueBase)null, Array.Empty<object>()));
			_forgetAfterDays = Rule("Record", "ForgetAfterDays", 30, new ConfigDescription("A character not seen on the server for this many days drops out of the record. 0 keeps everyone.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(0, 3650), Array.Empty<object>()));
			_showEffectIcon = ((BaseUnityPlugin)this).Config.Bind<bool>("Display", "ShowEffectIcon", true, "Show an effect icon beside the others while any of your skills counts lower here.");
			_showJoinMessage = ((BaseUnityPlugin)this).Config.Bind<bool>("Display", "ShowJoinMessage", true, "On joining, say in the middle of the screen and in chat which of your skills count lower here.");
			_showEffectIcon.SettingChanged += delegate
			{
				HeldEffect.Refresh();
			};
			Harmony = new Harmony("isimp.Kinsmen");
			try
			{
				Harmony.PatchAll(typeof(CapHook));
				Harmony.PatchAll(typeof(SkillsWindow));
				Harmony.PatchAll(typeof(HeldEffect));
				Harmony.PatchAll(typeof(RecordMessages));
			}
			catch (Exception ex)
			{
				Harmony.UnpatchSelf();
				Log.LogError((object)("Kinsmen could not hook into the game and holds no skill this session: " + ex));
				return;
			}
			RegisterCommand();
			Log.LogInfo((object)"Kinsmen 0.2.0 loaded.");
		}

		private void Update()
		{
			RecordClient.Tick();
		}

		internal static void WarnOnce(string place, Exception failure)
		{
			if (Warned.Add(place))
			{
				Log.LogWarning((object)("Kinsmen, " + place + ": " + failure));
			}
		}

		private static void RegisterCommand()
		{
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Expected O, but got Unknown
			CommandWords["forget"] = delegate(ConsoleEventArgs args)
			{
				string text = ((args.Length >= 3) ? string.Join(" ", args.Args, 2, args.Args.Length - 2) : "");
				if (text.Length == 0)
				{
					Terminal obj2 = args.Context.OrNull<Terminal>();
					if (obj2 != null)
					{
						obj2.AddString("Name the character to forget: /kinsmen forget Name");
					}
				}
				else
				{
					RecordClient.AskToForget(text);
				}
			};
			CommandWords["record"] = delegate(ConsoleEventArgs args)
			{
				Terminal obj2 = args.Context.OrNull<Terminal>();
				if (obj2 != null)
				{
					obj2.AddString(RecordClient.DescribeRecord());
				}
			};
			CommandWords["caps"] = delegate(ConsoleEventArgs args)
			{
				Terminal obj2 = args.Context.OrNull<Terminal>();
				if (obj2 != null)
				{
					obj2.AddString(RecordClient.DescribeCaps());
				}
			};
			CommandWords["held"] = delegate(ConsoleEventArgs args)
			{
				Terminal obj2 = args.Context.OrNull<Terminal>();
				if (obj2 != null)
				{
					obj2.AddString(RecordClient.DescribeHeld());
				}
			};
			object obj = <>c.<>9__40_4;
			if (obj == null)
			{
				ConsoleEvent val = delegate(ConsoleEventArgs args)
				{
					if (args.Length >= 2 && CommandWords.TryGetValue(args[1], out Action<ConsoleEventArgs> value))
					{
						value(args);
					}
					else
					{
						string unknown = ((args.Length >= 2) ? args[1] : null);
						Terminal obj2 = args.Context.OrNull<Terminal>();
						if (obj2 != null)
						{
							obj2.AddString(Words.Help(CommandWords.ContainsKey("selftest"), unknown));
						}
					}
				};
				<>c.<>9__40_4 = val;
				obj = (object)val;
			}
			new ConsoleCommand("kinsmen", "Kinsmen: type /kinsmen for its commands.", (ConsoleEvent)obj, false, false, false, false, false, false, (ConsoleOptionsFetcher)null, false, false, false);
		}
	}
	internal sealed class RecordEntry
	{
		public long Id { get; }

		public string Name { get; }

		public long LastSeen { get; }

		public IReadOnlyDictionary<int, float> Levels { get; }

		public RecordEntry(long id, string name, long lastSeen, Dictionary<int, float> levels)
		{
			Id = id;
			Name = name;
			LastSeen = lastSeen;
			Levels = levels;
		}
	}
	internal sealed class Record
	{
		private const string Header = "kinsmen record 1";

		private static readonly char[] Between = new char[1] { ';' };

		private readonly Dictionary<long, RecordEntry> _entries = new Dictionary<long, RecordEntry>();

		public IReadOnlyCollection<RecordEntry> Entries => _entries.Values;

		public RecordEntry Find(long id)
		{
			if (!_entries.TryGetValue(id, out RecordEntry value))
			{
				return null;
			}
			return value;
		}

		public void Note(long id, string name, IDictionary<int, float> levels, long now)
		{
			_entries[id] = new RecordEntry(id, Clean(name), now, new Dictionary<int, float>(levels));
		}

		public int DropUnseen(long now, int days)
		{
			if (days <= 0)
			{
				return 0;
			}
			long oldest = now - (long)days * 24L * 60 * 60;
			List<long> list = (from e in _entries.Values
				where e.LastSeen < oldest
				select e.Id).ToList();
			foreach (long item in list)
			{
				_entries.Remove(item);
			}
			return list.Count;
		}

		public int Forget(string name)
		{
			string wanted = Clean(name);
			List<long> list = (from e in _entries.Values
				where string.Equals(e.Name, wanted, StringComparison.OrdinalIgnoreCase)
				select e.Id).ToList();
			foreach (long item in list)
			{
				_entries.Remove(item);
			}
			return list.Count;
		}

		public List<Standing> Others(int skill, long self)
		{
			float value;
			return (from e in _entries.Values
				where e.Id != self
				select new Standing(e.Id, e.Name, e.Levels.TryGetValue(skill, out value) ? value : 0f)).ToList();
		}

		public string Write()
		{
			StringBuilder stringBuilder = new StringBuilder("kinsmen record 1").Append('\n');
			foreach (RecordEntry item in _entries.Values.OrderBy((RecordEntry e) => e.Id))
			{
				stringBuilder.Append(item.Id.ToString(CultureInfo.InvariantCulture)).Append('\t').Append(item.Name)
					.Append('\t')
					.Append(item.LastSeen.ToString(CultureInfo.InvariantCulture))
					.Append('\t')
					.Append(string.Join(";", from l in item.Levels
						orderby l.Key
						select l.Key.ToString(CultureInfo.InvariantCulture) + "=" + l.Value.ToString("R", CultureInfo.InvariantCulture)))
					.Append('\n');
			}
			return stringBuilder.ToString();
		}

		public static Record Read(string text, out List<string> problems)
		{
			problems = new List<string>();
			Record record = new Record();
			if (string.IsNullOrEmpty(text))
			{
				return record;
			}
			string[] array = text.Replace("\r", "").Split(new char[1] { '\n' });
			if (array[0] != "kinsmen record 1")
			{
				problems.Add("not a Kinsmen record: the first line reads \"" + Shorten(array[0]) + "\"");
				return record;
			}
			for (int i = 1; i < array.Length; i++)
			{
				if (array[i].Length != 0)
				{
					RecordEntry recordEntry = ReadLine(array[i]);
					if (recordEntry == null)
					{
						problems.Add("line " + (i + 1).ToString(CultureInfo.InvariantCulture) + " cannot be read: " + Shorten(array[i]));
					}
					else
					{
						record._entries[recordEntry.Id] = recordEntry;
					}
				}
			}
			return record;
		}

		private static RecordEntry ReadLine(string line)
		{
			string[] array = line.Split(new char[1] { '\t' });
			if (array.Length != 4)
			{
				return null;
			}
			if (!long.TryParse(array[0], NumberStyles.Integer, CultureInfo.InvariantCulture, out var result))
			{
				return null;
			}
			if (!long.TryParse(array[2], NumberStyles.Integer, CultureInfo.InvariantCulture, out var result2))
			{
				return null;
			}
			Dictionary<int, float> dictionary = new Dictionary<int, float>();
			string[] array2 = array[3].Split(Between, StringSplitOptions.RemoveEmptyEntries);
			for (int i = 0; i < array2.Length; i++)
			{
				string[] array3 = array2[i].Split(new char[1] { '=' });
				if (array3.Length != 2 || !int.TryParse(array3[0], NumberStyles.Integer, CultureInfo.InvariantCulture, out var result3) || !float.TryParse(array3[1], NumberStyles.Float, CultureInfo.InvariantCulture, out var result4))
				{
					return null;
				}
				dictionary[result3] = result4;
			}
			return new RecordEntry(result, array[1], result2, dictionary);
		}

		private static string Clean(string name)
		{
			return (name ?? "").Replace('\t', ' ').Replace('\r', ' ').Replace('\n', ' ')
				.Trim();
		}

		private static string Shorten(string line)
		{
			if (line.Length > 60)
			{
				return line.Substring(0, 60) + "...";
			}
			return line;
		}
	}
	internal static class RecordClient
	{
		private const float LookEvery = 2f;

		private static Record _record;

		private static Record _madeUp;

		private static CountingTable _table = CountingTable.None;

		private static long _tableFor;

		private static string _sent;

		private static float _nextLook;

		private static bool _joinTold;

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

		public static CountingTable Table => _table;

		internal static Record ServerRecord => _record;

		public static void Joined()
		{
			_record = null;
			_madeUp = null;
			_table = CountingTable.None;
			_tableFor = 0L;
			_sent = null;
			_nextLook = 0f;
			_joinTold = false;
			HeldEffect.Refresh();
		}

		internal static void UseRecord(Record madeUp)
		{
			_madeUp = madeUp;
			Rebuild();
		}

		public static void OnRecord(long sender, string text)
		{
			if (!FromServer(sender))
			{
				return;
			}
			_record = Record.Read(text, out List<string> problems);
			foreach (string item in problems)
			{
				Plugin.Log.LogWarning((object)("Kinsmen record from the server: " + item));
			}
			Rebuild();
		}

		public static void OnSaid(long sender, string said)
		{
			if (FromServer(sender))
			{
				Chat obj = Chat.instance.OrNull<Chat>();
				if (obj != null)
				{
					((Terminal)obj).AddString(said);
				}
				Console obj2 = Console.instance.OrNull<Console>();
				if (obj2 != null)
				{
					obj2.Print(said);
				}
			}
		}

		public static void Rebuild()
		{
			Player localPlayer = Player.m_localPlayer;
			List<string> list = new List<string>();
			_held = SkillList.Parse(Plugin.SkillNames, list);
			if (list.Count > 0)
			{
				Plugin.Log.LogWarning((object)("Kinsmen does not know these skills of its list and leaves them free: " + string.Join(", ", list)));
			}
			Record record = _madeUp ?? _record;
			if (record == null || (Object)(object)localPlayer == (Object)null || !Plugin.Enabled)
			{
				_table = CountingTable.None;
				_tableFor = 0L;
			}
			else
			{
				List<string> list2 = new List<string>();
				Dictionary<int, float> fixedCaps = SkillList.ParseCaps(Plugin.FixedCaps, list2);
				if (list2.Count > 0)
				{
					Plugin.Log.LogWarning((object)("Kinsmen cannot read these caps set by hand and leaves them out: " + string.Join(", ", list2)));
				}
				_tableFor = localPlayer.GetPlayerID();
				bool exempt = Exemptions.Parse(Plugin.ExemptNames).Covers(_tableFor, localPlayer.GetPlayerName());
				_table = new CountingTable(record, _tableFor, _held, Plugin.Settings, fixedCaps, exempt);
			}
			HeldEffect.Refresh();
		}

		public static string DescribeCaps()
		{
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Expected I4, but got Unknown
			if (_record == null)
			{
				return "Kinsmen: no record from the server yet, so no skill has a cap.";
			}
			if (!Plugin.Enabled)
			{
				return "Kinsmen is turned off on this server: no skill has a cap.";
			}
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null)
			{
				return "Kinsmen: the caps are worked out for a character in the world.";
			}
			Dictionary<int, float> levels = new Dictionary<int, float>();
			foreach (Skill skill in ((Character)localPlayer).GetSkills().GetSkillList())
			{
				levels[(int)skill.m_info.m_skill] = skill.m_level;
			}
			LadderSettings settings = Plugin.Settings;
			float value;
			IEnumerable<string> values = from s in _table.Capped.Select((int id) => (Name: Name((SkillType)id), Id: id)).OrderBy<(string, int), string>(((string Name, int Id) s) => s.Name, StringComparer.OrdinalIgnoreCase)
				select Words.CapLine(s.Name, _table.Cap(s.Id, levels.TryGetValue(s.Id, out value) ? value : 0f), settings.Gap, settings.Rate);
			return "Kinsmen caps on this server:\n" + string.Join("\n", values);
		}

		public static void Tick()
		{
			if (Time.unscaledTime < _nextLook)
			{
				return;
			}
			_nextLook = Time.unscaledTime + 2f;
			try
			{
				Player localPlayer = Player.m_localPlayer;
				if (!((Object)(object)localPlayer == (Object)null) && ZRoutedRpc.instance != null && !((Object)(object)ZNet.instance == (Object)null))
				{
					if ((_madeUp ?? _record) != null && localPlayer.GetPlayerID() != _tableFor && Plugin.Enabled)
					{
						Rebuild();
					}
					SendIfChanged(localPlayer);
					TellOnJoining(localPlayer);
				}
			}
			catch (Exception failure)
			{
				Plugin.WarnOnce("sending the character's levels", failure);
			}
		}

		public static void AskToForget(string name)
		{
			if (ZRoutedRpc.instance == null)
			{
				Chat obj = Chat.instance.OrNull<Chat>();
				if (obj != null)
				{
					((Terminal)obj).AddString("Kinsmen keeps its record in a world; join one first.");
				}
			}
			else
			{
				ZRoutedRpc.instance.InvokeRoutedRPC("Kinsmen_Forget", new object[1] { name });
			}
		}

		public static string DescribeHeld()
		{
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			if (_record == null)
			{
				return "Kinsmen: no record from the server yet, so every skill counts in full.";
			}
			if (!Plugin.Enabled)
			{
				return "Kinsmen is turned off on this server: every skill counts in full.";
			}
			if (_table.Exempt)
			{
				return "Kinsmen: this server exempts you, so every skill of yours counts in full.";
			}
			List<(SkillType, float, float, Ceiling)> list = Held(Player.m_localPlayer);
			if (list.Count == 0)
			{
				return "Kinsmen: none of your skills count lower here.";
			}
			StringBuilder stringBuilder = new StringBuilder();
			foreach (var (skill, _, level, ceiling) in list)
			{
				stringBuilder.Append(Words.Tooltip(Name(skill), Whole(level), ceiling.Holder, Whole(ceiling.HolderLevel), Whole(ceiling.Limit), Plugin.Settings.Rate)).Append('\n');
			}
			return stringBuilder.ToString().TrimEnd(new char[1] { '\n' });
		}

		public static string DescribeRecord()
		{
			if (_record == null)
			{
				return "Kinsmen: no record from the server yet.";
			}
			if (_record.Entries.Count == 0)
			{
				return "Kinsmen: the record is empty.";
			}
			long now = DateTimeOffset.UtcNow.ToUnixTimeSeconds();
			return "Kinsmen record: " + string.Join(", ", from e in _record.Entries.OrderBy<RecordEntry, string>((RecordEntry e) => e.Name, StringComparer.OrdinalIgnoreCase)
				select e.Name + " (" + Seen(now - e.LastSeen) + ")");
		}

		public static int HeldCount()
		{
			return Held(Player.m_localPlayer).Count;
		}

		public static List<(SkillType Skill, float Real, float Counted, Ceiling Why)> Held(Player player)
		{
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Expected I4, but got Unknown
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Expected I4, but got Unknown
			List<(SkillType, float, float, Ceiling)> list = new List<(SkillType, float, float, Ceiling)>();
			if ((Object)(object)player == (Object)null || !_table.Holds)
			{
				return list;
			}
			foreach (Skill skill2 in ((Character)player).GetSkills().GetSkillList())
			{
				SkillType skill = skill2.m_info.m_skill;
				float level = skill2.m_level;
				float num = _table.Lower((int)skill, level);
				if (!(Math.Floor(num) >= Math.Floor(level)))
				{
					list.Add((skill, level, num, _table.Why((int)skill, level)));
				}
			}
			return list;
		}

		public unsafe static string Name(SkillType skill)
		{
			if (Localization.instance != null)
			{
				return Localization.instance.Localize("$skill_" + ((object)(*(SkillType*)(&skill))/*cast due to .constrained prefix*/).ToString().ToLowerInvariant());
			}
			return ((object)(*(SkillType*)(&skill))/*cast due to .constrained prefix*/).ToString();
		}

		public static int Whole(float level)
		{
			return (int)Math.Floor(level);
		}

		private static void SendIfChanged(Player player)
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Expected I4, but got Unknown
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Expected O, but got Unknown
			List<(int, float)> list = new List<(int, float)>();
			foreach (Skill skill in ((Character)player).GetSkills().GetSkillList())
			{
				int num = (int)skill.m_info.m_skill;
				if (_held.Contains(num))
				{
					list.Add((num, skill.m_level));
				}
			}
			string playerName = player.GetPlayerName();
			string text = player.GetPlayerID().ToString(CultureInfo.InvariantCulture) + "|" + playerName + "|" + string.Join(";", list.Select<(int, float), string>(((int Skill, float Level) l) => l.Skill.ToString(CultureInfo.InvariantCulture) + "=" + l.Level.ToString("R", CultureInfo.InvariantCulture)));
			if (text == _sent)
			{
				return;
			}
			ZPackage val = new ZPackage();
			val.Write(player.GetPlayerID());
			val.Write(playerName);
			val.Write(list.Count);
			foreach (var (num2, num3) in list)
			{
				val.Write(num2);
				val.Write(num3);
			}
			ZRoutedRpc.instance.InvokeRoutedRPC("Kinsmen_Levels", new object[1] { val });
			_sent = text;
		}

		private static void TellOnJoining(Player player)
		{
			if (_joinTold || _record == null)
			{
				return;
			}
			_joinTold = true;
			if (!Plugin.ShowJoinMessage)
			{
				return;
			}
			List<(SkillType, float, float, Ceiling)> list = Held(player);
			string text = Words.Joined(list.Count);
			if (text == null)
			{
				return;
			}
			MessageHud obj = MessageHud.instance.OrNull<MessageHud>();
			if (obj != null)
			{
				obj.ShowMessage((MessageType)2, text, 0, (Sprite)null, false, true);
			}
			Chat obj2 = Chat.instance.OrNull<Chat>();
			if (obj2 != null)
			{
				((Terminal)obj2).AddString(Words.ChatList(list.Select<(SkillType, float, float, Ceiling), (string, int, int)>(((SkillType Skill, float Real, float Counted, Ceiling Why) h) => (Name(h.Skill), Whole(h.Counted), Whole(h.Real)))));
			}
		}

		private static bool FromServer(long sender)
		{
			if ((Object)(object)ZNet.instance == (Object)null)
			{
				return false;
			}
			if (ZNet.instance.IsServer())
			{
				return sender == ZDOMan.GetSessionID();
			}
			ZNetPeer serverPeer = ZNet.instance.GetServerPeer();
			if (serverPeer != null)
			{
				return sender == serverPeer.m_uid;
			}
			return false;
		}

		private static string Seen(long secondsAgo)
		{
			long num = secondsAgo / 86400;
			if (num <= 0)
			{
				return "seen today";
			}
			if (num != 1)
			{
				return "seen " + num.ToString(CultureInfo.InvariantCulture) + " days ago";
			}
			return "seen yesterday";
		}
	}
	[HarmonyPatch(typeof(ZNetScene), "Awake")]
	internal static class RecordMessages
	{
		public const string Levels = "Kinsmen_Levels";

		public const string Record = "Kinsmen_Record";

		public const string Forget = "Kinsmen_Forget";

		public const string Said = "Kinsmen_Said";

		private static void Postfix()
		{
			try
			{
				ZRoutedRpc instance = ZRoutedRpc.instance;
				if (instance == null || (Object)(object)ZNet.instance == (Object)null)
				{
					return;
				}
				bool server = ZNet.instance.IsServer();
				instance.Register<ZPackage>("Kinsmen_Levels", (Action<long, ZPackage>)delegate(long sender, ZPackage message)
				{
					if (server)
					{
						RecordServer.OnLevels(sender, message);
					}
				});
				instance.Register<string>("Kinsmen_Forget", (Action<long, string>)delegate(long sender, string name)
				{
					if (server)
					{
						RecordServer.OnForget(sender, name);
					}
				});
				instance.Register<string>("Kinsmen_Record", (Action<long, string>)RecordClient.OnRecord);
				instance.Register<string>("Kinsmen_Said", (Action<long, string>)RecordClient.OnSaid);
				RecordClient.Joined();
				if (server)
				{
					RecordServer.Start(ZNet.instance.GetWorldName());
				}
				else
				{
					RecordServer.Stop();
				}
			}
			catch (Exception ex)
			{
				Plugin.Log.LogError((object)("Kinsmen could not set up its record for this world and holds no skill in it: " + ex));
			}
		}
	}
	internal static class RecordServer
	{
		private const int MostSkills = 512;

		private const int LongestName = 64;

		private static Record _record = new Record();

		private static string _path;

		internal static string RecordPath => _path;

		public static void Start(string worldName)
		{
			_path = Path.Combine(Paths.ConfigPath, "Kinsmen", FileName(worldName) + ".record.txt");
			_record = Load(_path);
			if (_record.DropUnseen(Now(), Plugin.ForgetAfterDays) > 0)
			{
				Save();
			}
			Plugin.Log.LogInfo((object)("Kinsmen record for this world: " + _path));
		}

		public static void Stop()
		{
			_path = null;
			_record = new Record();
		}

		public static void OnLevels(long sender, ZPackage message)
		{
			if (_path == null)
			{
				return;
			}
			try
			{
				long num = message.ReadLong();
				string text = message.ReadString();
				int num2 = message.ReadInt();
				if (num == 0L || num2 < 0 || num2 > 512)
				{
					return;
				}
				Dictionary<int, float> dictionary = new Dictionary<int, float>();
				for (int i = 0; i < num2; i++)
				{
					int key = message.ReadInt();
					float num3 = message.ReadSingle();
					if (!float.IsNaN(num3) && !float.IsInfinity(num3))
					{
						dictionary[key] = Math.Max(0f, Math.Min(1000f, num3));
					}
				}
				if (text.Length > 64)
				{
					text = text.Substring(0, 64);
				}
				_record.Note(num, text, dictionary, Now());
				_record.DropUnseen(Now(), Plugin.ForgetAfterDays);
				Save();
				Send();
			}
			catch (Exception failure)
			{
				Plugin.WarnOnce("reading a game's levels", failure);
			}
		}

		public static void OnForget(long sender, string name)
		{
			if (_path == null)
			{
				return;
			}
			string text;
			if (!IsAdmin(sender))
			{
				text = "Only an admin can take a character out of the Kinsmen record.";
			}
			else
			{
				int num = _record.Forget(name);
				text = ((num == 0) ? ("Nobody called " + name + " is in the Kinsmen record.") : (name + " is out of the Kinsmen record."));
				if (num > 0)
				{
					Save();
					Send();
				}
			}
			ZRoutedRpc.instance.InvokeRoutedRPC(sender, "Kinsmen_Said", new object[1] { text });
		}

		private static void Send()
		{
			ZRoutedRpc.instance.InvokeRoutedRPC(0L, "Kinsmen_Record", new object[1] { _record.Write() });
		}

		private static bool IsAdmin(long sender)
		{