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.Numerics;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.CompilerServices;
using System.Runtime.Serialization;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using JetBrains.Annotations;
using Microsoft.CodeAnalysis;
using ServerSync;
using UnityEngine;
using UnityEngine.Animations;
using UnityEngine.Playables;
using UnityEngine.Rendering;

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

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

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

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

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

		public bool SynchronizedConfig = true;

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

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

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

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

		public readonly string Identifier;

		public readonly Type Type;

		private object? boxedValue;

		protected bool localIsOwner;

		public readonly int Priority;

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

		public event Action? ValueChanged;

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

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

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

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

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

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

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

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

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

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

				public volatile int versionMatchQueued = -1;

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

				public readonly ISocket Original;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

		private class PackageEntry
		{
			public string section;

			public string key;

			public Type type;

			public object? value;
		}

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

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

		private class InvalidDeserializationTypeException : Exception
		{
			public string expected;

			public string received;

			public string field = "";
		}

		public static bool ProcessingServerUpdate;

		public readonly string Name;

		public string? DisplayName;

		public string? CurrentVersion;

		public string? MinimumRequiredVersion;

		public bool ModRequired;

		private bool? forceConfigLocking;

		private bool isSourceOfTruth = true;

		private static readonly HashSet<ConfigSync> configSyncs;

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

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

		private static bool isServer;

		private static bool lockExempt;

		private OwnConfigEntryBase? lockedConfig;

		private const byte PARTIAL_CONFIGS = 1;

		private const byte FRAGMENTED_CONFIG = 2;

		private const byte COMPRESSED_CONFIG = 4;

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

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

		private static long packageCounter;

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

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

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

		public bool InitialSyncDone { get; private set; }

		public event Action<bool>? SourceOfTruthChanged;

		private event Action? lockedConfigChanged;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

		private static readonly Dictionary<string, string> notProcessedNames;

		public string Name;

		private string? displayName;

		private string? currentVersion;

		private string? minimumRequiredVersion;

		public bool ModRequired = true;

		private string? ReceivedCurrentVersion;

		private string? ReceivedMinimumRequiredVersion;

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

		private ConfigSync? ConfigSync;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

		[HarmonyPatch(typeof(FejdStartup), "ShowConnectError")]
		[HarmonyPostfix]
		private static void ShowConnectionError(FejdStartup __instance)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Invalid comparison between Unknown and I4
			if ((int)ZNet.GetConnectionStatus() != 3)
			{
				return;
			}
			string text = string.Join("\n", from check in GetFailedClient()
				select check.Error());
			foreach (KeyValuePair<string, string> notProcessedName in notProcessedNames)
			{
				text = text + "\nServer requires " + notProcessedName.Key + " " + notProcessedName.Value;
			}
			if (text.Length == 0)
			{
				return;
			}
			object obj = AccessTools.Field(typeof(FejdStartup), "m_connectionFailedError")?.GetValue(__instance);
			if (obj != null)
			{
				PropertyInfo propertyInfo = AccessTools.Property(obj.GetType(), "text");
				if (propertyInfo != null)
				{
					propertyInfo.SetValue(obj, (string)propertyInfo.GetValue(obj) + "\n" + text);
				}
			}
		}
	}
}
namespace VikingSeafarer
{
	internal static class AnchorSystem
	{
		internal const string Rpc = "VS_Anchor";

		internal static readonly int Anchored = StringExtensionMethods.GetStableHashCode("VS_anchored");

		internal static readonly int Point = StringExtensionMethods.GetStableHashCode("VS_anchorPoint");

		internal static readonly int Id = StringExtensionMethods.GetStableHashCode("VS_boatIdentity");

		internal static bool IsAnchored(Ship s)
		{
			if (Object.op_Implicit((Object)(object)s) && Object.op_Implicit((Object)(object)s.m_nview) && s.m_nview.IsValid())
			{
				return s.m_nview.GetZDO().GetBool(Anchored, false);
			}
			return false;
		}

		internal static string Hint(Ship ship)
		{
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			bool num = IsAnchored(ship);
			string text = (num ? Text.T("Lever l'ancre", "Raise anchor") : Text.T("Jeter l'ancre", "Drop anchor"));
			string text2 = (num ? Text.T("Amarré", "Anchored") : Text.T("Ancre levée", "Unanchored"));
			string text3 = (num ? "#FF6464" : "#FFD34D");
			return "<color=" + text3 + ">[" + Text.Shortcut(Plugin.AnchorKey.Value) + "] " + text + " — " + text2 + "</color>";
		}

		internal static Ship? Target(Player p)
		{
			IDoodadController doodadController = p.GetDoodadController();
			ShipControlls val = (ShipControlls)(object)((doodadController is ShipControlls) ? doodadController : null);
			if (val != null)
			{
				return val.m_ship;
			}
			GameObject hoverObject = ((Humanoid)p).GetHoverObject();
			ShipControlls val2 = (Object.op_Implicit((Object)(object)hoverObject) ? hoverObject.GetComponentInParent<ShipControlls>() : null);
			if (!((Object)(object)val2 != (Object)null))
			{
				return null;
			}
			return val2.m_ship;
		}

		internal static void ToggleLocal(Player p)
		{
			Ship val = Target(p);
			if ((Object)(object)val == (Object)null)
			{
				Text.Say(p, "Regarde le gouvernail ou prends la barre.", "Look at the rudder or take the helm.");
				return;
			}
			if (!Compatibility.CanAnchor(val, p))
			{
				Text.Say(p, "Accès au bateau refusé.", "Boat access denied.");
				return;
			}
			val.m_nview.InvokeRPC("VS_Anchor", new object[2]
			{
				p.GetPlayerID(),
				!IsAnchored(val)
			});
		}

		internal static void Register(Ship ship)
		{
			if (!Object.op_Implicit((Object)(object)ship.m_nview) || !ship.m_nview.IsValid())
			{
				return;
			}
			ship.m_nview.Register<long, bool>("VS_Anchor", (Action<long, long, bool>)delegate(long sender, long playerId, bool desired)
			{
				//IL_0056: Unknown result type (might be due to invalid IL or missing references)
				//IL_006b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0117: Unknown result type (might be due to invalid IL or missing references)
				//IL_0128: Unknown result type (might be due to invalid IL or missing references)
				if (Plugin.Anchoring.Value && !((Object)(object)ship == (Object)null) && ship.m_nview.IsOwner())
				{
					Player val = Compatibility.Sender(sender, playerId);
					if (!((Object)(object)val == (Object)null) && Object.op_Implicit((Object)(object)ship.m_shipControlls) && !(Vector3.Distance(((Component)val).transform.position, ((Component)ship.m_shipControlls).transform.position) > 5f) && Compatibility.CanAnchor(ship, val))
					{
						long user = ship.m_shipControlls.GetUser();
						if (user == 0L || user == val.GetPlayerID())
						{
							ZDO zDO = ship.m_nview.GetZDO();
							if (zDO.GetBool(Anchored, false) != desired)
							{
								if (desired)
								{
									if (zDO.GetString(Id, "") == "")
									{
										zDO.Set(Id, Guid.NewGuid().ToString("N"));
									}
									zDO.Set(Point, ((Component)ship).transform.position);
									ship.m_speed = (Speed)0;
								}
								zDO.Set(Anchored, desired);
							}
						}
					}
				}
			});
		}

