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

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: AssemblyCompany("WingsoftheValkyrie")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyDescription("Valheim Wings of the Valkyrie Mod")]
[assembly: AssemblyFileVersion("2.2.1.0")]
[assembly: AssemblyInformationalVersion("2.2.1+b00be47ed25ba9a6d38606bc33109cde738e1213")]
[assembly: AssemblyProduct("WingsoftheValkyrie")]
[assembly: AssemblyTitle("WingsoftheValkyrie")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("2.2.1.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 var value))
					{
						value = new SortedDictionary<int, byte[]>();
						configValueCache[text2] = value;
						cacheExpirations.Add(new KeyValuePair<long, string>(DateTimeOffset.Now.AddSeconds(60.0).Ticks, text2));
					}
					int key = package.ReadInt();
					int num2 = package.ReadInt();
					value.Add(key, package.ReadByteArray());
					if (value.Count < num2)
					{
						return false;
					}
					configValueCache.Remove(text2);
					package = new ZPackage(value.Values.SelectMany((byte[] a) => a).ToArray());
					b = package.ReadByte();
				}
				ProcessingServerUpdate = true;
				if ((b & 4) != 0)
				{
					MemoryStream stream = new MemoryStream(package.ReadByteArray());
					MemoryStream memoryStream = new MemoryStream();
					using (DeflateStream deflateStream = new DeflateStream(stream, CompressionMode.Decompress))
					{
						deflateStream.CopyTo(memoryStream);
					}
					package = new ZPackage(memoryStream.ToArray());
					b = package.ReadByte();
				}
				if ((b & 1) == 0)
				{
					resetConfigsFromServer();
				}
				ParsedConfigs parsedConfigs = ReadConfigsFromPackage(package);
				ConfigFile val2 = null;
				bool saveOnConfigSet = false;
				foreach (KeyValuePair<OwnConfigEntryBase, object> configValue in parsedConfigs.configValues)
				{
					if (!isServer && configValue.Key.LocalBaseValue == null)
					{
						configValue.Key.LocalBaseValue = configValue.Key.BaseConfig.BoxedValue;
					}
					if (val2 == null)
					{
						val2 = configValue.Key.BaseConfig.ConfigFile;
						saveOnConfigSet = val2.SaveOnConfigSet;
						val2.SaveOnConfigSet = false;
					}
					configValue.Key.BaseConfig.BoxedValue = configValue.Value;
				}
				if (val2 != null)
				{
					val2.SaveOnConfigSet = saveOnConfigSet;
					val2.Save();
				}
				foreach (KeyValuePair<CustomSyncedValueBase, object> customValue in parsedConfigs.customValues)
				{
					if (!isServer)
					{
						CustomSyncedValueBase key2 = customValue.Key;
						if (key2.LocalBaseValue == null)
						{
							key2.LocalBaseValue = customValue.Key.BoxedValue;
						}
					}
					customValue.Key.BoxedValue = customValue.Value;
				}
				Debug.Log((object)string.Format("Received {0} configs and {1} custom values from {2} for mod {3}", parsedConfigs.configValues.Count, parsedConfigs.customValues.Count, (isServer || clientUpdate) ? $"client {sender}" : "the server", DisplayName ?? Name));
				if (!isServer)
				{
					serverLockedSettingChanged();
				}
				return true;
			}
			finally
			{
				ProcessingServerUpdate = false;
			}
		}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

		private static readonly Dictionary<string, string> notProcessedNames;

		public string Name;

		private string? displayName;

		private string? currentVersion;

		private string? minimumRequiredVersion;

		public bool ModRequired = true;

		private string? ReceivedCurrentVersion;

		private string? ReceivedMinimumRequiredVersion;

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

		private ConfigSync? ConfigSync;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

		private const string TrinketSlotName = "$azu_epi_trinket";

		private const string BackSlotName = "$azu_epi_shoulder";

		private static MethodInfo _tryGetSlotIndexByName;

		private static MethodInfo _tryGetSlotIndexAtGridPos;

		public static bool Active { get; private set; }

		public static void Init(Harmony harmony)
		{
			//IL_0130: Unknown result type (might be due to invalid IL or missing references)
			//IL_013d: Expected O, but got Unknown
			//IL_01b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e3: Expected O, but got Unknown
			//IL_01e3: Expected O, but got Unknown
			if (harmony == null || !Chainloader.PluginInfos.ContainsKey("Azumatt.AzuExtendedPlayerInventory"))
			{
				return;
			}
			try
			{
				Type type = AccessTools.TypeByName("AzuEPI.API");
				MethodInfo methodInfo = ((type == null) ? null : AccessTools.Method(type, "SlotValidates", new Type[2]
				{
					typeof(int),
					typeof(ItemData)
				}, (Type[])null));
				_tryGetSlotIndexByName = ((type == null) ? null : AccessTools.Method(type, "TryGetSlotIndexByName", new Type[3]
				{
					typeof(string),
					typeof(int).MakeByRefType(),
					typeof(bool)
				}, (Type[])null));
				_tryGetSlotIndexAtGridPos = ((type == null) ? null : AccessTools.Method(type, "TryGetSlotIndexAtGridPos", new Type[3]
				{
					typeof(Inventory),
					typeof(Vector2i),
					typeof(int).MakeByRefType()
				}, (Type[])null));
				if (methodInfo == null || _tryGetSlotIndexByName == null)
				{
					Log.LogWarning("AzuExtendedPlayerInventory is loaded but its slot API is not the one this build knows (2.5.x), so the wings' trinket-slot compatibility is off. Its layout repair may move wings worn as a trinket out of its trinket cell.");
					return;
				}
				harmony.Patch((MethodBase)methodInfo, (HarmonyMethod)null, new HarmonyMethod(typeof(AzuEpiCompat), "SlotValidatesPostfix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				MethodInfo methodInfo2 = AccessTools.Method(typeof(InventoryGrid), "DropItem", new Type[4]
				{
					typeof(Inventory),
					typeof(ItemData),
					typeof(int),
					typeof(Vector2i)
				}, (Type[])null);
				if (_tryGetSlotIndexAtGridPos != null && methodInfo2 != null)
				{
					harmony.Patch((MethodBase)methodInfo2, new HarmonyMethod(typeof(AzuEpiCompat), "DropItemPrefix", (Type[])null)
					{
						priority = 200
					}, new HarmonyMethod(typeof(AzuEpiCompat), "DropItemPostfix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				}
				Active = true;
				Log.LogInfo("AzuExtendedPlayerInventory found: its trinket cell takes the wings whenever WingsSlot allows it, and a drag onto its trinket or back cell chooses the slot.");
			}
			catch (Exception ex)
			{
				Log.LogWarning("Could not bind to AzuExtendedPlayerInventory (" + ex.Message + "); the wings' trinket-slot compatibility is off.");
			}
		}

		private static int SlotIndex(string originalName)
		{
			if (_tryGetSlotIndexByName == null)
			{
				return -1;
			}
			try
			{
				object[] array = new object[3] { originalName, -1, true };
				return ((bool)_tryGetSlotIndexByName.Invoke(null, array)) ? ((int)array[1]) : (-1);
			}
			catch
			{
				return -1;
			}
		}

		private static int SlotIndexAt(Inventory inventory, Vector2i pos)
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			if (_tryGetSlotIndexAtGridPos == null || inventory == null)
			{
				return -1;
			}
			try
			{
				object[] array = new object[3] { inventory, pos, -1 };
				return ((bool)_tryGetSlotIndexAtGridPos.Invoke(null, array)) ? ((int)array[2]) : (-1);
			}
			catch
			{
				return -1;
			}
		}

		private static void SlotValidatesPostfix(int slotIndex, ItemData item, ref bool __result)
		{
			if (!__result && slotIndex >= 0 && WingsItem.IsWings(item) && slotIndex == SlotIndex("$azu_epi_trinket"))
			{
				__result = WingsSlot.MayUseTrinketSlot(item);
			}
		}

		private static void DropItemPrefix(InventoryGrid __instance, ItemData item, Vector2i pos, bool __runOriginal)
		{
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			if (!__runOriginal || !WingsItem.IsWings(item) || (Object)(object)Player.m_localPlayer == (Object)null)
			{
				return;
			}
			Inventory inventory = ((Humanoid)Player.m_localPlayer).GetInventory();
			if (inventory == null || __instance.GetInventory() != inventory)
			{
				return;
			}
			int num = SlotIndexAt(inventory, pos);
			if (num >= 0)
			{
				if (num == SlotIndex("$azu_epi_trinket"))
				{
					WingsSlot.NoteDragTarget(item, WingsSlotChoice.Trinket);
				}
				else if (num == SlotIndex("$azu_epi_shoulder"))
				{
					WingsSlot.NoteDragTarget(item, WingsSlotChoice.Back);
				}
			}
		}

		private static void DropItemPostfix(ItemData item, bool __result)
		{
			if (!__result && WingsItem.IsWings(item))
			{
				WingsSlot.ForgetDragTarget(item);
			}
		}
	}
	[HarmonyPatch]
	public static class CapeVisualPatch
	{
		private static readonly FieldRef<VisEquipment, List<GameObject>> ShoulderInstancesRef = ReflectionUtil.TryFieldRef<VisEquipment, List<GameObject>>("m_shoulderItemInstances");

		private static readonly FieldRef<VisEquipment, List<GameObject>> TrinketInstancesRef = ReflectionUtil.TryFieldRef<VisEquipment, List<GameObject>>("m_trinketItemInstances");

		[HarmonyPatch(typeof(VisEquipment), "AttachArmor")]
		[HarmonyPrefix]
		public static bool AttachArmorPrefix(int itemHash, ref List<GameObject> __result)
		{
			if (!WingsItem.IsWingsHash(itemHash))
			{
				return true;
			}
			__result = new List<GameObject>();
			return false;
		}

		[HarmonyPatch(typeof(VisEquipment), "SetShoulderEquipped")]
		[HarmonyPostfix]
		[HarmonyPriority(0)]
		public static void SetShoulderEquippedPostfix(VisEquipment __instance, int hash)
		{
			HideInstances(ShoulderInstancesRef, __instance, hash);
		}

		[HarmonyPatch(typeof(VisEquipment), "SetTrinketEquipped")]
		[HarmonyPostfix]
		[HarmonyPriority(0)]
		public static void SetTrinketEquippedPostfix(VisEquipment __instance, int hash)
		{
			HideInstances(TrinketInstancesRef, __instance, hash);
		}

		private static void HideInstances(FieldRef<VisEquipment, List<GameObject>> instancesRef, VisEquipment visEq, int hash)
		{
			if (instancesRef == null || !WingsItem.IsWingsHash(hash))
			{
				return;
			}
			List<GameObject> list = instancesRef.Invoke(visEq);
			if (list == null)
			{
				return;
			}
			for (int i = 0; i < list.Count; i++)
			{
				if ((Object)(object)list[i] != (Object)null)
				{
					list[i].SetActive(false);
				}
			}
		}
	}
	public static class ConfigMigration
	{
		public sealed class Rebase
		{
			public string Section;

			public string Key;

			public string[] OldDefaults;
		}

		public const int CurrentConfigVersion = 3;

		private static readonly Dictionary<int, Rebase[]> Rebases = new Dictionary<int, Rebase[]>
		{
			{
				1,
				new Rebase[9]
				{
					new Rebase
					{
						Section = "2. Crude Wings",
						Key = "MinStationLevel",
						OldDefaults = new string[1] { "1" }
					},
					new Rebase
					{
						Section = "2. Crude Wings",
						Key = "CraftingRequirements",
						OldDefaults = new string[1] { "Feathers:10,LeatherScraps:10" }
					},
					new Rebase
					{
						Section = "3. Troll Wings",
						Key = "MinStationLevel",
						OldDefaults = new string[1] { "2" }
					},
					new Rebase
					{
						Section = "3. Troll Wings",
						Key = "CraftingRequirements",
						OldDefaults = new string[1] { "TrollHide:5,Feathers:15" }
					},
					new Rebase
					{
						Section = "4. Lox Wings",
						Key = "MinStationLevel",
						OldDefaults = new string[1] { "1" }
					},
					new Rebase
					{
						Section = "4. Lox Wings",
						Key = "CraftingRequirements",
						OldDefaults = new string[1] { "LoxPelt:5,Silver:5" }
					},
					new Rebase
					{
						Section = "5. Dragon Wings",
						Key = "CraftingRequirements",
						OldDefaults = new string[1] { "Feathers:20,Eitr:5" }
					},
					new Rebase
					{
						Section = "6. Valkyrie Flight Skill",
						Key = "XpPerFlap",
						OldDefaults = new string[1] { "0.5" }
					},
					new Rebase
					{
						Section = "6. Valkyrie Flight Skill",
						Key = "XpPerGlideSecond",
						OldDefaults = new string[1] { "0.25" }
					}
				}
			},
			{
				2,
				new Rebase[20]
				{
					new Rebase
					{
						Section = "2. Crude Wings",
						Key = "FlightCeiling",
						OldDefaults = new string[1] { "120" }
					},
					new Rebase
					{
						Section = "2. Crude Wings",
						Key = "GlideSpeed",
						OldDefaults = new string[1] { "10" }
					},
					new Rebase
					{
						Section = "2. Crude Wings",
						Key = "FlapForce",
						OldDefaults = new string[1] { "15" }
					},
					new Rebase
					{
						Section = "2. Crude Wings",
						Key = "FlapStaminaCost",
						OldDefaults = new string[1] { "10" }
					},
					new Rebase
					{
						Section = "3. Troll Wings",
						Key = "FlightCeiling",
						OldDefaults = new string[1] { "135" }
					},
					new Rebase
					{
						Section = "3. Troll Wings",
						Key = "GlideSpeed",
						OldDefaults = new string[1] { "15" }
					},
					new Rebase
					{
						Section = "3. Troll Wings",
						Key = "FlapForce",
						OldDefaults = new string[1] { "18" }
					},
					new Rebase
					{
						Section = "3. Troll Wings",
						Key = "FlapStaminaCost",
						OldDefaults = new string[1] { "8" }
					},
					new Rebase
					{
						Section = "4. Lox Wings",
						Key = "FlightCeiling",
						OldDefaults = new string[1] { "160" }
					},
					new Rebase
					{
						Section = "4. Lox Wings",
						Key = "GlideSpeed",
						OldDefaults = new string[1] { "20" }
					},
					new Rebase
					{
						Section = "4. Lox Wings",
						Key = "FlapForce",
						OldDefaults = new string[1] { "22" }
					},
					new Rebase
					{
						Section = "4. Lox Wings",
						Key = "FlapStaminaCost",
						OldDefaults = new string[1] { "6" }
					},
					new Rebase
					{
						Section = "5. Dragon Wings",
						Key = "FlightCeiling",
						OldDefaults = new string[1] { "1100" }
					},
					new Rebase
					{
						Section = "5. Dragon Wings",
						Key = "GlideSpeed",
						OldDefaults = new string[1] { "30" }
					},
					new Rebase
					{
						Section = "5. Dragon Wings",
						Key = "FlapForce",
						OldDefaults = new string[1] { "28" }
					},
					new Rebase
					{
						Section = "5. Dragon Wings",
						Key = "FlapStaminaCost",
						OldDefaults = new string[1] { "4" }
					},
					new Rebase
					{
						Section = "6. Valkyrie Flight Skill",
						Key = "StaminaReductionAtMax",
						OldDefaults = new string[1] { "0.5" }
					},
					new Rebase
					{
						Section = "6. Valkyrie Flight Skill",
						Key = "FlapPowerBonusAtMax",
						OldDefaults = new string[1] { "0.3" }
					},
					new Rebase
					{
						Section = "6. Valkyrie Flight Skill",
						Key = "GlideSinkReductionAtMax",
						OldDefaults = new string[1] { "0.5" }
					},
					new Rebase
					{
						Section = "6. Valkyrie Flight Skill",
						Key = "GlideSpeedBonusAtMax",
						OldDefaults = new string[1] { "0.15" }
					}
				}
			},
			{
				3,
				new Rebase[2]
				{
					new Rebase
					{
						Section = "2. Crude Wings",
						Key = "MinStationLevel",
						OldDefaults = new string[1] { "3" }
					},
					new Rebase
					{
						Section = "3. Troll Wings",
						Key = "MinStationLevel",
						OldDefaults = new string[1] { "3" }
					}
				}
			}
		};

		private static readonly Dictionary<string, string> Snapshot = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);

		private static readonly List<ConfigDefinition> Pending = new List<ConfigDefinition>();

		private static int _fileVersion;

		private static string Slot(string section, string key)
		{
			return section + "::" + key;
		}

		public static void Begin(ConfigFile config)
		{
			Snapshot.Clear();
			Pending.Clear();
			_fileVersion = 3;
			try
			{
				string configFilePath = config.ConfigFilePath;
				if (File.Exists(configFilePath))
				{
					ReadRaw(configFilePath, Snapshot);
					_fileVersion = ReadStampedVersion(Snapshot);
					if (_fileVersion < 3)
					{
						Backup(configFilePath, _fileVersion);
						Log.LogWarning($"Migrating {Path.GetFileName(configFilePath)} from config version {_fileVersion} to {3}. Values you changed are kept; values still at their old defaults move to the new ones. The previous file is backed up beside it.");
						PlanRebases();
					}
				}
			}
			catch (Exception arg)
			{
				Log.LogError($"Config migration could not start, settings will be read as-is. Reason: {arg}");
			}
		}

		private static void PlanRebases()
		{
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Expected O, but got Unknown
			for (int i = _fileVersion + 1; i <= 3; i++)
			{
				if (!Rebases.TryGetValue(i, out var value))
				{
					continue;
				}
				Rebase[] array = value;
				foreach (Rebase rebase in array)
				{
					if (!Snapshot.TryGetValue(Slot(rebase.Section, rebase.Key), out var value2))
					{
						continue;
					}
					bool flag = false;
					string[] oldDefaults = rebase.OldDefaults;
					foreach (string b in oldDefaults)
					{
						if (string.Equals(value2.Trim(), b, StringComparison.Ordinal))
						{
							flag = true;
							break;
						}
					}
					if (flag)
					{
						Pending.Add(new ConfigDefinition(rebase.Section, rebase.Key));
						Log.LogInfo("[" + rebase.Section + "] " + rebase.Key + " was still the old default; moving it to the new default.");
					}
					else
					{
						Log.LogInfo("[" + rebase.Section + "] " + rebase.Key + " was customised ('" + value2 + "'); keeping your value.");
					}
				}
			}
		}

		public static void Finish(ConfigFile config, ConfigEntry<int> versionEntry)
		{
			try
			{
				foreach (ConfigDefinition item in Pending)
				{
					if (config.ContainsKey(item))
					{
						ConfigEntryBase obj = config[item];
						obj.BoxedValue = obj.DefaultValue;
					}
				}
				if (versionEntry != null)
				{
					versionEntry.Value = 3;
				}
				config.Save();
			}
			catch (Exception arg)
			{
				Log.LogError($"Config migration could not finish - check the backup beside your config file. Reason: {arg}");
			}
			finally
			{
				Snapshot.Clear();
				Pending.Clear();
			}
		}

		private static void Backup(string path, int fromVersion)
		{
			try
			{
				File.Copy(path, path + $".v{fromVersion}.bak", overwrite: true);
			}
			catch (Exception ex)
			{
				Log.LogError("Could not back up the config before migrating (" + ex.Message + "). Migrating anyway.");
			}
		}

		private static int ReadStampedVersion(Dictionary<string, string> snapshot)
		{
			if (snapshot.TryGetValue(Slot("0. Meta", "ConfigVersion"), out var value) && int.TryParse(value, out var result))
			{
				return result;
			}
			return 0;
		}

		private static void ReadRaw(string path, Dictionary<string, string> into)
		{
			string section = "";
			string[] array = File.ReadAllLines(path);
			for (int i = 0; i < array.Length; i++)
			{
				string text = array[i].Trim();
				if (text.Length == 0 || text[0] == '#')
				{
					continue;
				}
				if (text[0] == '[' && text[text.Length - 1] == ']')
				{
					section = text.Substring(1, text.Length - 2).Trim();
					continue;
				}
				int num = text.IndexOf('=');
				if (num > 0)
				{
					string text2 = text.Substring(0, num).Trim();
					string value = text.Substring(num + 1).Trim();
					if (text2.Length != 0)
					{
						into[Slot(section, text2)] = value;
					}
				}
			}
		}
	}
	[HarmonyPatch(typeof(Player))]
	public static class FlightController
	{
		private static readonly int ZdoGliding = StringExtensionMethods.GetStableHashCode("wotv_gliding");

		private static readonly int ZdoFlapCount = StringExtensionMethods.GetStableHashCode("wotv_flapcount");

		private static readonly int ZdoWings = StringExtensionMethods.GetStableHashCode("wotv_wings");

		[HarmonyPatch("Update")]
		[HarmonyPostfix]
		public static void UpdatePostfix(Player __instance)
		{
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			if (!ModConfig.EnableMod.Value)
			{
				return;
			}
			try
			{
				RuneWingVFX runeWingVFX = ((Component)__instance).GetComponent<RuneWingVFX>();
				if ((Object)(object)runeWingVFX == (Object)null)
				{
					runeWingVFX = ((Component)__instance).gameObject.AddComponent<RuneWingVFX>();
				}
				bool flag = (Object)(object)__instance == (Object)(object)Player.m_localPlayer;
				if (flag)
				{
					WingsSlot.Tick(__instance);
				}
				string text = (flag ? WingsItem.GetEquippedWingsName(__instance) : ReadRemoteWings(__instance, runeWingVFX));
				if (text == null)
				{
					runeWingVFX.IsGlidingLocal = false;
					if (flag)
					{
						FlightLog.Tick(__instance, gliding: false, null, Time.deltaTime);
					}
				}
				else
				{
					runeWingVFX.SetTierColor(GetTierColor(text));
					if (flag)
					{
						UpdateLocalGlide(__instance, runeWingVFX, text);
						FlyingSkill.AccumulateGlideXP(__instance, runeWingVFX.IsGlidingLocal, Time.deltaTime);
						FlightLog.Tick(__instance, runeWingVFX.IsGlidingLocal, text, Time.deltaTime);
					}
					else
					{
						ReadRemoteState(__instance, runeWingVFX);
					}
				}
				if (flag)
				{
					PublishState(runeWingVFX, text);
				}
				runeWingVFX.SetGlidingState(runeWingVFX.IsGlidingLocal);
			}
			catch (Exception ex)
			{
				Log.LogWarning("Error in UpdatePostfix for " + ((__instance != null) ? __instance.GetPlayerName() : null) + ": " + ex.Message);
			}
		}

		private static Color GetTierColor(string wingsName)
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			return (Color)(wingsName switch
			{
				"WingsOf_Troll" => Color.cyan, 
				"WingsOf_Lox" => new Color(0.8f, 0.8f, 1f), 
				"WingsOf_Dragon" => new Color(0.8f, 0.1f, 1f), 
				_ => Color.green, 
			});
		}

		private static void UpdateLocalGlide(Player player, RuneWingVFX vfx, string wingsName)
		{
			//IL_0154: Unknown result type (might be due to invalid IL or missing references)
			//IL_011e: Unknown result type (might be due to invalid IL or missing references)
			if (((Character)player).IsOnGround() || ((Character)player).IsSwimming() || ((Character)player).InWater() || (Object)(object)((Character)player).GetStandingOnShip() != (Object)null || ((Character)player).IsAttachedToShip())
			{
				vfx.IsGlidingLocal = false;
				return;
			}
			if (ValkyrieInput.JumpPressed(player))
			{
				WingStats stats = ModConfig.GetStats(wingsName, WingsItem.GetEquippedWingsQuality(player));
				if (FlyingSkill.IsAvailable && FlyingSkill.Level(player) < stats.MinSkillToFlap)
				{
					vfx.IsGlidingLocal = true;
					FlightLog.NoteSkillDenied();
					((Character)player).Message((MessageType)2, $"These wings will not beat for you yet - Valkyrie Flight {Mathf.RoundToInt(stats.MinSkillToFlap)} required. Glide to learn.", 0, (Sprite)null, false);
				}
				else
				{
					float num = stats.FlapStaminaCost * (1f - ModConfig.SkillStaminaReduction.Value * FlyingSkill.Factor(player));
					if (((Character)player).HaveStamina(num))
					{
						((Character)player).UseStamina(num);
						FlyingSkill.AddFlapXP(player);
						FlightLog.NoteFlap();
						vfx.TriggerFlap();
						vfx.WantsToFlap = true;
						vfx.FlapCount++;
					}
					else
					{
						FlightLog.NoteStaminaDenied();
						((Character)player).Message((MessageType)2, "Not enough stamina to flap!", 0, (Sprite)null, false);
					}
				}
			}
			if (!vfx.IsGlidingLocal)
			{
				bool flag = ((Character)player).InNumShipVolumes > 0;
				if (vfx.WantsToFlap || (!flag && ((Character)player).GetVelocity().y < -5f))
				{
					vfx.IsGlidingLocal = true;
				}
			}
			if (vfx.IsGlidingLocal)
			{
				Traverse.Create((object)player).Field("m_maxAirAltitude").SetValue((object)((Component)player).transform.position.y);
			}
		}

		private static void PublishState(RuneWingVFX vfx, string wingsName)
		{
			ZNetView nView = vfx.NView;
			if ((Object)(object)nView == (Object)null || !nView.IsValid() || !nView.IsOwner())
			{
				return;
			}
			ZDO zDO = nView.GetZDO();
			if (zDO != null)
			{
				if (zDO.GetBool(ZdoGliding, false) != vfx.IsGlidingLocal)
				{
					zDO.Set(ZdoGliding, vfx.IsGlidingLocal);
				}
				if (zDO.GetInt(ZdoFlapCount, 0) != vfx.FlapCount)
				{
					zDO.Set(ZdoFlapCount, vfx.FlapCount, false);
				}
				int hashFromWingsName = WingsItem.GetHashFromWingsName(wingsName);
				int num = default(int);
				if (!zDO.GetInt(ZdoWings, ref num) || num != hashFromWingsName)
				{
					zDO.Set(ZdoWings, hashFromWingsName, false);
				}
			}
		}

		private static string ReadRemoteWings(Player player, RuneWingVFX vfx)
		{
			ZNetView nView = vfx.NView;
			ZDO val = (((Object)(object)nView != (Object)null && nView.IsValid()) ? nView.GetZDO() : null);
			int hash = default(int);
			if (val != null && val.GetInt(ZdoWings, ref hash))
			{
				return WingsItem.GetWingsNameFromHash(hash);
			}
			return WingsItem.GetVisualWingsName(player);
		}

		private static void ReadRemoteState(Player player, RuneWingVFX vfx)
		{
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			ZNetView nView = vfx.NView;
			ZDO val = (((Object)(object)nView != (Object)null && nView.IsValid()) ? nView.GetZDO() : null);
			bool isGlidingLocal = default(bool);
			if (val == null || !val.GetBool(ZdoGliding, ref isGlidingLocal))
			{
				isGlidingLocal = !((Character)player).IsOnGround() && !((Character)player).IsSwimming() && !((Character)player).InWater() && (Object)(object)((Character)player).GetStandingOnShip() == (Object)null && !((Character)player).IsAttachedToShip() && ((Character)player).InNumShipVolumes == 0 && Mathf.Abs(((Character)player).GetVelocity().y) > 2f;
				vfx.IsGlidingLocal = isGlidingLocal;
				return;
			}
			vfx.IsGlidingLocal = isGlidingLocal;
			int num = val.GetInt(ZdoFlapCount, 0);
			if (vfx.LastSeenFlapCount == int.MinValue)
			{
				vfx.LastSeenFlapCount = num;
			}
			else if (num != vfx.LastSeenFlapCount)
			{
				vfx.LastSeenFlapCount = num;
				vfx.TriggerFlap();
			}
		}

		[HarmonyPatch("FixedUpdate")]
		[HarmonyPostfix]
		public static void FixedUpdatePostfix(Player __instance)
		{
			//IL_0166: Unknown result type (might be due to invalid IL or missing references)
			//IL_016b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0192: Unknown result type (might be due to invalid IL or missing references)
			//IL_0138: Unknown result type (might be due to invalid IL or missing references)
			//IL_0145: Unknown result type (might be due to invalid IL or missing references)
			//IL_014f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0203: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01da: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0213: Unknown result type (might be due to invalid IL or missing references)
			//IL_0217: Unknown result type (might be due to invalid IL or missing references)
			//IL_021c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0221: Unknown result type (might be due to invalid IL or missing references)
			//IL_0232: Unknown result type (might be due to invalid IL or missing references)
			//IL_0237: Unknown result type (might be due to invalid IL or missing references)
			//IL_0244: Unknown result type (might be due to invalid IL or missing references)
			//IL_0266: Unknown result type (might be due to invalid IL or missing references)
			//IL_0278: Unknown result type (might be due to invalid IL or missing references)
			//IL_028a: Unknown result type (might be due to invalid IL or missing references)
			//IL_029d: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b7: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)__instance != (Object)(object)Player.m_localPlayer || !ModConfig.EnableMod.Value)
			{
				return;
			}
			try
			{
				RuneWingVFX component = ((Component)__instance).GetComponent<RuneWingVFX>();
				if ((Object)(object)component == (Object)null || !component.IsGlidingLocal || ((Character)__instance).IsOnGround() || ((Character)__instance).IsSwimming() || ((Character)__instance).InWater() || !((Object)(object)((Character)__instance).GetStandingOnShip() == (Object)null) || ((Character)__instance).IsAttachedToShip())
				{
					return;
				}
				Rigidbody component2 = ((Component)__instance).GetComponent<Rigidbody>();
				if (!((Object)(object)component2 != (Object)null))
				{
					return;
				}
				ItemData equippedWings = WingsItem.GetEquippedWings(__instance);
				WingStats stats = ModConfig.GetStats((equippedWings != null) ? WingsItem.GetWingsNameFromHash(StringExtensionMethods.GetStableHashCode(((Object)equippedWings.m_dropPrefab).name)) : null, equippedWings?.m_quality ?? 1);
				float num = FlyingSkill.Factor(__instance);
				float num2 = stats.GlideSpeed * (1f + ModConfig.SkillGlideSpeedBonus.Value * num);
				float num3 = stats.FlapForce * (1f + ModConfig.SkillFlapPowerBonus.Value * num);
				float num4 = (FlyingSkill.IsAvailable ? (stats.FlightCeiling * Mathf.Lerp(ModConfig.CeilingAtNovice.Value, 1f, num)) : stats.FlightCeiling);
				if (component.WantsToFlap)
				{
					component2.linearVelocity = new Vector3(component2.linearVelocity.x, num3, component2.linearVelocity.z);
					component.WantsToFlap = false;
				}
				else
				{
					Vector3 lookDir = ((Character)__instance).GetLookDir();
					float num5 = (0f - ModConfig.BaseGlideSinkRate.Value) * (1f - ModConfig.SkillGlideSinkReduction.Value * num);
					float num6 = num5;
					if (lookDir.y < 0f)
					{
						num6 = Mathf.Lerp(num5, 0f - ModConfig.MaxDiveSpeed.Value, 0f - lookDir.y);
					}
					if (component2.linearVelocity.y < num6)
					{
						component2.linearVelocity = new Vector3(component2.linearVelocity.x, num6, component2.linearVelocity.z);
					}
				}
				Vector3 value = Traverse.Create((object)__instance).Field("m_moveDir").GetValue<Vector3>();
				if (((Vector3)(ref value)).magnitude > 0.1f)
				{
					Vector3 val = value * num2;
					val.y = component2.linearVelocity.y;
					component2.linearVelocity = Vector3.Lerp(component2.linearVelocity, val, 3f * Time.fixedDeltaTime);
				}
				if ((Object)(object)ZoneSystem.instance != (Object)null)
				{
					float groundHeight = ZoneSystem.instance.GetGroundHeight(((Component)__instance).transform.position);
					if (((Component)__instance).transform.position.y - groundHeight > num4 && component2.linearVelocity.y > 0f)
					{
						component2.linearVelocity = new Vector3(component2.linearVelocity.x, 0f, component2.linearVelocity.z);
					}
				}
			}
			catch (Exception ex)
			{
				Log.LogWarning("Error in FixedUpdatePostfix for " + ((__instance != null) ? __instance.GetPlayerName() : null) + ": " + ex.Message);
			}
		}
	}
	public static class FlightLog
	{
		private const string CustomDataKey = "wubarrk.wotv.flightlog";

		private const float MinTrackedSpeed = 0.1f;

		private const float ImplausibleSpeed = 200f;

		private const float AltitudeSampleInterval = 0.25f;

		private const float InFlightFlushInterval = 10f;

		private static FlightSaga _saga = new FlightSaga();

		private static string _loadedFor;

		private static Player _boundPlayer;

		private static bool _airborne;

		private static float _currentFlightSeconds;

		private static float _currentFlightMeters;

		private static Vector3 _lastPosition;

		private static bool _hasLastPosition;

		private static float _altitudeSampleTimer;

		private static float _flushTimer;

		public static bool HasFlown => _saga.HasFlown;

		public static FlightSaga Saga => _saga;

		public static string OwnerName => _loadedFor;

		public static void LoadFrom(Player player)
		{
			Bind(player, force: true);
		}

		public static void EnsureLoaded(Player player)
		{
			Bind(player, force: false);
		}

		private static void Bind(Player player, bool force)
		{
			if ((Object)(object)player == (Object)null || (!force && _boundPlayer == player))
			{
				return;
			}
			string playerName = player.GetPlayerName();
			if (!force && _loadedFor == playerName)
			{
				_boundPlayer = player;
				return;
			}
			_saga = new FlightSaga();
			_loadedFor = playerName;
			_boundPlayer = player;
			ResetFlightState();
			_airborne = false;
			try
			{
				Dictionary<string, string> customData = player.m_customData;
				if (customData != null && customData.TryGetValue("wubarrk.wotv.flightlog", out var value) && !string.IsNullOrEmpty(value))
				{
					_saga = FlightSaga.Deserialize(value);
				}
			}
			catch (Exception ex)
			{
				_saga = new FlightSaga();
				Log.LogWarning("Could not read the flight logbook for " + playerName + ", starting a fresh one. Reason: " + ex.Message);
			}
		}

		public static void Flush(Player player, bool force)
		{
			if ((Object)(object)player == (Object)null || !ModConfig.EnableFlightLog.Value || _loadedFor == null || _loadedFor != player.GetPlayerName())
			{
				return;
			}
			_saga.SkillLevel = FlyingSkill.Level(player);
			try
			{
				Dictionary<string, string> dictionary = player.m_customData;
				if (dictionary == null)
				{
					dictionary = (player.m_customData = new Dictionary<string, string>());
				}
				dictionary["wubarrk.wotv.flightlog"] = _saga.Serialize();
			}
			catch (Exception ex)
			{
				Log.LogWarning("Could not store the flight logbook on your character. Reason: " + ex.Message);
			}
			FlightReport.ReportToServer(player, _saga, force);
		}

		public static void NoteFlap()
		{
			if (ModConfig.EnableFlightLog.Value)
			{
				_saga.Flaps++;
			}
		}

		public static void NoteStaminaDenied()
		{
			if (ModConfig.EnableFlightLog.Value)
			{
				_saga.StaminaDenials++;
			}
		}

		public static void NoteSkillDenied()
		{
			if (ModConfig.EnableFlightLog.Value)
			{
				_saga.SkillDenials++;
			}
		}

		public static void Tick(Player player, bool gliding, string wingsName, float deltaTime)
		{
			if (!((Object)(object)player == (Object)null) && ModConfig.EnableFlightLog.Value)
			{
				EnsureLoaded(player);
				if (gliding && !_airborne)
				{
					BeginFlight(player);
				}
				else if (!gliding && _airborne)
				{
					EndFlight(player);
				}
				if (!gliding)
				{
					_hasLastPosition = false;
				}
				else
				{
					Accumulate(player, wingsName, deltaTime);
				}
			}
		}

		private static void BeginFlight(Player player)
		{
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			_airborne = true;
			_currentFlightSeconds = 0f;
			_currentFlightMeters = 0f;
			_altitudeSampleTimer = 0f;
			_flushTimer = 0f;
			_lastPosition = ((Component)player).transform.position;
			_hasLastPosition = true;
			_saga.Flights++;
			long num = FlightSaga.UnixNow();
			if (_saga.FirstFlightUnix == 0L)
			{
				_saga.FirstFlightUnix = num;
			}
			_saga.LastFlightUnix = num;
		}

		private static void EndFlight(Player player)
		{
			_airborne = false;
			if (_currentFlightSeconds > _saga.BestFlightSeconds)
			{
				_saga.BestFlightSeconds = _currentFlightSeconds;
			}
			if (_currentFlightMeters > _saga.BestFlightMeters)
			{
				_saga.BestFlightMeters = _currentFlightMeters;
			}
			_saga.LastFlightUnix = FlightSaga.UnixNow();
			if (((Character)player).IsSwimming() || ((Character)player).InWater())
			{
				_saga.LandingsWater++;
			}
			else if ((Object)(object)((Character)player).GetStandingOnShip() != (Object)null)
			{
				_saga.LandingsShip++;
			}
			else
			{
				_saga.LandingsGround++;
			}
			ResetFlightState();
			Flush(player, force: false);
		}

		private static void Accumulate(Player player, string wingsName, float deltaTime)
		{
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: 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_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0108: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_0157: Unknown result type (might be due to invalid IL or missing references)
			if (deltaTime <= 0f)
			{
				return;
			}
			_currentFlightSeconds += deltaTime;
			_saga.TimeFlownSeconds += deltaTime;
			_saga.AddTierTime(wingsName, deltaTime);
			_flushTimer += deltaTime;
			if (_flushTimer >= 10f)
			{
				_flushTimer = 0f;
				Flush(player, force: false);
			}
			if (EnvMan.IsNight())
			{
				_saga.NightSeconds += deltaTime;
			}
			Vector3 position = ((Component)player).transform.position;
			if (_hasLastPosition)
			{
				Vector3 val = position - _lastPosition;
				val.y = 0f;
				float magnitude = ((Vector3)(ref val)).magnitude;
				float num = magnitude / deltaTime;
				if (num >= 0.1f && num < 200f)
				{
					_saga.DistanceMeters += magnitude;
					_currentFlightMeters += magnitude;
					if (num > _saga.BestSpeed)
					{
						_saga.BestSpeed = num;
					}
				}
			}
			_lastPosition = position;
			_hasLastPosition = true;
			float num2 = 0f - ((Character)player).GetVelocity().y;
			if (num2 > _saga.BestDiveSpeed && num2 < 200f)
			{
				_saga.BestDiveSpeed = num2;
			}
			_altitudeSampleTimer += deltaTime;
			if (_altitudeSampleTimer >= 0.25f)
			{
				_altitudeSampleTimer = 0f;
				SampleAltitudeAndBiome(player, position);
			}
		}

		private static void SampleAltitudeAndBiome(Player player, Vector3 position)
		{
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Expected I4, but got Unknown
			if ((Object)(object)ZoneSystem.instance != (Object)null)
			{
				float num = position.y - ZoneSystem.instance.GetGroundHeight(position);
				if (num > _saga.BestAltitude)
				{
					_saga.BestAltitude = num;
				}
			}
			Biome currentBiome = player.GetCurrentBiome();
			if ((int)currentBiome != 0)
			{
				FlightSaga saga = _saga;
				saga.BiomeMask |= currentBiome;
			}
		}

		private static void ResetFlightState()
		{
			_currentFlightSeconds = 0f;
			_currentFlightMeters = 0f;
			_hasLastPosition = false;
			_altitudeSampleTimer = 0f;
			_flushTimer = 0f;
		}

		private static string Num(double value, int decimals)
		{
			return value.ToString("N" + decimals, CultureInfo.InvariantCulture);
		}

		public static List<string> Report(Player player, bool includeOddities)
		{
			List<string> list = new List<string>();
			if (!ModConfig.EnableFlightLog.Value)
			{
				list.Add("The flight logbook is switched off (see EnableFlightLog in the config).");
				return list;
			}
			if (!HasFlown)
			{
				list.Add("Your logbook is empty. The sky is still waiting.");
				return list;
			}
			list.Add("=== The Flight Saga of " + (_loadedFor ?? "a nameless Viking") + " ===");
			list.Add("Valkyrie Flight level : " + Num(FlyingSkill.Level(player), 1));
			list.Add("Time flown            : " + FlightSaga.Duration(_saga.TimeFlownSeconds));
			list.Add("Distance flown        : " + Num(_saga.DistanceMeters, 0) + " m");
			list.Add("Flights               : " + _saga.Flights.ToString(CultureInfo.InvariantCulture));
			list.Add("Wingbeats             : " + _saga.Flaps.ToString(CultureInfo.InvariantCulture));
			list.Add("-- Records --");
			list.Add("Highest above ground  : " + Num(_saga.BestAltitude, 1) + " m");
			list.Add("Longest single flight : " + FlightSaga.Duration(_saga.BestFlightSeconds) + " / " + Num(_saga.BestFlightMeters, 0) + " m");
			list.Add("Fastest on the wing   : " + Num(_saga.BestSpeed, 1) + " m/s");
			list.Add("Steepest stoop        : " + Num(_saga.BestDiveSpeed, 1) + " m/s straight down");
			if (!includeOddities)
			{
				return list;
			}
			list.Add("-- Oddities --");
			list.Add("Flown by night        : " + FlightSaga.Duration(_saga.NightSeconds));
			list.Add("Out of stamina midair : " + _saga.StaminaDenials.ToString(CultureInfo.InvariantCulture) + " times");
			list.Add("Wings refused you     : " + _saga.SkillDenials.ToString(CultureInfo.InvariantCulture) + " times (not skilled enough to flap)");
			list.Add("Landed on solid ground: " + _saga.LandingsGround.ToString(CultureInfo.InvariantCulture));
			list.Add("Landed in the drink   : " + _saga.LandingsWater.ToString(CultureInfo.InvariantCulture));
			list.Add("Landed on a ship      : " + _saga.LandingsShip.ToString(CultureInfo.InvariantCulture));
			List<string> list2 = _saga.BiomesFlownOver();
			list.Add("Biomes crossed        : " + list2.Count + "/" + FlightSaga.BiomeCount + ((list2.Count > 0) ? (" (" + string.Join(", ", list2.ToArray()) + ")") : ""));
			list.Add("-- Time per tier --");
			list.Add("Crude  : " + FlightSaga.Duration(_saga.CrudeSeconds));
			list.Add("Troll  : " + FlightSaga.Duration(_saga.TrollSeconds));
			list.Add("Lox    : " + FlightSaga.Duration(_saga.LoxSeconds));
			list.Add("Dragon : " + FlightSaga.Duration(_saga.DragonSeconds));
			return list;
		}
	}
	public static class FlightLogCommand
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static ConsoleEvent <0>__Run;
		}

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

			public static ConsoleOptionsFetcher <>9__3_0;

			internal List<string> <Register>b__3_0()
			{
				return Options;
			}
		}

		private const string Name = "wov";

		private const string Help = "Wings of the Valkyrie. 'wov log' for your flight saga, 'wov oddities' for the strange corners of it, 'wov export' to write the logbook out as JSON, 'wov where' for that file's path, 'wov slot [back|trinket]' to see or choose which slot your wings go in.";

		private static readonly List<string> Options = new List<string> { "log", "oddities", "export", "where", "slot" };

		public static void Register()
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Expected O, but got Unknown
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Expected O, but got Unknown
			object obj = <>O.<0>__Run;
			if (obj == null)
			{
				ConsoleEvent val = Run;
				<>O.<0>__Run = val;
				obj = (object)val;
			}
			object obj2 = <>c.<>9__3_0;
			if (obj2 == null)
			{
				ConsoleOptionsFetcher val2 = () => Options;
				<>c.<>9__3_0 = val2;
				obj2 = (object)val2;
			}
			new ConsoleCommand("wov", "Wings of the Valkyrie. 'wov log' for your flight saga, 'wov oddities' for the strange corners of it, 'wov export' to write the logbook out as JSON, 'wov where' for that file's path, 'wov slot [back|trinket]' to see or choose which slot your wings go in.", (ConsoleEvent)obj, false, false, false, false, false, false, (ConsoleOptionsFetcher)obj2, false, false, false);
		}

		private static void Run(ConsoleEventArgs args)
		{
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null)
			{
				Print(args, "No Viking to speak of - load a character first.");
				return;
			}
			FlightLog.EnsureLoaded(localPlayer);
			string text = ((args != null && args.Length > 1) ? args[1].ToLowerInvariant() : "log");
			switch (text)
			{
			case "log":
			case "oddities":
			{
				foreach (string item in FlightLog.Report(localPlayer, text == "oddities"))
				{
					Print(args, item);
				}
				break;
			}
			case "export":
			{
				FlightLog.Flush(localPlayer, force: true);
				if (!ModConfig.PublishFlightStats.Value)
				{
					Print(args, "Flight statistics are switched off here - set PublishFlightStats to true in the config.");
					break;
				}
				if ((Object)(object)ZNet.instance != (Object)null && !ZNet.instance.IsServer())
				{
					Print(args, "Sent your flight saga to the server. The server owns the statistics file - ask its admin, or run this on the server itself.");
					break;
				}
				string text2 = FlightReport.WriteExport();
				Print(args, (text2 != null) ? ("Flight statistics written to " + text2) : "Could not write the flight statistics - see the log for why.");
				break;
			}
			case "where":
				Print(args, "Flight statistics file: " + FlightReport.ExportPath());
				Print(args, "Your own saga lives on your character, not in that file.");
				break;
			case "slot":
			{
				string argument = ((args.Length > 2) ? args[2].ToLowerInvariant() : null);
				{
					foreach (string item2 in WingsSlot.Command(localPlayer, argument))
					{
						Print(args, item2);
					}
					break;
				}
			}
			default:
				Print(args, "Unknown option '" + text + "'. Try: log, oddities, export, where, slot.");
				break;
			}
		}

		private static void Print(ConsoleEventArgs args, string line)
		{
			Terminal val = args?.Context;
			if ((Object)(object)val != (Object)null)
			{
				val.AddString(line);
			}
			else if ((Object)(object)Console.instance != (Object)null)
			{
				((Terminal)Console.instance).AddString(line);
			}
		}
	}
	[HarmonyPatch(typeof(Player))]
	public static class FlightLogPatches
	{
		[HarmonyPatch("Load")]
		[HarmonyPostfix]
		public static void LoadPostfix(Player __instance)
		{
			if (ModConfig.EnableFlightLog.Value)
			{
				FlightLog.LoadFrom(__instance);
			}
		}

		[HarmonyPatch("OnSpawned")]
		[HarmonyPostfix]
		public static void OnSpawnedPostfix(Player __instance)
		{
			if (ModConfig.EnableFlightLog.Value && !((Object)(object)__instance != (Object)(object)Player.m_localPlayer))
			{
				FlightLog.EnsureLoaded(__instance);
			}
		}

		[HarmonyPatch("Save")]
		[HarmonyPrefix]
		public static void SavePrefix(Player __instance)
		{
			if (ModConfig.EnableFlightLog.Value)
			{
				FlightLog.Flush(__instance, force: true);
			}
		}
	}
	public static class FlightReport
	{
		private sealed class Row
		{
			public long PlayerId;

			public string Name;

			public FlightSaga Saga;
		}

		private sealed class Field
		{
			public string Name;

			public Func<FlightSaga, double> Value;

			public bool Integral;
		}

		private sealed class Subject
		{
			public string FileName;

			public string Holds;

			public Field[] Fields;

			public Action<StringBuilder, FlightSaga> AppendExtra;
		}

		private sealed class Leader
		{
			public string Name;

			public double Value;
		}

		private const string RpcName = "WOTV_FlightSaga";

		private const string ExportFolder = "WingsOfTheValkyrie";

		private const string ExportFileName = "barrkbot_flight.json";

		private const string RegistryFileName = "flight_registry.dat";

		private static readonly Dictionary<long, Row> Rows = new Dictionary<long, Row>();

		private static ZRoutedRpc _registeredOn;

		private static bool _registryLoaded;

		private static float _writeTimer;

		private static float _lastReportTime = float.NegativeInfinity;

		private const int RowBudgetChars = 2400;

		public static void Register()
		{
			ZRoutedRpc instance = ZRoutedRpc.instance;
			if (instance == null || _registeredOn == instance)
			{
				return;
			}
			try
			{
				instance.Register<long, string, string>("WOTV_FlightSaga", (Action<long, long, string, string>)OnSagaReceived);
				_registeredOn = instance;
				Rows.Clear();
				_registryLoaded = false;
				_writeTimer = 0f;
				_lastReportTime = float.NegativeInfinity;
			}
			catch (Exception ex)
			{
				Log.LogWarning("Could not register the flight report RPC; flight stats will not reach the server. Reason: " + ex.Message);
			}
		}

		public static void ReportToServer(Player player, FlightSaga saga, bool force)
		{
			if ((Object)(object)player == (Object)null || saga == null || !ModConfig.PublishFlightStats.Value || !saga.HasFlown)
			{
				return;
			}
			Register();
			float num = Mathf.Max(1f, ModConfig.FlightStatsReportInterval.Value);
			if (!force && Time.realtimeSinceStartup - _lastReportTime < num)
			{
				return;
			}
			_lastReportTime = Time.realtimeSinceStartup;
			try
			{
				long playerID = player.GetPlayerID();
				string playerName = player.GetPlayerName();
				string text = saga.Serialize();
				if ((Object)(object)ZNet.instance == (Object)null || ZNet.instance.IsServer())
				{
					Accept(playerID, playerName, text);
					return;
				}
				ZRoutedRpc instance = ZRoutedRpc.instance;
				if (instance != null)
				{
					ZNetPeer serverPeer = ZNet.instance.GetServerPeer();
					if (serverPeer != null)
					{
						instance.InvokeRoutedRPC(serverPeer.m_uid, "WOTV_FlightSaga", new object[3] { playerID, playerName, text });
					}
				}
			}
			catch (Exception ex)
			{
				Log.LogWarning("Could not send your flight stats to the server. Reason: " + ex.Message);
			}
		}

		private static void OnSagaReceived(long sender, long playerId, string name, string payload)
		{
			if (!((Object)(object)ZNet.instance != (Object)null) || ZNet.instance.IsServer())
			{
				Accept(playerId, name, payload);
			}
		}

		private static void Accept(long playerId, string name, string payload)
		{
			try
			{
				if (playerId != 0L && !string.IsNullOrEmpty(payload))
				{
					FlightSaga flightSaga = FlightSaga.Deserialize(payload);
					if (flightSaga.HasFlown)
					{
						EnsureRegistryLoaded();
						Rows[playerId] = new Row
						{
							PlayerId = playerId,
							Name = (string.IsNullOrEmpty(name) ? "Unknown" : name),
							Saga = flightSaga
						};
					}
				}
			}
			catch (Exception ex)
			{
				Log.LogWarning("Could not read a flight report. Reason: " + ex.Message);
			}
		}

		public static void Tick(float deltaTime)
		{
			if (ModConfig.PublishFlightStats.Value && !((Object)(object)ZNet.instance == (Object)null) && ZNet.instance.IsServer())
			{
				Register();
				EnsureRegistryLoaded();
				_writeTimer += deltaTime;
				if (!(_writeTimer < Mathf.Max(5f, ModConfig.FlightStatsWriteInterval.Value)))
				{
					_writeTimer = 0f;
					WriteExport();
				}
			}
		}

		public static string ExportDirectory()
		{
			string value = ModConfig.FlightStatsExportFolder.Value;
			if (!string.IsNullOrEmpty(value))
			{
				return value.Trim();
			}
			return Path.Combine(Paths.ConfigPath, "WingsOfTheValkyrie");
		}

		public static string ExportPath()
		{
			return Path.Combine(ExportDirectory(), "barrkbot_flight.json");
		}

		private static string RegistryPath()
		{
			return Path.Combine(ExportDirectory(), "flight_registry.dat");
		}

		internal static void EnsureSnapshot()
		{
			EnsureRegistryLoaded();
		}

		private static void EnsureRegistryLoaded()
		{
			if (_registryLoaded)
			{
				return;
			}
			_registryLoaded = true;
			try
			{
				string path = RegistryPath();
				if (!File.Exists(path))
				{
					return;
				}
				string[] array = File.ReadAllLines(path);
				foreach (string text in array)
				{
					if (!string.IsNullOrEmpty(text))
					{
						int num = text.IndexOf('|');
						int num2 = text.LastIndexOf('|');
						if (num > 0 && num2 > num && long.TryParse(text.Substring(0, num), NumberStyles.Integer, CultureInfo.InvariantCulture, out var result))
						{
							Rows[result] = new Row
							{
								PlayerId = result,
								Name = text.Substring(num + 1, num2 - num - 1),
								Saga = FlightSaga.Deserialize(text.Substring(num2 + 1))
							};
						}
					}
				}
			}
			catch (Exception ex)
			{
				Log.LogWarning("Could not read the flight registry; it will rebuild as players fly. Reason: " + ex.Message);
			}
			FlyingSkillRestore.CaptureSnapshot(Rows.Count, VisitRows);
		}

		priva