		internal static void Hold(Ship s, float dt)
		{
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: 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_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			if (Plugin.Anchoring.Value && s.IsOwner() && IsAnchored(s) && Object.op_Implicit((Object)(object)s.m_body))
			{
				s.m_speed = (Speed)0;
				Vector3 val = s.m_nview.GetZDO().GetVec3(Point, ((Component)s).transform.position) - s.m_body.position;
				val.y = 0f;
				Vector3 velocity = s.m_body.velocity;
				Vector3 val2 = default(Vector3);
				((Vector3)(ref val2))..ctor(velocity.x, 0f, velocity.z);
				Vector3 val3 = ((((Vector3)(ref val)).magnitude > Plugin.AnchorSlack.Value) ? (((Vector3)(ref val)).normalized * (((Vector3)(ref val)).magnitude - Plugin.AnchorSlack.Value) * 3f) : Vector3.zero);
				s.m_body.AddForce(Vector3.ClampMagnitude(val3 - val2 * 4f, 12f), (ForceMode)5);
			}
		}
	}
	[HarmonyPatch(typeof(Ship), "Awake")]
	internal static class AnchorAwake
	{
		private static void Postfix(Ship __instance)
		{
			AnchorSystem.Register(__instance);
		}
	}
	[HarmonyPatch(typeof(Ship), "CustomFixedUpdate")]
	internal static class AnchorPhysics
	{
		private static void Prefix(Ship __instance, out float __state)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			__state = __instance.m_waterImpactDamage;
			if (Plugin.Anchoring.Value && AnchorSystem.IsAnchored(__instance))
			{
				__instance.m_speed = (Speed)0;
				if (Plugin.ProtectedWaveImpacts.Value)
				{
					__instance.m_waterImpactDamage = 0f;
				}
			}
		}

		private static void Postfix(Ship __instance, float fixedDeltaTime)
		{
			AnchorSystem.Hold(__instance, fixedDeltaTime);
		}

		private static void Finalizer(Ship __instance, float __state)
		{
			__instance.m_waterImpactDamage = __state;
		}
	}
	[HarmonyPatch(typeof(ShipControlls), "GetHoverText")]
	internal static class AnchorHover
	{
		private static void Postfix(ShipControlls __instance, ref string __result)
		{
			if (Plugin.Anchoring.Value)
			{
				__result = __result + "\n" + AnchorSystem.Hint(__instance.m_ship);
			}
		}
	}
	[HarmonyPatch(typeof(Ship), "RPC_Forward")]
	internal static class AnchorForward
	{
		private static bool Prefix(Ship __instance)
		{
			if (Plugin.Anchoring.Value)
			{
				return !AnchorSystem.IsAnchored(__instance);
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(Ship), "RPC_Backward")]
	internal static class AnchorBackward
	{
		private static bool Prefix(Ship __instance)
		{
			if (Plugin.Anchoring.Value)
			{
				return !AnchorSystem.IsAnchored(__instance);
			}
			return true;
		}
	}
	internal static class Compatibility
	{
		internal static bool HasFirstPerson;

		private static FieldInfo? fp;

		private static MethodInfo? evaluate;

		private static bool accessInstalled;

		internal static void Initialize()
		{
			HasFirstPerson = Chainloader.PluginInfos.TryGetValue("Azumatt.FirstPersonMode", out var value);
			if (value != null)
			{
				fp = AccessTools.Field(((object)value.Instance).GetType().Assembly.GetType("FirstPersonMode.FirstPersonModePlugin+DynamicPerson"), "IsFirstPerson");
			}
			accessInstalled = Chainloader.PluginInfos.TryGetValue("zephyrfit.simpleaccesscontrol", out var value2);
			if (value2 != null)
			{
				evaluate = AccessTools.Method(((object)value2.Instance).GetType().Assembly.GetType("SimpleAccessControl.AccessPolicy"), "Evaluate", (Type[])null, (Type[])null);
			}
			if (accessInstalled && evaluate == null)
			{
				Plugin.Log.LogWarning((object)"SimpleAccessControl API unavailable: anchoring denied until compatibility is repaired.");
			}
		}

		internal static bool IsFirstPerson()
		{
			object obj = fp?.GetValue(null);
			if (obj is bool)
			{
				return (bool)obj;
			}
			if (HasFirstPerson && (Object)(object)GameCamera.instance != (Object)null)
			{
				return GameCamera.instance.m_distance <= 1f;
			}
			return false;
		}

		internal static bool CanAnchor(Ship ship, Player player)
		{
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			foreach (PrivateArea allArea in PrivateArea.m_allAreas)
			{
				if ((Object)(object)allArea != (Object)null && allArea.IsEnabled() && allArea.IsInside(((Component)ship).transform.position, 0f) && ((Object)(object)allArea.m_piece == (Object)null || allArea.m_piece.GetCreator() != player.GetPlayerID()) && !allArea.IsPermitted(player.GetPlayerID()))
				{
					return false;
				}
			}
			if (!accessInstalled)
			{
				return true;
			}
			if (evaluate == null)
			{
				return false;
			}
			try
			{
				Piece component = ((Component)ship).GetComponent<Piece>();
				if (!Object.op_Implicit((Object)(object)component))
				{
					return false;
				}
				return (bool)evaluate.Invoke(null, new object[4]
				{
					component,
					ship.m_nview.GetZDO(),
					player.GetPlayerID(),
					""
				});
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("Anchor access check failed: " + ex.GetType().Name));
				return false;
			}
		}

		internal static Player? Sender(long peer, long playerId)
		{
			Player player = Player.GetPlayer(playerId);
			if (!Object.op_Implicit((Object)(object)player) || !Object.op_Implicit((Object)(object)((Character)player).m_nview) || !((Character)player).m_nview.IsValid() || ((Character)player).m_nview.GetZDO().GetOwner() != peer || ((Character)player).IsDead())
			{
				return null;
			}
			return player;
		}
	}
	internal static class DeckRecovery
	{
		private const string Key = "VikingSeafarer.Deck";

		private static readonly CultureInfo Inv = CultureInfo.InvariantCulture;

		internal static void Record(Player p)
		{
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)p != (Object)(object)Player.m_localPlayer || !Object.op_Implicit((Object)(object)ZNet.instance))
			{
				return;
			}
			p.m_customData.Remove("VikingSeafarer.Deck");
			Ship localShip = Ship.GetLocalShip();
			RaycastHit val = default(RaycastHit);
			if (Plugin.Reboard.Value && Plugin.Anchoring.Value && !((Character)p).IsDead() && !((Object)(object)localShip == (Object)null) && AnchorSystem.IsAnchored(localShip) && Physics.Raycast(((Component)p).transform.position + Vector3.up * 0.2f, Vector3.down, ref val, 1.5f, -1, (QueryTriggerInteraction)1) && !((Object)(object)((Component)((RaycastHit)(ref val)).collider).GetComponentInParent<Ship>() != (Object)(object)localShip))
			{
				Vector3 val2 = ((Component)localShip).transform.InverseTransformPoint(((Component)p).transform.position);
				string text = localShip.m_nview.GetZDO().GetString(AnchorSystem.Id, "");
				if (!(text == ""))
				{
					p.m_customData["VikingSeafarer.Deck"] = string.Join("|", ZNet.instance.GetWorldUID().ToString(Inv), text, val2.x.ToString("R", Inv), val2.y.ToString("R", Inv), val2.z.ToString("R", Inv));
				}
			}
		}

		internal static IEnumerator Restore(Player p)
		{
			if (!Plugin.Reboard.Value || !p.m_customData.TryGetValue("VikingSeafarer.Deck", out var value))
			{
				yield break;
			}
			p.m_customData.Remove("VikingSeafarer.Deck");
			string[] parts = value.Split(new char[1] { '|' });
			if (parts.Length != 5 || !long.TryParse(parts[0], out var world) || !float.TryParse(parts[2], NumberStyles.Float, Inv, out var x) || !float.TryParse(parts[3], NumberStyles.Float, Inv, out var y) || !float.TryParse(parts[4], NumberStyles.Float, Inv, out var z) || !Object.op_Implicit((Object)(object)ZNet.instance) || world != ZNet.instance.GetWorldUID() || float.IsNaN(x + y + z) || float.IsInfinity(x + y + z))
			{
				yield break;
			}
			Vector3 val = new Vector3(x, y, z);
			if (((Vector3)(ref val)).magnitude > 50f)
			{
				yield break;
			}
			Vector3 start = ((Component)p).transform.position;
			RaycastHit val4 = default(RaycastHit);
			for (int i = 0; i < 40; i++)
			{
				if ((Object)(object)p == (Object)null || (Object)(object)p != (Object)(object)Player.m_localPlayer || ((Character)p).IsDead() || Vector3.Distance(start, ((Component)p).transform.position) > 5f)
				{
					yield break;
				}
				foreach (IMonoUpdater instance in Ship.Instances)
				{
					Ship val2 = (Ship)(object)((instance is Ship) ? instance : null);
					if (val2 == null || !Object.op_Implicit((Object)(object)val2.m_nview) || !val2.m_nview.IsValid() || val2.m_nview.GetZDO().GetString(AnchorSystem.Id, "") != parts[1])
					{
						continue;
					}
					Vector3 val3 = ((Component)val2).transform.TransformPoint(new Vector3(x, y, z));
					if (Rules.MayRestore(world, ZNet.instance.GetWorldUID(), !((Character)p).IsDead(), AnchorSystem.IsAnchored(val2), Vector3.Distance(val3, start), 20f) && Compatibility.CanAnchor(val2, p) && Physics.Raycast(val3 + Vector3.up * 2f, Vector3.down, ref val4, 4f, -1, (QueryTriggerInteraction)1) && !((Object)(object)((Component)((RaycastHit)(ref val4)).collider).GetComponentInParent<Ship>() != (Object)(object)val2))
					{
						Vector3 val5 = ((RaycastHit)(ref val4)).point + Vector3.up * 0.2f;
						if (!Physics.CheckCapsule(val5 + Vector3.up * 0.4f, val5 + Vector3.up * 1.6f, 0.28f, LayerMask.GetMask(new string[3] { "piece", "Default", "static_solid" }), (QueryTriggerInteraction)1))
						{
							((Component)p).transform.position = val5;
							((Character)p).m_body.position = val5;
							((Character)p).m_body.velocity = Vector3.zero;
							Text.Say(p, "De retour à bord.", "Back aboard.");
						}
					}
					yield break;
				}
				yield return (object)new WaitForSeconds(0.25f);
			}
			Plugin.Log.LogInfo((object)"Deck restore skipped: anchored boat not loaded nearby. Vanilla spawn position retained.");
		}
	}
	[HarmonyPatch(typeof(Player), "Save")]
	internal static class DeckSave
	{
		private static void Prefix(Player __instance)
		{
			DeckRecovery.Record(__instance);
		}
	}
	[HarmonyPatch(typeof(Player), "OnSpawned")]
	internal static class DeckSpawn
	{
		private static void Postfix(Player __instance, bool spawnValkyrie)
		{
			if (!spawnValkyrie && (Object)(object)__instance == (Object)(object)Player.m_localPlayer)
			{
				((MonoBehaviour)Plugin.Instance).StartCoroutine(DeckRecovery.Restore(__instance));
			}
		}
	}
	[HarmonyPatch(typeof(Player), "OnDeath")]
	internal static class DeckDeath
	{
		private static void Prefix(Player __instance)
		{
			__instance.m_customData.Remove("VikingSeafarer.Deck");
		}
	}
	[BepInPlugin("Zephyrfit.VikingSeafarer", "Viking Seafarer", "1.1.6")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInIncompatibility("sighsorry.DiveIn")]
	[BepInIncompatibility("Searica.Valheim.UnderTheSea")]
	[BepInIncompatibility("blacks7ar.VikingsDoSwim")]
	[BepInIncompatibility("blacks7ar.WieldEquipmentWhileSwimming")]
	[BepInIncompatibility("org.bepinex.plugins.spearfishing")]
	public class Plugin : BaseUnityPlugin
	{
		public enum FastSwimInputMode
		{
			Press,
			Toggle
		}

		private sealed class ConfigurationManagerAttributes
		{
			public int? Order;
		}

		private sealed class AcceptableShortcuts : AcceptableValueBase
		{
			internal AcceptableShortcuts()
				: base(typeof(KeyboardShortcut))
			{
			}

			public override object Clamp(object value)
			{
				return value;
			}

			public override bool IsValid(object value)
			{
				return true;
			}

			public override string ToDescriptionString()
			{
				return "# Acceptable values: " + string.Join(", ", UnityInput.Current.SupportedKeyCodes);
			}
		}

		public enum Toggle
		{
			Off,
			On
		}

		internal const float DefaultUnderwaterDarknessFactor = 0.5f;

		internal const float DefaultUnderwaterVisibilityFalloff = 0.25f;

		internal static ConfigEntry<string> _waterEquipmentBlacklist = null;

		internal static ConfigEntry<float> _surfaceStaminaRegenRateMultiplier = null;

		internal static ConfigEntry<float> _midwaterStaminaRegenRateMultiplier = null;

		internal static ConfigEntry<float> _surfaceEitrRegenRateMultiplier = null;

		internal static ConfigEntry<float> _midwaterEitrRegenRateMultiplier = null;

		internal static ConfigEntry<float> _midwaterIdleStaminaDrainPerDepth = null;

		internal static ConfigEntry<float> _swimStaminaDrainMultiplierPerDepth = null;

		internal static ConfigEntry<Toggle> _multiplicativeSwimStaminaModifiers = null;

		internal static ConfigEntry<float> _swimStaminaDrainBaseMultiplier = null;

		internal static ConfigEntry<float> _playerSwimSkillSpeedMultiplier = null;

		internal static ConfigEntry<float> _fastSwimSpeedMultiplier = null;

		internal static ConfigEntry<float> _fastSwimStaminaDrainMultiplier = null;

		internal static ConfigEntry<float> _encumberedSwimSpeedMultiplier = null;

		internal static ConfigEntry<FastSwimInputMode> _fastSwimInputMode = null;

		internal static ConfigEntry<float> _playerProjectileUnderwaterTtlMultiplier = null;

		internal static ConfigEntry<float> _playerProjectileUnderwaterSpeedMultiplier = null;

		internal static ConfigEntry<float> _playerProjectileUnderwaterDamageMultiplier = null;

		internal static ConfigEntry<KeyboardShortcut> _playerDiveAscendShortcut = null;

		internal static ConfigEntry<KeyboardShortcut> _playerDiveDescendShortcut = null;

		internal static ConfigEntry<float> _underwaterDarknessFactor = null;

		internal static ConfigEntry<float> _underwaterVisibilityFalloff = null;

		private static (KeyboardShortcut Shortcut, string Text)? _ascendKeyHint;

		private static (KeyboardShortcut Shortcut, string Text)? _descendKeyHint;

		public const string Guid = "Zephyrfit.VikingSeafarer";

		public const string Version = "1.1.6";

		internal static ManualLogSource Log = null;

		internal static Plugin Instance = null;

		internal static ConfigSync Sync = new ConfigSync("Zephyrfit.VikingSeafarer")
		{
			DisplayName = "Viking Seafarer",
			CurrentVersion = "1.1.6",
			MinimumRequiredVersion = "1.1.6",
			ModRequired = true
		};

		private Harmony harmony;

		internal static ConfigEntry<bool> Diving = null;

		internal static ConfigEntry<bool> WaterCombat = null;

		internal static ConfigEntry<bool> RestrictRanged = null;

		internal static ConfigEntry<bool> Fishing = null;

		internal static ConfigEntry<bool> Anchoring = null;

		internal static ConfigEntry<bool> Chumming = null;

		internal static ConfigEntry<bool> Reboard = null;

		internal static ConfigEntry<bool> Hints = null;

		internal static ConfigEntry<float> AnchorSlack = null;

		internal static ConfigEntry<float> FearRadius = null;

		internal static ConfigEntry<float> ChumDuration = null;

		internal static ConfigEntry<float> ChumRadius = null;

		internal static ConfigEntry<float> ReelCost = null;

		internal static ConfigEntry<float> ReelSpeed = null;

		internal static ConfigEntry<float> BoatReelSpeed = null;

		internal static ConfigEntry<float> TetherRange = null;

		internal static ConfigEntry<float> ChumCooldown = null;

		internal static ConfigEntry<int> ChumFishLimit = null;

		internal static ConfigEntry<KeyboardShortcut> AnchorKey = null;

		internal static ConfigEntry<KeyboardShortcut> ChumKey = null;

		internal static ConfigEntry<KeyboardShortcut> SelectBaitKey = null;

		internal static ConfigEntry<KeyboardShortcut> ReleaseKey = null;

		internal static ConfigEntry<string> SpearProjectiles = null;

		internal static ConfigEntry<string> HarpoonProjectiles = null;

		internal static ConfigEntry<bool> ProtectedWaveImpacts = null;

		internal static ConfigEntry<bool> WaterAiming = null;

		internal static ConfigEntry<bool> LandAiming = null;

		internal static ConfigEntry<bool> ThrowPose = null;

		internal static ConfigEntry<float> WaterSpearSpeed = null;

		internal static ConfigEntry<float> AimChargeSeconds = null;

		internal static ConfigEntry<float> AimSpeedBonus = null;

		internal static ConfigEntry<float> CreaturePullSpeed = null;

		private ConfigEntry<bool> configLock;

		private float nextInput;

		private void InitializePlayerDiveConfig()
		{
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Expected O, but got Unknown
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Expected O, but got Unknown
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Expected O, but got Unknown
			//IL_011e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0129: Expected O, but got Unknown
			//IL_016d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0178: Expected O, but got Unknown
			//IL_01bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c7: Expected O, but got Unknown
			//IL_020b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0216: Expected O, but got Unknown
			//IL_0248: Unknown result type (might be due to invalid IL or missing references)
			//IL_0253: Expected O, but got Unknown
			//IL_0297: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a2: Expected O, but got Unknown
			//IL_02e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f1: Expected O, but got Unknown
			//IL_0335: Unknown result type (might be due to invalid IL or missing references)
			//IL_0340: Expected O, but got Unknown
			//IL_0384: Unknown result type (might be due to invalid IL or missing references)
			//IL_038f: Expected O, but got Unknown
			//IL_03d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_03de: Expected O, but got Unknown
			//IL_0422: Unknown result type (might be due to invalid IL or missing references)
			//IL_042d: Expected O, but got Unknown
			//IL_0471: Unknown result type (might be due to invalid IL or missing references)
			//IL_047c: Expected O, but got Unknown
			//IL_04c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_04cb: Expected O, but got Unknown
			//IL_04e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_050c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0517: Expected O, but got Unknown
			//IL_0531: Unknown result type (might be due to invalid IL or missing references)
			//IL_055b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0566: Expected O, but got Unknown
			//IL_0598: Unknown result type (might be due to invalid IL or missing references)
			//IL_05a3: Expected O, but got Unknown
			//IL_05e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_05f2: Expected O, but got Unknown
			//IL_0636: Unknown result type (might be due to invalid IL or missing references)
			//IL_0641: Expected O, but got Unknown
			_waterEquipmentBlacklist = config("2 - Player Diving", "Water Equipment Blacklist", "", new ConfigDescription("Comma-separated item prefab names that keep their own vanilla water restriction. Listed armor and accessories do not hide unrelated hand equipment. A listed hand item still uses vanilla hand-item hiding, which can stow both hands. Example: BowFineWood,ShieldBronzeBuckler.", (AcceptableValueBase)null, new object[1]
			{
				new ConfigurationManagerAttributes
				{
					Order = 100
				}
			}));
			_surfaceStaminaRegenRateMultiplier = config("3 - Regen Rate", "Surface Stamina Regen Rate", 0.5f, new ConfigDescription("Multiplier applied to vanilla stamina regeneration while swimming on the surface with your head above water. 0 matches vanilla swimming behavior, 1 matches normal non-swimming stamina regeneration timing and rate.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 1f), new object[1]
			{
				new ConfigurationManagerAttributes
				{
					Order = 110
				}
			}));
			_midwaterStaminaRegenRateMultiplier = config("3 - Regen Rate", "Midwater Stamina Regen Rate", 0f, new ConfigDescription("Multiplier applied to vanilla stamina regeneration while your head is underwater. 0 makes stamina recover only after surfacing.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 1f), new object[1]
			{
				new ConfigurationManagerAttributes
				{
					Order = 109
				}
			}));
			_surfaceEitrRegenRateMultiplier = config("3 - Regen Rate", "Surface Eitr Regen Rate", 0.7f, new ConfigDescription("Multiplier applied to vanilla eitr regeneration while swimming on the surface with your head above water. 0 disables eitr regeneration while surface swimming, 1 keeps vanilla eitr regeneration.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 1f), new object[1]
			{
				new ConfigurationManagerAttributes
				{
					Order = 108
				}
			}));
			_midwaterEitrRegenRateMultiplier = config("3 - Regen Rate", "Midwater Eitr Regen Rate", 0.3f, new ConfigDescription("Multiplier applied to vanilla eitr regeneration while your head is underwater. 0 makes eitr recover only after surfacing.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 1f), new object[1]
			{
				new ConfigurationManagerAttributes
				{
					Order = 107
				}
			}));
			_midwaterIdleStaminaDrainPerDepth = config("4 - Stamina Drain", "Midwater Idle Stamina Drain Per Depth", 0.02f, new ConfigDescription("Idle stamina drained per second per 1m of current liquid depth while your head is underwater. 0 disables idle underwater stamina drain. Example: 0.1 drains 3 stamina per second at 30m depth.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 1f), new object[1]
			{
				new ConfigurationManagerAttributes
				{
					Order = 109
				}
			}));
			_swimStaminaDrainMultiplierPerDepth = config("4 - Stamina Drain", "Swim Stamina Drain Multiplier Per Depth", 2.5f, new ConfigDescription("Additional moving swim stamina drain percent per 1m of current liquid depth. 1 means 30% extra at 30m; 2.5 means 75% extra at 30m. Applied multiplicatively with base and Fast Swim stamina drain.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 5f), new object[1]
			{
				new ConfigurationManagerAttributes
				{
					Order = 108
				}
			}));
			_multiplicativeSwimStaminaModifiers = config("4 - Stamina Drain", "Multiplicative Swim Stamina Modifiers", Toggle.On, new ConfigDescription("If on, status-effect swim stamina use modifiers stack multiplicatively during actual swim stamina consumption. Off is vanilla. Example: -50% and -60% leaves 20% cost instead of 0%. Tooltips keep vanilla display behavior.", (AcceptableValueBase)null, new object[1]
			{
				new ConfigurationManagerAttributes
				{
					Order = 110
				}
			}));
			_swimStaminaDrainBaseMultiplier = config("4 - Stamina Drain", "Swim Stamina Drain Base Multiplier", 1f, new ConfigDescription("Multiplier applied to vanilla moving swim stamina drain before depth and Fast Swim multipliers. 1 keeps vanilla cost, 0.5 halves it, 2 doubles it.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.1f, 2f), new object[1]
			{
				new ConfigurationManagerAttributes
				{
					Order = 107
				}
			}));
			_fastSwimSpeedMultiplier = config("5 - Swim Speed", "Fast Swim Speed Multiplier", 2f, new ConfigDescription("FR: Bonus de course uniquement en plongee ; vitesse de surface native. EN: Run-key swim multiplier underwater only; surface speed is unchanged.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(1f, 3f), new object[1]
			{
				new ConfigurationManagerAttributes
				{
					Order = 109
				}
			}));
			_fastSwimStaminaDrainMultiplier = config("5 - Swim Speed", "Fast Swim Stamina Drain Multiplier", 2f, new ConfigDescription("Moving swim stamina drain multiplier while Fast Swim is enabled. Applied multiplicatively with base and depth stamina drain.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(1f, 5f), new object[1]
			{
				new ConfigurationManagerAttributes
				{
					Order = 108
				}
			}));
			_playerSwimSkillSpeedMultiplier = config("5 - Swim Speed", "Swim Skill Speed Multiplier", 1.5f, new ConfigDescription("FR: Bonus de vitesse uniquement en plongee a Nage 100. EN: Underwater-only speed multiplier at Swim skill 100; no surface bonus.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(1f, 3f), new object[1]
			{
				new ConfigurationManagerAttributes
				{
					Order = 110
				}
			}));
			_encumberedSwimSpeedMultiplier = config("5 - Swim Speed", "Encumbered Swim Speed Multiplier", 0.5f, new ConfigDescription("FR: Ralentissement en surcharge uniquement en plongee. EN: Encumbered speed multiplier underwater only. Fast Swim is unavailable while encumbered.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.1f, 1f), new object[1]
			{
				new ConfigurationManagerAttributes
				{
					Order = 107
				}
			}));
			_playerProjectileUnderwaterTtlMultiplier = config("6 - Underwater Projectiles", "Player Projectile Underwater TTL Multiplier", 0.5f, new ConfigDescription("Lifetime multiplier applied to the initial player-owned projectile when fired underwater. Spawned child projectiles keep their own lifetime without another DiveIn multiplier. 1 keeps vanilla lifetime; lower values shorten underwater range.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.05f, 1f), new object[1]
			{
				new ConfigurationManagerAttributes
				{
					Order = 110
				}
			}));
			_playerProjectileUnderwaterSpeedMultiplier = config("6 - Underwater Projectiles", "Player Projectile Underwater Speed Multiplier", 0.5f, new ConfigDescription("Velocity multiplier applied to the initial player-owned projectile when fired underwater. Spawned child projectiles keep the velocity from the parent spawn logic without another DiveIn multiplier. 1 keeps vanilla speed; lower values slow underwater projectiles.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.05f, 1f), new object[1]
			{
				new ConfigurationManagerAttributes
				{
					Order = 109
				}
			}));
			_playerProjectileUnderwaterDamageMultiplier = config("6 - Underwater Projectiles", "Player Projectile Underwater Damage Multiplier", 0.5f, new ConfigDescription("Damage multiplier applied to the initial player-owned projectile when fired underwater. Inherited hit data keeps this multiplier; spawned child projectiles do not apply it again. 1 keeps vanilla damage; 0 removes the initial projectile's damage underwater.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 1f), new object[1]
			{
				new ConfigurationManagerAttributes
				{
					Order = 108
				}
			}));
			_playerDiveAscendShortcut = config<KeyboardShortcut>("2 - Player Diving", "Dive Ascend Key", new KeyboardShortcut((KeyCode)32, Array.Empty<KeyCode>()), new ConfigDescription("Client-side key used to ascend while swimming underwater.", (AcceptableValueBase)(object)new AcceptableShortcuts(), new object[1]
			{
				new ConfigurationManagerAttributes
				{
					Order = 110
				}
			}), synchronizedSetting: false);
			_playerDiveDescendShortcut = config<KeyboardShortcut>("2 - Player Diving", "Dive Descend Key", new KeyboardShortcut((KeyCode)306, Array.Empty<KeyCode>()), new ConfigDescription("Client-side key used to descend while swimming.", (AcceptableValueBase)(object)new AcceptableShortcuts(), new object[1]
			{
				new ConfigurationManagerAttributes
				{
					Order = 109
				}
			}), synchronizedSetting: false);
			_fastSwimInputMode = config("2 - Player Diving", "Fast Swim Input Mode", FastSwimInputMode.Press, new ConfigDescription("Client-side input behavior for Fast Swim. Press keeps Fast Swim active only while the vanilla run key is held. Toggle switches Fast Swim on or off whenever the vanilla run key is pressed.", (AcceptableValueBase)null, new object[1]
			{
				new ConfigurationManagerAttributes
				{
					Order = 108
				}
			}), synchronizedSetting: false);
			_underwaterDarknessFactor = config("2 - Player Diving", "Darkness Factor", 0.5f, new ConfigDescription("Underwater darkness added per meter of swim depth. 1 means 1% per meter, so 30m gives 30%.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 3f), new object[1]
			{
				new ConfigurationManagerAttributes
				{
					Order = 92
				}
			}));
			_underwaterVisibilityFalloff = config("2 - Player Diving", "Murkiness Factor", 0.25f, new ConfigDescription("Underwater fog density added per meter of swim depth. 1 means 1% per meter, so 30m adds 30%.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 3f), new object[1]
			{
				new ConfigurationManagerAttributes
				{
					Order = 91
				}
			}));
		}

		internal static float GetUnderwaterDarknessFactor()
		{
			return Mathf.Max(0f, _underwaterDarknessFactor.Value) * 0.01f;
		}

		internal static float GetUnderwaterVisibilityFalloff()
		{
			return Mathf.Max(0f, _underwaterVisibilityFalloff.Value) * 0.01f;
		}

		internal static bool IsSwimRunEnabled()
		{
			if (_fastSwimSpeedMultiplier != null)
			{
				return _fastSwimSpeedMultiplier.Value > 1.001f;
			}
			return false;
		}

		internal static bool UseFastSwimToggleInput()
		{
			ConfigEntry<FastSwimInputMode> fastSwimInputMode = _fastSwimInputMode;
			if (fastSwimInputMode == null)
			{
				return true;
			}
			return fastSwimInputMode.Value != FastSwimInputMode.Press;
		}

		internal static bool UseMultiplicativeSwimStaminaModifiers()
		{
			ConfigEntry<Toggle> multiplicativeSwimStaminaModifiers = _multiplicativeSwimStaminaModifiers;
			if (multiplicativeSwimStaminaModifiers == null)
			{
				return false;
			}
			return multiplicativeSwimStaminaModifiers.Value == Toggle.On;
		}

		internal static bool HasPlayerProjectileUnderwaterPenalty()
		{
			if (!(GetPlayerProjectileUnderwaterTtlMultiplier() < 0.999f) && !(GetPlayerProjectileUnderwaterSpeedMultiplier() < 0.999f))
			{
				return GetPlayerProjectileUnderwaterDamageMultiplier() < 0.999f;
			}
			return true;
		}

		internal static float GetPlayerProjectileUnderwaterTtlMultiplier()
		{
			return Mathf.Clamp(_playerProjectileUnderwaterTtlMultiplier?.Value ?? 1f, 0.05f, 1f);
		}

		internal static float GetPlayerProjectileUnderwaterSpeedMultiplier()
		{
			return Mathf.Clamp(_playerProjectileUnderwaterSpeedMultiplier?.Value ?? 1f, 0.05f, 1f);
		}

		internal static float GetPlayerProjectileUnderwaterDamageMultiplier()
		{
			return Mathf.Clamp01(_playerProjectileUnderwaterDamageMultiplier?.Value ?? 1f);
		}

		internal static bool IsDiveAscendInputHeld()
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			ConfigEntry<KeyboardShortcut> playerDiveAscendShortcut = _playerDiveAscendShortcut;
			if (playerDiveAscendShortcut == null || !playerDiveAscendShortcut.Value.IsKeyHeld())
			{
				return ZInput.GetButton("JoyJump");
			}
			return true;
		}

		internal static bool IsDiveDescendInputHeld()
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			ConfigEntry<KeyboardShortcut> playerDiveDescendShortcut = _playerDiveDescendShortcut;
			if (playerDiveDescendShortcut == null || !playerDiveDescendShortcut.Value.IsKeyHeld())
			{
				return ZInput.GetButton("JoyCrouch");
			}
			return true;
		}

		internal static string GetDiveAscendKeyHint()
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			if (ShouldShowGamepadKeyHints())
			{
				return GetBoundKeyHint("JoyJump", "A");
			}
			return FormatShortcutForKeyHint((KeyboardShortcut)(((??)_playerDiveAscendShortcut?.Value) ?? new KeyboardShortcut((KeyCode)32, Array.Empty<KeyCode>())), ref _ascendKeyHint);
		}

		internal static string GetDiveDescendKeyHint()
		{
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			if (ShouldShowGamepadKeyHints())
			{
				return GetBoundKeyHint("JoyCrouch", "B");
			}
			return FormatShortcutForKeyHint((KeyboardShortcut)(((??)_playerDiveDescendShortcut?.Value) ?? new KeyboardShortcut((KeyCode)306, Array.Empty<KeyCode>())), ref _descendKeyHint);
		}

		internal static string GetDiveRunKeyHint()
		{
			if (!ShouldShowGamepadKeyHints())
			{
				return GetBoundKeyHint("Run", "Left Shift");
			}
			return GetBoundKeyHint("JoyRun", "LT");
		}

		private static bool ShouldShowGamepadKeyHints()
		{
			return ZInput.IsGamepadActive();
		}

		private static string GetBoundKeyHint(string bindingName, string fallback)
		{
			ZInput instance = ZInput.instance;
			string text = ((instance != null) ? instance.GetBoundKeyString(bindingName, true) : null) ?? string.Empty;
			if (string.IsNullOrWhiteSpace(text))
			{
				return fallback;
			}
			if (Localization.instance == null)
			{
				return text;
			}
			return Localization.instance.Localize(text);
		}

		private static string FormatShortcutForKeyHint(KeyboardShortcut shortcut, ref (KeyboardShortcut Shortcut, string Text)? cache)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			return Text.Shortcut(shortcut);
		}

		private void Awake()
		{
			//IL_0209: Unknown result type (might be due to invalid IL or missing references)
			//IL_0214: Expected O, but got Unknown
			//IL_0318: Unknown result type (might be due to invalid IL or missing references)
			//IL_0348: Unknown result type (might be due to invalid IL or missing references)
			//IL_0378: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_053a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0544: Expected O, but got Unknown
			Instance = this;
			Log = ((BaseUnityPlugin)this).Logger;
			configLock = config("1 - General", "Lock Configuration", value: true, "FR: Configuration imposee par le serveur. EN: Server-enforced configuration.");
			Sync.AddLockingConfigEntry<bool>(configLock);
			Diving = config("1 - General", "Diving", value: true, "FR: Activer la plongee. EN: Enable diving.");
			WaterCombat = config("1 - General", "Water Combat", value: true, "FR: Armes dans l'eau. EN: Equipment in water.");
			RestrictRanged = config("1 - General", "Restrict Ranged And Magic", value: true, "FR: Interdire arcs/arbaletes/magie dans l'eau. EN: Block bows, crossbows and magic in water.");
			Fishing = config("1 - General", "Spear Fishing", value: true, "FR: Chasse sous-marine. EN: Spear and harpoon fishing.");
			Anchoring = config("1 - General", "Anchoring", value: true, "FR: Ancrage sans poteau. EN: Anchor anywhere.");
			Chumming = config("1 - General", "Chumming", value: true, "FR: Amorcage avec les appats existants. EN: Chum with existing bait.");
			Reboard = config("7 - Anchor", "Restore Deck Position", value: true, "FR: Retrouver le pont proche a la reconnexion si le bateau est toujours ancre. EN: Restore nearby anchored deck on reconnect.");
			ProtectedWaveImpacts = config("7 - Anchor", "Protect Wave Slams", value: false, "FR: Annuler uniquement les degats de vagues du bateau ancre. EN: Prevent anchored wave slam damage only.");
			AnchorSlack = Number("7 - Anchor", "Slack Metres", 0.5f, 0.1f, 3f, "FR: Jeu horizontal de l'ancre. EN: Horizontal anchor slack.");
			FearRadius = Number("8 - Fishing", "Fear Radius", 6f, 1f, 15f, "FR: Distance de fuite de base. EN: Base fish flee distance.");
			ChumDuration = Number("8 - Fishing", "Chum Duration", 25f, 5f, 90f, "FR: Duree de l'amorcage en secondes. EN: Chum duration, seconds.");
			ChumRadius = Number("8 - Fishing", "Chum Radius", 7f, 2f, 15f, "FR: Rayon d'attraction. EN: Attraction radius.");
			ChumCooldown = Number("8 - Fishing", "Chum Cooldown", 30f, 5f, 120f, "FR: Delai entre amorcages. EN: Chum cooldown.");
			ChumFishLimit = config("8 - Fishing", "Chum Fish Limit", 2, new ConfigDescription("FR: Nombre maximal de poissons par amorcage. EN: Maximum selected fish per chum.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(1, 5), Array.Empty<object>()));
			ReelCost = Number("8 - Fishing", "Reel Stamina Per Second", 5f, 1f, 20f, "FR: Cout de traction, augmente avec le niveau du poisson. EN: Reeling stamina, scaled by fish level.");
			ReelSpeed = Number("8 - Fishing", "Reel Metres Per Second", 2.8f, 0.5f, 4f, "FR: Vitesse de traction de base. EN: Base reeling speed.");
			BoatReelSpeed = Number("8 - Fishing", "Boat Reel Metres Per Second", 5f, 0.5f, 8f, "FR: Vitesse de traction depuis un bateau, reduite selon la taille du poisson. EN: Fish reeling speed from a boat, reduced by fish size.");
			TetherRange = Number("8 - Fishing", "Maximum Tether Range", 15f, 4f, 30f, "FR: Distance de rupture. EN: Tether break distance.");
			SpearProjectiles = config("8 - Fishing", "Additional Spear Projectiles", "", "FR: Prefabs supplementaires separes par virgules. EN: Extra spear projectile prefab names.");
			HarpoonProjectiles = config("8 - Fishing", "Additional Harpoon Projectiles", "", "FR: Prefabs supplementaires separes par virgules. EN: Extra harpoon projectile prefab names.");
			AnchorKey = config<KeyboardShortcut>("9 - Controls", "Anchor", new KeyboardShortcut((KeyCode)103, (KeyCode[])(object)new KeyCode[1] { (KeyCode)308 }), "FR: Regarder le gouvernail ou le tenir. EN: Look at or use rudder.", synchronizedSetting: false);
			ChumKey = config<KeyboardShortcut>("9 - Controls", "Chum", new KeyboardShortcut((KeyCode)98, (KeyCode[])(object)new KeyCode[1] { (KeyCode)308 }), "FR: Amorcer dans l'eau visee. EN: Chum aimed water.", synchronizedSetting: false);
			SelectBaitKey = config<KeyboardShortcut>("9 - Controls", "Select Bait", new KeyboardShortcut((KeyCode)110, (KeyCode[])(object)new KeyCode[1] { (KeyCode)308 }), "FR: Choisir l'appat suivant. EN: Select next bait.", synchronizedSetting: false);
			ReleaseKey = config<KeyboardShortcut>("9 - Controls", "Release Fish", new KeyboardShortcut((KeyCode)114, (KeyCode[])(object)new KeyCode[1] { (KeyCode)308 }), "FR: Liberer le poisson. EN: Release tethered fish.", synchronizedSetting: false);
			Hints = config("9 - Controls", "Show Hints", value: true, "FR: Aide compacte en jeu. EN: Compact in-game hints.", synchronizedSetting: false);
			WaterAiming = config("8 - Fishing", "Water Aim", value: true, "FR: Viser dans l'eau : lance sans bouclier ou harpon. EN: Aim in water: spear without shield or harpoon.");
			LandAiming = config("8 - Fishing", "Land Aim", value: true, "FR: Visee lance sans bouclier / harpon a terre et sur le pont. EN: Aim spears without a shield / harpoons on land and deck.");
			ThrowPose = config("8 - Fishing", "Throw Aim Pose", value: true, "FR: Posture de preparation au lancer. EN: Raised-arm throw preparation pose.");
			WaterSpearSpeed = Number("8 - Fishing", "Spear Water Speed", 0.8f, 0.5f, 1f, "FR: Vitesse conservee par lance/harpon sous l'eau. EN: Spear/harpoon speed retained underwater.");
			AimChargeSeconds = Number("8 - Fishing", "Aim Charge Seconds", 0.65f, 0.2f, 2f, "FR: Temps pour stabiliser le lancer. EN: Time to steady a throw.");
			AimSpeedBonus = Number("8 - Fishing", "Aimed Throw Speed Bonus", 1.25f, 1f, 1.5f, "FR: Multiplicateur maximal de vitesse apres visee, sans bonus de degats. EN: Maximum aimed velocity multiplier, no damage bonus.");
			CreaturePullSpeed = Number("8 - Fishing", "Creature Pull Speed Multiplier", 1.5f, 1f, 2f, "FR: Traction du harpon natif sur les creatures. EN: Native harpoon reeling speed on creatures.");
			ConfigEntry<int> val = config("0 - Migration", "Configuration Revision", 0, "Internal configuration migration version.", synchronizedSetting: false);
			if (val.Value < 1)
			{
				if (Mathf.Approximately(ReelSpeed.Value, 1.7f))
				{
					ReelSpeed.Value = 2.8f;
				}
				val.Value = 1;
				((BaseUnityPlugin)this).Config.Save();
			}
			InitializePlayerDiveConfig();
			Compatibility.Initialize();
			harmony = new Harmony("Zephyrfit.VikingSeafarer");
			try
			{
				harmony.PatchAll(typeof(Plugin).Assembly);
			}
			catch
			{
				harmony.UnpatchSelf();
				throw;
			}
			Log.LogInfo((object)("Viking Seafarer 1.1.6: all clients + server required. FirstPersonMode=" + Compatibility.HasFirstPerson));
		}

		private ConfigEntry<float> Number(string group, string key, float def, float min, float max, string desc)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Expected O, but got Unknown
			return config(group, key, def, new ConfigDescription(desc, (AcceptableValueBase)(object)new AcceptableValueRange<float>(min, max), Array.Empty<object>()));
		}

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

		private ConfigEntry<T> config<T>(string group, string key, T value, ConfigDescription desc, bool synchronizedSetting = true)
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Expected O, but got Unknown
			ConfigEntry<T> val = ((BaseUnityPlugin)this).Config.Bind<T>(group, key, value, new ConfigDescription(desc.Description + (synchronizedSetting ? " [Synced with Server]" : " [Local]"), desc.AcceptableValues, desc.Tags));
			Sync.AddConfigEntry<T>(val).SynchronizedConfig = synchronizedSetting;
			return val;
		}

		private void Update()
		{
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0132: Unknown result type (might be due to invalid IL or missing references)
			//IL_0137: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			Player localPlayer = Player.m_localPlayer;
			if (!Object.op_Implicit((Object)(object)localPlayer) || !Object.op_Implicit((Object)(object)((Character)localPlayer).m_nview) || !((Character)localPlayer).m_nview.IsValid())
			{
				return;
			}
			if (!Diving.Value && (Object)(object)PlayerDiveController.LocalInstance != (Object)null)
			{
				PlayerDiveController.LocalInstance.DisableUnderwaterMovement();
			}
			FishingSystem.PublishReel(localPlayer);
			if (!((Character)localPlayer).TakeInput() || ((Character)localPlayer).IsDead() || Time.unscaledTime < nextInput)
			{
				return;
			}
			KeyboardShortcut value;
			if (Anchoring.Value)
			{
				value = AnchorKey.Value;
				if (((KeyboardShortcut)(ref value)).IsDown())
				{
					nextInput = Time.unscaledTime + 0.25f;
					AnchorSystem.ToggleLocal(localPlayer);
				}
			}
			if (Fishing.Value)
			{
				value = SelectBaitKey.Value;
				if (((KeyboardShortcut)(ref value)).IsDown())
				{
					nextInput = Time.unscaledTime + 0.25f;
					FishingSystem.SelectBait(localPlayer);
				}
			}
			if (Fishing.Value && Chumming.Value)
			{
				value = ChumKey.Value;
				if (((KeyboardShortcut)(ref value)).IsDown())
				{
					nextInput = Time.unscaledTime + 0.25f;
					FishingSystem.Chum(localPlayer);
				}
			}
			if (Fishing.Value)
			{
				value = ReleaseKey.Value;
				if (((KeyboardShortcut)(ref value)).IsDown())
				{
					FishingSystem.ReleaseLocal(localPlayer);
				}
			}
		}

		private void OnGUI()
		{
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0151: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01af: Expected O, but got Unknown
			//IL_01d5: Unknown result type (might be due to invalid IL or missing references)
			WaterThrowAim.Draw();
			Player localPlayer = Player.m_localPlayer;
			if (Hints.Value && Object.op_Implicit((Object)(object)localPlayer) && !((Character)localPlayer).IsDead() && ((Character)localPlayer).TakeInput() && (((Character)localPlayer).InWater() || Object.op_Implicit((Object)(object)Ship.GetLocalShip())))
			{
				string text = Text.T("Ancre ", "Anchor ") + Text.Shortcut(AnchorKey.Value) + "  |  " + Text.T("Appât ", "Bait ") + Text.Shortcut(SelectBaitKey.Value) + "  |  " + Text.T("Amorcer ", "Chum ") + Text.Shortcut(ChumKey.Value);
				if (((Character)localPlayer).InWater())
				{
					text = text + "\n" + Text.T("Descendre : ", "Descend: ") + GetDiveDescendKeyHint() + "  |  " + Text.T("Monter : ", "Ascend: ") + GetDiveAscendKeyHint();
				}
				if ((Object)(object)FishingSystem.LocalTether(localPlayer) != (Object)null)
				{
					text = text + "\n" + Text.T("Maintenir Attaque pour ramener • Libérer : ", "Hold Attack to reel • Release: ") + Text.Shortcut(ReleaseKey.Value);
				}
				Ship val = AnchorSystem.Target(localPlayer) ?? Ship.GetLocalShip();
				if (Anchoring.Value && (Object)(object)val != (Object)null)
				{
					text = text + "\n" + AnchorSystem.Hint(val);
				}
				GUIStyle val2 = new GUISt