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.InteropServices;
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 LocalizationManager;
using Microsoft.CodeAnalysis;
using ServerSync;
using TMPro;
using UnityEngine;
using UnityEngine.Events;
using UnityEngine.UI;
using YamlDotNet.Serialization;
using YamlDotNet.Serialization.NamingConventions;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: Guid("E0E2F92E-557C-4A05-9D89-AA92A0BD75C4")]
[assembly: ComVisible(false)]
[assembly: AssemblyTrademark("")]
[assembly: AssemblyCopyright("Original © RustyMods 2022; Continued by SephrinMods")]
[assembly: AssemblyProduct("Norsemen Continued")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyDescription("Valheim 1.0 continuation of Norsemen")]
[assembly: AssemblyTitle("Norsemen Continued")]
[assembly: AssemblyFileVersion("0.4.1")]
[assembly: AssemblyCompany("SephrinMods")]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.4.1.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
[module: _003Cb4e4c1d4_002Df66f_002D43d9_002Daa13_002D4ee0e3dffa1f_003ERefSafetyRules(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;
		}
	}
	[_003C15985cda_002Dd337_002D451f_002Db973_002D227a12929b60_003EEmbedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	[CompilerGenerated]
	internal sealed class _003C227f8b5a_002D22c2_002D474e_002Db0ef_002D3bcf0457138c_003ENullableContextAttribute : Attribute
	{
		public readonly byte Flag;

		public _003C227f8b5a_002D22c2_002D474e_002Db0ef_002D3bcf0457138c_003ENullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	[CompilerGenerated]
	[_003C15985cda_002Dd337_002D451f_002Db973_002D227a12929b60_003EEmbedded]
	internal sealed class _003C812f407f_002D18f8_002D4794_002Dbefe_002D7b53d43aa20f_003ENullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

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

		public _003C812f407f_002D18f8_002D4794_002Dbefe_002D7b53d43aa20f_003ENullableAttribute(byte[] P_0)
		{
			NullableFlags = P_0;
		}
	}
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	[CompilerGenerated]
	[_003C15985cda_002Dd337_002D451f_002Db973_002D227a12929b60_003EEmbedded]
	internal sealed class _003Cb4e4c1d4_002Df66f_002D43d9_002Daa13_002D4ee0e3dffa1f_003ERefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public _003Cb4e4c1d4_002Df66f_002D43d9_002Daa13_002D4ee0e3dffa1f_003ERefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace ServerSync
{
	[PublicAPI]
	internal 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> adminPeer = ZNet.instance.GetPeers().Where(delegate(ZNetPeer p)
							{
								string hostName = p.m_rpc.GetSocket().GetHostName();
								return ((object)listContainsId == null) ? adminList.Contains(hostName) : ((bool)listContainsId.Invoke(ZNet.instance, new object[2] { adminList, hostName }));
							}).ToList();
							List<ZNetPeer> nonAdminPeer = ZNet.instance.GetPeers().Except(adminPeer).ToList();
							SendAdmin(nonAdminPeer, isAdmin: false);
							SendAdmin(adminPeer, 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 : ISocket
			{
				public volatile bool finished = false;

				public volatile int versionMatchQueued = -1;

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

				public readonly ISocket Original;

				public BufferingSocket(ISocket original)
				{
					Original = original;
				}

				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_0057: Unknown result type (might be due to invalid IL or missing references)
					//IL_005d: 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_007c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0082: Expected O, but got Unknown
				//IL_0085: Unknown result type (might be due to invalid IL or missing references)
				//IL_008b: Invalid comparison between Unknown and I4
				if (__instance.IsServer())
				{
					BufferingSocket value = new BufferingSocket(rpc.GetSocket());
					AccessTools.DeclaredField(typeof(ZRpc), "m_socket").SetValue(rpc, value);
					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)
					{
						AccessTools.DeclaredField(typeof(ZNetPeer), "m_socket").SetValue(val, value);
					}
					if (__state == null)
					{
						__state = new Dictionary<Assembly, BufferingSocket>();
					}
					__state[Assembly.GetExecutingAssembly()] = value;
				}
			}

			[HarmonyPostfix]
			private static void Postfix(Dictionary<Assembly, BufferingSocket> __state, ZNet __instance, ZRpc rpc)
			{
				//IL_007f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0089: Expected O, but got Unknown
				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()
				{
					//IL_0093: Unknown result type (might be due to invalid IL or missing references)
					//IL_009a: Expected O, but got Unknown
					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> entries = new List<PackageEntry>();
						if (configSync.CurrentVersion != null)
						{
							entries.Add(new PackageEntry
							{
								section = "Internal",
								key = "serverversion",
								type = typeof(string),
								value = configSync.CurrentVersion
							});
						}
						MethodInfo listContainsId = AccessTools.DeclaredMethod(typeof(ZNet), "ListContainsId", (Type[])null, (Type[])null);
						SyncedList adminList = (SyncedList)AccessTools.DeclaredField(typeof(ZNet), "m_adminList").GetValue(ZNet.instance);
						entries.Add(new PackageEntry
						{
							section = "Internal",
							key = "lockexempt",
							type = typeof(bool),
							value = (((object)listContainsId == null) ? ((object)adminList.Contains(rpc.GetSocket().GetHostName())) : listContainsId.Invoke(ZNet.instance, new object[2]
							{
								adminList,
								rpc.GetSocket().GetHostName()
							}))
						});
						ZPackage package = ConfigsToPackage(configSync.allConfigs.Select((OwnConfigEntryBase c) => c.BaseConfig), configSync.allCustomValues, entries, partial: false);
						yield return ((MonoBehaviour)__instance).StartCoroutine(configSync.sendZPackage(new List<ZNetPeer> { peer }, package));
					}
					SendBufferedData();
				}
			}
		}

		private class PackageEntry
		{
			public string section = null;

			public string key = null;

			public Type type = null;

			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 = null;

			public string received = null;

			public string field = "";
		}

		public static bool ProcessingServerUpdate;

		public readonly string Name;

		public string? DisplayName;

		public string? CurrentVersion;

		public string? MinimumRequiredVersion;

		public bool ModRequired = false;

		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 = null;

		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 flag2;
				if (!flag.HasValue)
				{
					if (lockedConfig == null)
					{
						goto IL_0074;
					}
					flag2 = ((IConvertible)lockedConfig.BaseConfig.BoxedValue).ToInt32(CultureInfo.InvariantCulture) != 0;
				}
				else
				{
					flag2 = flag == true;
				}
				if (!flag2)
				{
					goto IL_0074;
				}
				int num = ((!lockExempt) ? 1 : 0);
				goto IL_0079;
				IL_0074:
				num = 0;
				goto IL_0079;
				IL_0079:
				return (byte)num != 0;
			}
			set
			{
				forceConfigLocking = value;
			}
		}

		public bool IsAdmin => lockExempt || isSourceOfTruth;

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

		public bool InitialSyncDone { get; private set; } = false;

		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)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Expected O, but got Unknown
			OwnConfigEntryBase ownConfigEntryBase = configData((ConfigEntryBase)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_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Expected O, but got Unknown
			//IL_0277: Unknown result type (might be due to invalid IL or missing references)
			//IL_027e: Expected O, but got Unknown
			//IL_0211: Unknown result type (might be due to invalid IL or missing references)
			//IL_0218: 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)
				{
					byte[] buffer = package.ReadByteArray();
					MemoryStream stream = new MemoryStream(buffer);
					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;
				}
				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;
			}
			return configSync.IsSourceOfTruth || !config.SynchronizedConfig || config.LocalBaseValue == null || (!configSync.IsLocked && (config != configSync.lockedConfig || lockExempt));
		}

		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 fragmentedPackage = new ZPackage();
						fragmentedPackage.Write((byte)2);
						fragmentedPackage.Write(packageIdentifier);
						fragmentedPackage.Write(fragment);
						fragmentedPackage.Write(fragments);
						fragmentedPackage.Write(data.Skip(250000 * fragment).Take(250000).ToArray());
						SendPackage(fragmentedPackage);
						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)(object)ZNet.instance == (Object)null)
			{
				return Enumerable.Empty<object>().GetEnumerator();
			}
			List<ZNetPeer> list = (List<ZNetPeer>)AccessTools.DeclaredField(typeof(ZRoutedRpc), "m_peers").GetValue(ZRoutedRpc.instance);
			if (target != 0)
			{
				list = list.Where((ZNetPeer p) => p.m_uid == target).ToList();
			}
			return sendZPackage(list, package);
		}

		private IEnumerator sendZPackage(List<ZNetPeer> peers, ZPackage package)
		{
			if ((Object)(object)ZNet.instance == (Object)null)
			{
				yield break;
			}
			byte[] rawData = package.GetArray();
			if (rawData != null && rawData.LongLength > 10000)
			{
				ZPackage compressedPackage = new ZPackage();
				compressedPackage.Write((byte)4);
				MemoryStream output = new MemoryStream();
				using (DeflateStream deflateStream = new DeflateStream(output, CompressionLevel.Optimal))
				{
					deflateStream.Write(rawData, 0, rawData.Length);
				}
				compressedPackage.Write(output.ToArray());
				package = compressedPackage;
			}
			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 ((Object)(object)instance != (Object)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 ((Object)(object)instance != (Object)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)
		{
			return type.IsEnum ? Enum.GetUnderlyingType(type) : type;
		}

		private static ZPackage ConfigsToPackage(IEnumerable<ConfigEntryBase>? configs = null, IEnumerable<CustomSyncedValueBase>? customValues = null, IEnumerable<PackageEntry>? packageEntries = null, bool partial = true)
		{
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: 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((byte)(partial ? 1u : 0u));
			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;
					FieldInfo[] array2 = array;
					foreach (FieldInfo fieldInfo in array2)
					{
						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;
				FieldInfo[] array2 = array;
				foreach (FieldInfo fieldInfo in array2)
				{
					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();
		}
	}
	internal class ConfigurationManagerAttributes
	{
		[UsedImplicitly]
		public bool? ReadOnly = false;
	}
	[PublicAPI]
	internal 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 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]
	internal abstract class OwnConfigEntryBase
	{
		public object? LocalBaseValue;

		public bool SynchronizedConfig = true;

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

		public override ConfigEntryBase BaseConfig => (ConfigEntryBase)SourceConfig;

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

		public SyncedConfigEntry(ConfigEntry<T> sourceConfig)
		{
			SourceConfig = sourceConfig;
		}

		public void AssignLocalValue(T value)
		{
			if (LocalBaseValue == null)
			{
				Value = value;
			}
			else
			{
				LocalBaseValue = value;
			}
		}
	}
	[HarmonyPatch]
	[PublicAPI]
	internal 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
			{
				return minimumRequiredVersion ?? (ModRequired ? CurrentVersion : "0.0.0");
			}
			set
			{
				minimumRequiredVersion = value;
			}
		}

		private static void PatchServerSync()
		{
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: 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 flag = new Version(CurrentVersion) >= new Version(ReceivedMinimumRequiredVersion);
			bool flag2 = new Version(ReceivedCurrentVersion) >= new Version(MinimumRequiredVersion);
			return flag && flag2;
		}

		private string ErrorClient()
		{
			if (ReceivedMinimumRequiredVersion == null)
			{
				return DisplayName + " is not installed on the server.";
			}
			return (new Version(CurrentVersion) >= new Version(ReceivedMinimumRequiredVersion)) ? (DisplayName + " may not be higher than version " + ReceivedCurrentVersion + ". You have version " + CurrentVersion + ".") : (DisplayName + " needs to be at least version " + ReceivedMinimumRequiredVersion + ". 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)
		{
			return (rpc == null) ? ErrorClient() : ErrorServer(rpc);
		}

		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;
			VersionCheck[] array3 = array2;
			foreach (VersionCheck versionCheck in array3)
			{
				Debug.LogWarning((object)versionCheck.Error(rpc));
			}
			if (__instance.IsServer())
			{
				DisconnectClient(rpc);
			}
			else
			{
				Logout();
			}
			return false;
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(ZNet), "OnNewConnection")]
		private static void RegisterAndCheckVersion(ZNetPeer peer, ZNet __instance)
		{
			//IL_0189: Unknown result type (might be due to invalid IL or missing references)
			//IL_0190: 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 });
				}
			}
		}

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

		[HarmonyPostfix]
		[HarmonyPatch(typeof(FejdStartup), "ShowConnectError")]
		private static void ShowConnectionError(FejdStartup __instance)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Invalid comparison between Unknown and I4
			//IL_0189: Unknown result type (might be due to invalid IL or missing references)
			//IL_018e: Unknown result type (might be due to invalid IL or missing references)
			//IL_019e: 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_01ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_020f: 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_022e: 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 Norsemen
{
	public class AnimChain
	{
		public readonly int index;

		public readonly string trigger;

		public AnimChain(string trigger, int index)
		{
			this.trigger = trigger;
			this.index = index;
		}
	}
	public class AnimType : Attribute
	{
		public string trigger = string.Empty;

		public bool isBool;

		public bool isIndex;

		public bool isEmote;

		public bool isChain;

		public bool isSequential;

		public int chainMax;

		public float chainInterval = 1f;

		public float chargeTime = 2f;

		public int index;

		public PlayerAnims nextSequence = PlayerAnims.None;
	}
	[PublicAPI]
	public static class AssetBundleManager
	{
		private static readonly Dictionary<string, AssetBundle> CachedBundles = new Dictionary<string, AssetBundle>();

		public static T LoadAsset<T>(string assetBundle, string prefab) where T : Object
		{
			AssetBundle assetBundle2 = GetAssetBundle(assetBundle);
			return ((Object)(object)assetBundle2 == (Object)null) ? default(T) : assetBundle2.LoadAsset<T>(prefab);
		}

		public static AssetBundle GetAssetBundle(string fileName)
		{
			if (CachedBundles.TryGetValue(fileName, out var value))
			{
				return value;
			}
			AssetBundle val = AssetBundle.GetAllLoadedAssetBundles().FirstOrDefault((Func<AssetBundle, bool>)((AssetBundle b) => ((Object)b).name == fileName));
			if ((Object)(object)val != (Object)null)
			{
				CachedBundles[fileName] = val;
				return val;
			}
			Assembly executingAssembly = Assembly.GetExecutingAssembly();
			string name = executingAssembly.GetManifestResourceNames().Single((string str) => str.EndsWith(fileName));
			using Stream stream = executingAssembly.GetManifestResourceStream(name);
			AssetBundle val2 = AssetBundle.LoadFromStream(stream);
			CachedBundles[fileName] = val2;
			return val2;
		}
	}
	public class Clone
	{
		private GameObject Prefab;

		private readonly string PrefabName;

		private readonly string NewName;

		private bool Loaded;

		public event Action<GameObject> OnCreated;

		public Clone(string prefabName, string newName)
		{
			PrefabName = prefabName;
			NewName = newName;
			PrefabManager.Clones.Add(this);
		}

		internal void Create()
		{
			if (!Loaded)
			{
				GameObject prefab = Helpers.GetPrefab(PrefabName);
				if ((Object)(object)prefab != (Object)null)
				{
					Prefab = Object.Instantiate<GameObject>(prefab, CloneManager.GetRootTransform(), false);
					((Object)Prefab).name = NewName;
					PrefabManager.RegisterPrefab(Prefab);
					this.OnCreated?.Invoke(Prefab);
					CloneManager.clones[((Object)Prefab).name] = Prefab;
					Loaded = true;
				}
			}
		}
	}
	public static class CloneManager
	{
		public static GameObject root;

		internal static readonly Dictionary<string, GameObject> clones;

		internal static readonly Dictionary<string, GameObject> norsemen;

		static CloneManager()
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Expected O, but got Unknown
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Expected O, but got Unknown
			clones = new Dictionary<string, GameObject>();
			norsemen = new Dictionary<string, GameObject>();
			root = new GameObject("Norsemen_prefab_root");
			Object.DontDestroyOnLoad((Object)root);
			root.SetActive(false);
		}

		public static Transform GetRootTransform()
		{
			return root.transform;
		}
	}
	public static class CommandManager
	{
		[Serializable]
		[CompilerGenerated]
		private sealed class _003C_003Ec
		{
			public static readonly _003C_003Ec _003C_003E9 = new _003C_003Ec();

			public static ConsoleEventFailable _003C_003E9__3_0;

			internal object _003CPatch_Terminal_Awake_003Eb__3_0(ConsoleEventArgs args)
			{
				if (args.Length < 2)
				{
					return false;
				}
				if (!commands.TryGetValue(args[1], out var value))
				{
					return false;
				}
				return value.Run(args);
			}

			internal bool _003CPatch_Terminal_Awake_003Eb__3_1(KeyValuePair<string, NorseCommand> x)
			{
				return !x.Value.IsSecret();
			}

			internal string _003CPatch_Terminal_Awake_003Eb__3_2(KeyValuePair<string, NorseCommand> x)
			{
				return x.Key;
			}
		}

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

			public static ConsoleEventFailable <>9__7_1;

			public static Func<KeyValuePair<string, NorseCommand>, bool> <>9__7_2;

			public static Func<KeyValuePair<string, NorseCommand>, string> <>9__7_3;

			public static ConsoleOptionsFetcher <>9__7_0;

			internal object <Patch_Terminal_Awake>b__7_1(ConsoleEventArgs args)
			{
				if (args.Length < 2)
				{
					return false;
				}
				NorseCommand value;
				return (!commands.TryGetValue(args[1], out value)) ? ((object)false) : ((object)value.Run(args));
			}

			internal List<string> <Patch_Terminal_Awake>b__7_0()
			{
				return (from x in commands
					where !x.Value.IsSecret()
					select x.Key).ToList();
			}

			internal bool <Patch_Terminal_Awake>b__7_2(KeyValuePair<string, NorseCommand> x)
			{
				return !x.Value.IsSecret();
			}

			internal string <Patch_Terminal_Awake>b__7_3(KeyValuePair<string, NorseCommand> x)
			{
				return x.Key;
			}
		}

		private static readonly string startCommand;

		public static readonly Dictionary<string, NorseCommand> commands;

		private static readonly List<string> tabOptions;

		private static int tabIndex;

		private static string lastTabWord;

		static CommandManager()
		{
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Expected O, but got Unknown
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Expected O, but got Unknown
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f2: Expected O, but got Unknown
			tabOptions = new List<string>();
			tabIndex = -1;
			lastTabWord = "";
			commands = new Dictionary<string, NorseCommand>();
			Harmony harmony = NorsemenPlugin.instance._harmony;
			startCommand = "Norsemen".ToLower();
			harmony.Patch((MethodBase)AccessTools.Method(typeof(Terminal), "Awake", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(AccessTools.Method(typeof(CommandManager), "Patch_Terminal_Awake", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			harmony.Patch((MethodBase)AccessTools.Method(typeof(Terminal), "updateSearch", (Type[])null, (Type[])null), new HarmonyMethod(AccessTools.Method(typeof(CommandManager), "Patch_Terminal_UpdateSearch", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			harmony.Patch((MethodBase)AccessTools.Method(typeof(Terminal), "tabCycle", (Type[])null, (Type[])null), new HarmonyMethod(AccessTools.Method(typeof(CommandManager), "Patch_Terminal_TabCycle", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		}

		private static void Patch_Terminal_Awake()
		{
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Expected O, but got Unknown
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Expected O, but got Unknown
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Expected O, but got Unknown
			string text = startCommand;
			object obj = _003C_003Ec._003C_003E9__3_0;
			if (obj == null)
			{
				object obj2 = <>c.<>9__7_1;
				if (obj2 == null)
				{
					NorseCommand value;
					ConsoleEventFailable val = (ConsoleEventArgs args) => (args.Length < 2) ? ((object)false) : ((!commands.TryGetValue(args[1], out value)) ? ((object)false) : ((object)value.Run(args)));
					<>c.<>9__7_1 = val;
					obj2 = (object)val;
				}
				obj = (_003C_003Ec._003C_003E9__3_0 = (ConsoleEventFailable)obj2);
			}
			ConsoleEventFailable val2 = (ConsoleEventFailable)obj;
			object obj3 = <>c.<>9__7_0;
			if (obj3 == null)
			{
				ConsoleOptionsFetcher val3 = () => (from x in commands
					where !x.Value.IsSecret()
					select x.Key).ToList();
				<>c.<>9__7_0 = val3;
				obj3 = (object)val3;
			}
			new ConsoleCommand(text, "use help to find available commands", val2, false, false, false, false, false, false, (ConsoleOptionsFetcher)obj3, false, false, false);
		}

		private static bool Patch_Terminal_UpdateSearch(Terminal __instance, string word)
		{
			if ((Object)(object)__instance.m_search == (Object)null)
			{
				return true;
			}
			string[] array = ((TMP_InputField)__instance.m_input).text.Split(new char[1] { ' ' });
			if (array.Length < 3)
			{
				return true;
			}
			if (array[0] != startCommand)
			{
				return true;
			}
			return HandleSearch(__instance, word, array);
		}

		private static bool HandleSearch(Terminal __instance, string word, string[] strArray)
		{
			if (!commands.TryGetValue(strArray[1], out var value))
			{
				return true;
			}
			if (value.HasOptions() && strArray.Length == 3)
			{
				List<string> list = value.FetchOptions();
				string currentSearch = strArray[2];
				List<string> list2;
				if (!Utility.IsNullOrWhiteSpace(currentSearch))
				{
					int num = list.IndexOf(currentSearch);
					list2 = ((num != -1) ? list.GetRange(num, list.Count - num) : list);
					list2 = list2.FindAll((string x) => x.ToLower().Contains(currentSearch.ToLower()));
				}
				else
				{
					list2 = list;
				}
				if (list2.Count <= 0)
				{
					__instance.m_search.text = value.m_description;
				}
				else
				{
					list2.Remove(word);
					__instance.m_search.text = "";
					int num2 = 10;
					int num3 = Math.Min(list2.Count, num2);
					for (int num4 = 0; num4 < num3; num4++)
					{
						string text = list2[num4];
						TMP_Text search = __instance.m_search;
						search.text = search.text + text + " ";
					}
					if (list2.Count <= num2)
					{
						return false;
					}
					int num5 = list2.Count - num2;
					TMP_Text search2 = __instance.m_search;
					search2.text += $"... {num5} more.";
				}
			}
			else
			{
				__instance.m_search.text = value.m_description;
			}
			return false;
		}

		private static bool Patch_Terminal_TabCycle(Terminal __instance, string word, List<string> options, bool usePrefix)
		{
			if (options == null || options.Count == 0)
			{
				return true;
			}
			if (usePrefix)
			{
				if (word.Length < 1)
				{
					return true;
				}
				word = word.Substring(1);
			}
			return HandleTabCycle(__instance, word, options, usePrefix);
		}

		private static bool HandleTabCycle(Terminal __instance, string word, List<string> options, bool usePrefix)
		{
			TMP_InputField input = (TMP_InputField)(object)__instance.m_input;
			string text = input.text;
			string[] array = text.Split(new char[1] { ' ' });
			if (array.Length < 2 || !string.Equals(array[0], startCommand, StringComparison.CurrentCultureIgnoreCase) || !commands.ContainsKey(array[1].ToLower()))
			{
				return true;
			}
			word = word.ToLower();
			if (lastTabWord != word)
			{
				lastTabWord = word;
				tabOptions.Clear();
				tabIndex = -1;
				if (word.Length == 0)
				{
					tabOptions.AddRange(options);
				}
				else
				{
					foreach (string option in options)
					{
						if (option != null && option.Length >= word.Length && option.Substring(0, word.Length).Equals(word, StringComparison.CurrentCultureIgnoreCase))
						{
							tabOptions.Add(option);
						}
					}
				}
				tabOptions.Sort();
			}
			if (tabOptions.Count == 0)
			{
				return false;
			}
			tabIndex++;
			if (tabIndex >= tabOptions.Count)
			{
				tabIndex = 0;
			}
			string text2 = tabOptions[tabIndex];
			int num = -1;
			int num2 = 0;
			for (int i = 0; i < text.Length; i++)
			{
				if (text[i] == ' ')
				{
					num2++;
					if (num2 == 2)
					{
						num = i;
						break;
					}
				}
			}
			if (num >= 0)
			{
				input.text = text.Substring(0, num + 1) + text2;
			}
			else if (array.Length == 2)
			{
				input.text = text + " " + text2;
			}
			input.caretPosition = input.text.Length;
			return false;
		}
	}
	[Serializable]
	public class ConditioanlWeightedItem
	{
		public string PrefabName = "";

		public string RequiredDefeatKey = "";

		public float Weight = 1f;

		[YamlIgnore]
		private Viking.ConditionalRandomWeapon _weapon;

		[YamlIgnore]
		public Viking.ConditionalRandomWeapon weapon
		{
			get
			{
				if (_weapon != null)
				{
					return _weapon;
				}
				_weapon = new Viking.ConditionalRandomWeapon
				{
					m_requiredDefeatKey = RequiredDefeatKey,
					m_weight = Weight,
					m_prefab = Helpers.GetPrefab(PrefabName)
				};
				return _weapon;
			}
		}

		public ConditioanlWeightedItem(string prefabName, string requiredDefeatKey, float weight)
		{
			PrefabName = prefabName;
			RequiredDefeatKey = requiredDefeatKey;
			Weight = weight;
		}

		public ConditioanlWeightedItem()
		{
		}
	}
	[Serializable]
	public class ConditionalChanceItem
	{
		public string PrefabName = "";

		public string RequiredDefeatKey = "";

		public float Chance = 0.5f;

		public int Min = 1;

		public int Max = 1;

		[YamlIgnore]
		private Viking.ConditionalRandomItem _item;

		[YamlIgnore]
		public Viking.ConditionalRandomItem item
		{
			get
			{
				if (_item != null)
				{
					return _item;
				}
				_item = new Viking.ConditionalRandomItem
				{
					m_prefab = Helpers.GetPrefab(PrefabName),
					m_requiredDefeatKey = RequiredDefeatKey,
					m_chance = Chance,
					m_min = Min,
					m_max = Max
				};
				return _item;
			}
		}

		public ConditionalChanceItem(string prefab, int min = 1, int max = 1, float chance = 0.5f, string requiredDefeatKey = "")
		{
			PrefabName = prefab;
			RequiredDefeatKey = requiredDefeatKey;
			Chance = chance;
			Min = min;
			Max = max;
		}

		public ConditionalChanceItem()
		{
		}
	}
	[Serializable]
	public class ConditionalWeightedSet
	{
		public List<string> PrefabNames = new List<string>();

		public string RequiredDefeatKey = "";

		public float Weight = 1f;

		[YamlIgnore]
		private Viking.ConditionalItemSet _set;

		[YamlIgnore]
		public Viking.ConditionalItemSet set
		{
			get
			{
				if (_set != null)
				{
					return _set;
				}
				_set = new Viking.ConditionalItemSet
				{
					m_requiredDefeatKey = RequiredDefeatKey,
					m_weight = Weight,
					m_items = PrefabNames.Select(Helpers.GetPrefab).ToArray()
				};
				return _set;
			}
		}

		public ConditionalWeightedSet(string requiredDefeatKey, float weight, params string[] prefabNames)
		{
			RequiredDefeatKey = requiredDefeatKey;
			PrefabNames.Add(prefabNames);
			Weight = weight;
		}

		public ConditionalWeightedSet()
		{
		}
	}
	public static class ConfigManager
	{
		public static readonly ISerializer serializer;

		public static readonly IDeserializer deserializer;

		private static readonly ConfigFile Config;

		internal static readonly ConfigSync ConfigSync;

		private static readonly string ConfigFileName;

		private static readonly string ConfigFileFullPath;

		public static readonly string DirectoryPath;

		private static readonly ConfigEntry<LogLevel> logLevels;

		private static readonly ConfigEntry<Toggle> canHaveStars;

		private static readonly ConfigEntry<string> reviveRequirements;

		public static bool ShouldLog(LogLevel type)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			return ((Enum)logLevels.Value).HasFlag((Enum)(object)type);
		}

		public static bool CanHaveStars()
		{
			return canHaveStars.Value == Toggle.On;
		}

		public static Requirement[] GetReviveRequirements()
		{
			return new RequirementList(reviveRequirements.Value).ToPieceRequirements();
		}

		static ConfigManager()
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_014e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0159: Expected O, but got Unknown
			//IL_0197: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a4: Expected O, but got Unknown
			serializer = ((BuilderSkeleton<SerializerBuilder>)(object)new SerializerBuilder().ConfigureDefaultValuesHandling((DefaultValuesHandling)7).DisableAliases()).WithNamingConvention(CamelCaseNamingConvention.Instance).Build();
			deserializer = ((BuilderSkeleton<DeserializerBuilder>)(object)new DeserializerBuilder().IgnoreUnmatchedProperties()).WithNamingConvention(CamelCaseNamingConvention.Instance).Build();
			Config = ((BaseUnityPlugin)NorsemenPlugin.instance).Config;
			ConfigFileName = "RustyMods.Norsemen.cfg";
			ConfigFileFullPath = Path.Combine(Paths.ConfigPath, ConfigFileName);
			ConfigSync = new ConfigSync("RustyMods.Norsemen")
			{
				DisplayName = "Norsemen Continued",
				CurrentVersion = "0.4.1",
				MinimumRequiredVersion = "0.4.1"
			};
			DirectoryPath = Path.Combine(Paths.ConfigPath, "Norsemen");
			if (!Directory.Exists(DirectoryPath))
			{
				Directory.CreateDirectory(DirectoryPath);
			}
			ConfigEntry<Toggle> lockingConfig = config("1 - General", "Lock Configuration", Toggle.On, "If on, the configuration is locked and can be changed by server admins only.");
			ConfigSync.AddLockingConfigEntry<Toggle>(lockingConfig);
			logLevels = config<LogLevel>("1 - General", "Log Levels", (LogLevel)2, "Set log levels", synchronizedSetting: false);
			canHaveStars = config("Settings", "Can Have Stars", Toggle.On, "If on, norsemen can have stars");
			reviveRequirements = config("Settings", "Revive Cost", "", new ConfigDescription("Cost to revive viking", (AcceptableValueBase)null, new object[1] { RequirementList.attributes }));
			Harmony harmony = NorsemenPlugin.instance._harmony;
			harmony.Patch((MethodBase)AccessTools.Method(typeof(ZNet), "Awake", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(AccessTools.Method(typeof(ConfigManager), "Patch_ZNet_Awake", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		}

		public static void Patch_ZNet_Awake(ZNet __instance)
		{
			CustomizationManager.UpdateSync(__instance);
			TalkManager.UpdateSync(__instance);
			NameGenerator.UpdateSync(__instance);
		}

		public static void SetupWatcher()
		{
			FileSystemWatcher fileSystemWatcher = new FileSystemWatcher(Paths.ConfigPath, ConfigFileName);
			fileSystemWatcher.Changed += ReadConfigValues;
			fileSystemWatcher.Created += ReadConfigValues;
			fileSystemWatcher.Renamed += ReadConfigValues;
			fileSystemWatcher.IncludeSubdirectories = true;
			fileSystemWatcher.SynchronizingObject = ThreadingHelper.SynchronizingObject;
			fileSystemWatcher.EnableRaisingEvents = true;
		}

		private static void ReadConfigValues(object sender, FileSystemEventArgs e)
		{
			if (!File.Exists(ConfigFileFullPath))
			{
				return;
			}
			try
			{
				NorsemenPlugin.LogDebug("ReadConfigValues called");
				Config.Reload();
			}
			catch
			{
				NorsemenPlugin.LogError("There was an issue loading your " + ConfigFileName);
				NorsemenPlugin.LogError("Please check your config entries for spelling and format!");
			}
		}

		public static ConfigEntry<T> config<T>(string group, string name, T value, ConfigDescription description, bool synchronizedSetting = true)
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Expected O, but got Unknown
			ConfigDescription val = new ConfigDescription(description.Description + (synchronizedSetting ? " [Synced with Server]" : " [Not Synced with Server]"), description.AcceptableValues, description.Tags);
			ConfigEntry<T> val2 = Config.Bind<T>(group, name, value, val);
			SyncedConfigEntry<T> syncedConfigEntry = ConfigSync.AddConfigEntry<T>(val2);
			syncedConfigEntry.SynchronizedConfig = synchronizedSetting;
			return val2;
		}

		public static ConfigEntry<T> config<T>(string group, string name, T value, string description, bool synchronizedSetting = true)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Expected O, but got Unknown
			return config(group, name, value, new ConfigDescription(description, (AcceptableValueBase)null, Array.Empty<object>()), synchronizedSetting);
		}
	}
	public class ConfigurationManagerAttributes
	{
		[UsedImplicitly]
		public int? Order;

		[UsedImplicitly]
		public bool? Browsable;

		[UsedImplicitly]
		[_003C812f407f_002D18f8_002D4794_002Dbefe_002D7b53d43aa20f_003ENullable(2)]
		public string Category;

		[UsedImplicitly]
		[_003C812f407f_002D18f8_002D4794_002Dbefe_002D7b53d43aa20f_003ENullable(new byte[] { 2, 1 })]
		public Action<ConfigEntryBase> CustomDrawer;
	}
	public static class CustomizationManager
	{
		public static readonly List<string> beards;

		public static readonly List<string> hairs;

		public static readonly List<Color> hairColors;

		public static readonly List<Color> skinColors;

		public static readonly string FileName;

		public static readonly string FilePath;

		public static Dictionary<Biome, Equipment> equipment;

		internal static readonly CustomSyncedValue<string> sync;

		public static Color GetRandomSkinColor()
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			int index = Random.Range(0, skinColors.Count);
			return skinColors[index];
		}

		public static void GetHairAndBeards(ObjectDB db)
		{
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Invalid comparison between Unknown and I4
			foreach (GameObject item in db.m_items)
			{
				ItemDrop component = item.GetComponent<ItemDrop>();
				if (!((Object)(object)component == (Object)null) && (int)component.m_itemData.m_shared.m_itemType == 10)
				{
					if (Utils.CustomStartsWith(((Object)item).name, "Beard"))
					{
						beards.Add(((Object)item).name);
					}
					else if (Utils.CustomStartsWith(((Object)item).name, "Hair"))
					{
						hairs.Add(((Object)item).name);
					}
				}
			}
			beards.RemoveAll((string x) => x.Contains("_"));
			hairs.RemoveAll((string x) => x.Contains("_"));
		}

		public static void Setup()
		{
			GetOrSerialize();
			SetupFileWatcher();
			sync.ValueChanged += OnConfigChange;
		}

		public static void OnConfigChange()
		{
			if ((Object)(object)ZNet.instance == (Object)null || ZNet.instance.IsServer())
			{
				return;
			}
			string value = sync.Value;
			if (string.IsNullOrEmpty(value))
			{
				return;
			}
			try
			{
				Dictionary<Biome, Equipment> other = ConfigManager.deserializer.Deserialize<Dictionary<Biome, Equipment>>(value);
				equipment.Clear();
				equipment.AddRange(other);
			}
			catch
			{
				NorsemenPlugin.LogError("Failed to deserialize server's equipments");
			}
		}

		public static void SetupFileWatcher()
		{
			FileSystemWatcher fileSystemWatcher = new FileSystemWatcher(ConfigManager.DirectoryPath, FileName);
			fileSystemWatcher.Changed += ReadConfigValues;
			fileSystemWatcher.Created += ReadConfigValues;
			fileSystemWatcher.Renamed += ReadConfigValues;
			fileSystemWatcher.IncludeSubdirectories = true;
			fileSystemWatcher.SynchronizingObject = ThreadingHelper.SynchronizingObject;
			fileSystemWatcher.EnableRaisingEvents = true;
		}

		public static void ReadConfigValues(object sender, FileSystemEventArgs e)
		{
			if ((Object)(object)ZNet.instance == (Object)null || !ZNet.instance.IsServer())
			{
				return;
			}
			try
			{
				string text = File.ReadAllText(FilePath);
				Dictionary<Biome, Equipment> dictionary = ConfigManager.deserializer.Deserialize<Dictionary<Biome, Equipment>>(text);
				equipment = dictionary;
				UpdateSync(ZNet.instance);
				NorsemenPlugin.LogDebug(FileName + " changed");
			}
			catch (Exception ex)
			{
				NorsemenPlugin.LogError("Failed to deserialize " + FileName);
				Debug.LogError((object)ex.Message);
			}
		}

		public static void UpdateSync(ZNet net)
		{
			if (net.IsServer())
			{
				string value = ConfigManager.serializer.Serialize((object)equipment);
				sync.Value = value;
			}
		}

		public static void GetOrSerialize()
		{
			if (!File.Exists(FilePath))
			{
				string file = EmbeddedResourceManager.GetFile(FileName);
				equipment = ConfigManager.deserializer.Deserialize<Dictionary<Biome, Equipment>>(file);
				File.WriteAllText(FilePath, file);
			}
			else
			{
				Read();
			}
		}

		public static void Read()
		{
			try
			{
				string text = File.ReadAllText(FilePath);
				Dictionary<Biome, Equipment> dictionary = ConfigManager.deserializer.Deserialize<Dictionary<Biome, Equipment>>(text);
				equipment = dictionary;
			}
			catch (Exception ex)
			{
				NorsemenPlugin.LogError("Failed to deserialize: " + FileName);
				Debug.LogError((object)ex.Message);
			}
		}

		public static void Add(Biome biome, params ConditionalWeightedSet[] set)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			if (!equipment.ContainsKey(biome))
			{
				equipment[biome] = new Equipment();
			}
			equipment[biome].RandomSets.Add(set);
		}

		public static void Add(Biome biome, params ConditionalChanceItem[] item)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			if (!equipment.ContainsKey(biome))
			{
				equipment[biome] = new Equipment();
			}
			equipment[biome].RandomItems.Add(item);
		}

		public static void Add(Biome biome, params ConditioanlWeightedItem[] weapon)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			if (!equipment.ContainsKey(biome))
			{
				equipment[biome] = new Equipment();
			}
			equipment[biome].RandomWeapons.Add(weapon);
		}

		public static List<ConditionalWeightedSet> GetSets(Biome biome)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			if (!equipment.TryGetValue(biome, out var value))
			{
				return new List<ConditionalWeightedSet>();
			}
			return value.RandomSets;
		}

		public static List<ConditionalChanceItem> GetItems(Biome biome)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			if (!equipment.TryGetValue(biome, out var value))
			{
				return new List<ConditionalChanceItem>();
			}
			return value.RandomItems;
		}

		public static List<ConditioanlWeightedItem> GetWeapons(Biome biome)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			if (!equipment.TryGetValue(biome, out var value))
			{
				return new List<ConditioanlWeightedItem>();
			}
			return value.RandomWeapons;
		}

		static CustomizationManager()
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_011b: Unknown result type (might be due to invalid IL or missing references)
			//IL_013b: Unknown result type (might be due to invalid IL or missing references)
			//IL_015b: Unknown result type (might be due to invalid IL or missing references)
			//IL_017b: Unknown result type (might be due to invalid IL or missing references)
			//IL_019b: 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_01db: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0225: Unknown result type (might be due to invalid IL or missing references)
			//IL_0245: Unknown result type (might be due to invalid IL or missing references)
			//IL_0265: Unknown result type (might be due to invalid IL or missing references)
			//IL_0285: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0305: Unknown result type (might be due to invalid IL or missing references)
			//IL_0325: Unknown result type (might be due to invalid IL or missing references)
			//IL_0345: Unknown result type (might be due to invalid IL or missing references)
			//IL_0365: Unknown result type (might be due to invalid IL or missing references)
			//IL_0385: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e5: Unknown result type (might be due to invalid IL or missing references)
			beards = new List<string>();
			hairs = new List<string>();
			hairColors = new List<Color>
			{
				Color.black,
				new Color(0.98f, 0.94f, 0.75f, 1f),
				new Color(0.63f, 0.36f, 0f, 1f),
				new Color(0.15f, 0.08f, 0.05f, 1f),
				new Color(0.35f, 0.25f, 0.15f, 1f),
				new Color(0.55f, 0.45f, 0.35f, 1f),
				new Color(0.95f, 0.87f, 0.51f, 1f),
				new Color(0.85f, 0.75f, 0.45f, 1f),
				new Color(0.72f, 0.65f, 0.52f, 1f),
				new Color(0.45f, 0.18f, 0.08f, 1f),
				new Color(0.55f, 0.12f, 0.05f, 1f),
				new Color(0.72f, 0.25f, 0.12f, 1f),
				new Color(0.4f, 0.4f, 0.4f, 1f),
				new Color(0.65f, 0.65f, 0.65f, 1f),
				new Color(0.88f, 0.88f, 0.9f, 1f),
				new Color(0.25f, 0.25f, 0.28f, 1f)
			};
			skinColors = new List<Color>
			{
				new Color(1f, 1f, 1f, 1f),
				new Color(1f, 0.95f, 0.92f, 1f),
				new Color(1f, 0.92f, 0.86f, 1f),
				new Color(1f, 0.94f, 0.88f, 1f),
				new Color(1f, 0.9f, 0.82f, 1f),
				new Color(1f, 0.88f, 0.78f, 1f),
				new Color(0.98f, 0.85f, 0.72f, 1f),
				new Color(0.95f, 0.82f, 0.68f, 1f),
				new Color(0.92f, 0.78f, 0.62f, 1f),
				new Color(0.88f, 0.72f, 0.56f, 1f),
				new Color(0.85f, 0.68f, 0.52f, 1f),
				new Color(0.78f, 0.62f, 0.48f, 1f),
				new Color(1f, 0.88f, 0.75f, 1f),
				new Color(0.98f, 0.9f, 0.8f, 1f),
				new Color(0.95f, 0.86f, 0.76f, 1f)
			};
			FileName = "Equipment.yml";
			FilePath = Path.Combine(ConfigManager.DirectoryPath, FileName);
			equipment = new Dictionary<Biome, Equipment>();
			sync = new CustomSyncedValue<string>(ConfigManager.ConfigSync, "RustyMods.Norsemen.Equipment.Sync", "");
		}
	}
	public class EffectListRef
	{
		public class EffectDataRef
		{
			public readonly string prefabName;

			public int variant;

			public bool attach;

			public bool follow;

			public bool inheritParentRotation;

			public bool inheritParentScale;

			public bool multiplyParentVisualScale;

			public bool randomRotation;

			public bool scale;

			public string childTransform = string.Empty;

			private EffectData _data;

			public EffectDataRef(string prefabName)
			{
				this.prefabName = prefabName;
			}

			public EffectData ToEffectData()
			{
				//IL_0055: Unknown result type (might be due to invalid IL or missing references)
				//IL_005a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0061: Unknown result type (might be due to invalid IL or missing references)
				//IL_006d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0079: Unknown result type (might be due to invalid IL or missing references)
				//IL_0085: 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_009d: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d2: Expected O, but got Unknown
				//IL_0049: Unknown result type (might be due to invalid IL or missing references)
				//IL_004f: Expected O, but got Unknown
				if (_data != null)
				{
					return _data;
				}
				GameObject prefab = Helpers.GetPrefab(prefabName);
				if ((Object)(object)prefab == (Object)null)
				{
					NorsemenPlugin.LogError("Effect Data Reference invalid: " + prefabName);
					return new EffectData();
				}
				_data = new EffectData
				{
					m_prefab = prefab,
					m_variant = variant,
					m_attach = attach,
					m_follow = follow,
					m_inheritParentRotation = inheritParentRotation,
					m_inheritParentScale = inheritParentScale,
					m_multiplyParentVisualScale = multiplyParentVisualScale,
					m_randomRotation = randomRotation,
					m_scale = scale,
					m_childTransform = childTransform
				};
				return _data;
			}
		}

		public List<EffectDataRef> dataRefs = new List<EffectDataRef>();

		private readonly List<EffectData> data = new List<EffectData>();

		private EffectList _effects;

		public EffectList Effects
		{
			get
			{
				//IL_005e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0068: Expected O, but got Unknown
				if (_effects != null)
				{
					return _effects;
				}
				foreach (EffectDataRef dataRef in dataRefs)
				{
					data.Add(dataRef.ToEffectData());
				}
				_effects = new EffectList();
				_effects.m_effectPrefabs = data.ToArray();
				return _effects;
			}
		}

		public GameObject[] Create(Vector3 basePos, Quaternion baseRot, Transform baseParent = null, float scale = 1f, int variant = -1)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			return Effects.Create(basePos, baseRot, baseParent, scale, variant, default(ZDOID));
		}

		public EffectListRef(params string[] effects)
		{
			Add(effects);
		}

		public EffectListRef(params EffectDataRef[] refs)
		{
			dataRefs.AddRange(refs);
		}

		public EffectListRef()
		{
		}

		public void Add(params string[] effects)
		{
			foreach (string prefabName in effects)
			{
				dataRefs.Add(new EffectDataRef(prefabName));
			}
		}

		public void Add(params EffectDataRef[] refs)
		{
			dataRefs.AddRange(refs);
		}
	}
	public static class EmbeddedResourceManager
	{
		public static readonly Assembly assembly = Assembly.GetExecutingAssembly();

		public static string GetFile(string fileName, string directory = "Files")
		{
			string name = "Norsemen." + directory + "." + fileName;
			using Stream stream = assembly.GetManifestResourceStream(name);
			if (stream == null)
			{
				throw new FileNotFoundException("Embedded resource " + fileName + " not found.");
			}
			using StreamReader streamReader = new StreamReader(stream);
			return streamReader.ReadToEnd();
		}
	}
	public enum Emotion
	{
		Aggressive,
		Passive
	}
	public class EnvList
	{
		public static readonly ConfigurationManagerAttributes attributes = new ConfigurationManagerAttributes
		{
			CustomDrawer = DrawTable
		};

		public readonly List<string> Envs;

		public EnvList(List<string> envs)
		{
			Envs = envs;
			if (Envs.Count == 0)
			{
				Envs.Add("");
			}
		}

		public EnvList(string envs)
		{
			Envs = envs.Split(new char[1] { ',' }).ToList();
		}

		public EnvList()
		{
			Envs = new List<string> { "" };
		}

		public void Add(string env)
		{
			Envs.Add(env);
		}

		public List<string> GetValidatedList()
		{
			return ((Object)(object)EnvMan.instance != (Object)null) ? Envs.Where((string env) => EnvMan.instance.m_environments.Any((EnvSetup e) => e.m_name == env)).ToList() : Envs.Where((string env) => !Utility.IsNullOrWhiteSpace(env)).ToList();
		}

		public override string ToString()
		{
			return string.Join(",", Envs);
		}

		public static void DrawTable(ConfigEntryBase cfg)
		{
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Expected O, but got Unknown
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f9: Expected O, but got Unknown
			//IL_010a: Unknown result type (might be due to invalid IL or missing references)
			//IL_010f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0125: Expected O, but got Unknown
			bool valueOrDefault = cfg.Description.Tags.Select((object a) => (a.GetType().Name == "ConfigurationManagerAttributes") ? ((bool?)a.GetType().GetField("ReadOnly")?.GetValue(a)) : ((bool?)null)).FirstOrDefault((bool? v) => v.HasValue) == true;
			List<string> list = new List<string>();
			bool flag = false;
			GUILayout.BeginVertical(Array.Empty<GUILayoutOption>());
			foreach (string env in new EnvList((string)cfg.BoxedValue).Envs)
			{
				GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
				string text = GUILayout.TextField(env, new GUIStyle(GUI.skin.textField), Array.Empty<GUILayoutOption>());
				string item = (valueOrDefault ? env : text);
				bool flag2 = GUILayout.Button("x", new GUIStyle(GUI.skin.button)
				{
					fixedWidth = 21f
				}, Array.Empty<GUILayoutOption>());
				bool flag3 = GUILayout.Button("+", new GUIStyle(GUI.skin.button)
				{
					fixedWidth = 21f
				}, Array.Empty<GUILayoutOption>());
				GUILayout.EndHorizontal();
				if (flag2 && !valueOrDefault)
				{
					flag = true;
				}
				else
				{
					list.Add(item);
				}
				if (flag3 && !valueOrDefault)
				{
					flag = true;
					list.Add("");
				}
			}
			GUILayout.EndVertical();
			if (flag)
			{
				cfg.BoxedValue = new EnvList(list).ToString();
			}
		}
	}
	[Serializable]
	public class Equipment
	{
		public List<ConditionalChanceItem> RandomItems = new List<ConditionalChanceItem>();

		public List<ConditionalWeightedSet> RandomSets = new List<ConditionalWeightedSet>();

		public List<ConditioanlWeightedItem> RandomWeapons = new List<ConditioanlWeightedItem>();
	}
	public class Faction
	{
		public readonly string name;

		public int hash;

		private readonly bool friendly;

		public readonly string hoverColor;

		public readonly bool targetTames;

		public readonly Faction faction;

		public readonly ConfigEntry<Toggle> isFriendly;

		public Faction(string name, bool friendly)
		{
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			hoverColor = "white";
			targetTames = false;
			this.name = name;
			this.friendly = friendly;
			hash = StringExtensionMethods.GetStableHashCode(name);
			faction = FactionManager.GetFaction(name);
			isFriendly = ConfigManager.config(name + " Faction", "Friendly", friendly ? Toggle.On : Toggle.Off, "If on, " + name + " are friendly unless aggravated");
			FactionManager.customFactions[faction] = this;
		}

		public bool IsFriendly()
		{
			return isFriendly.Value == Toggle.On;
		}
	}
	public static class FactionManager
	{
		public static readonly Dictionary<Faction, Faction> customFactions;

		public static readonly Dictionary<string, Faction> factions;

		static FactionManager()
		{
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Expected O, but got Unknown
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Expected O, but got Unknown
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f2: Expected O, but got Unknown
			//IL_0121: Unknown result type (might be due to invalid IL or missing references)
			//IL_012e: Expected O, but got Unknown
			customFactions = new Dictionary<Faction, Faction>();
			factions = new Dictionary<string, Faction>();
			Harmony harmony = NorsemenPlugin.instance._harmony;
			harmony.Patch((MethodBase)AccessTools.Method(typeof(Enum), "GetValues", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(AccessTools.Method(typeof(FactionManager), "Patch_Enum_GetValues", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			harmony.Patch((MethodBase)AccessTools.Method(typeof(Enum), "GetNames", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(AccessTools.Method(typeof(FactionManager), "Patch_Enum_GetNames", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			harmony.Patch((MethodBase)AccessTools.Method(typeof(BaseAI), "IsEnemy", new Type[2]
			{
				typeof(Character),
				typeof(Character)
			}, (Type[])null), new HarmonyMethod(AccessTools.Method(typeof(FactionManager), "Patch_BaseAI_IsEnemy", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			harmony.Patch((MethodBase)AccessTools.Method(typeof(Enum), "ToString", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(AccessTools.Method(typeof(FactionManager), "Patch_Enum_ToString", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		}

		private static bool Patch_BaseAI_IsEnemy(Character a, Character b, ref bool __result)
		{
			if (!(a is Viking) && !(b is Viking))
			{
				return true;
			}
			__result = IsEnemy(a, b);
			return false;
		}

		public static bool IsEnemy(Character a, Character b)
		{
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)a == (Object)(object)b)
			{
				return false;
			}
			if (a is Viking viking)
			{
				return IsEnemy(viking, b);
			}
			if (b is Viking viking2)
			{
				return IsEnemy(viking2, a);
			}
			return a.GetFaction() != b.GetFaction();
		}

		public static bool IsEnemy(Viking viking, Character character)
		{
			if (character is Viking b)
			{
				return IsEnemyToOtherViking(viking, b);
			}
			if (character.IsPlayer())
			{
				return IsEnemyToPlayers(viking);
			}
			return IsEnemyToCreatures(viking, character);
		}

		public static bool IsEnemyToCreatures(Viking viking, Character character)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Invalid comparison between Unknown and I4
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Expected I4, but got Unknown
			if (!customFactions.TryGetValue(((Character)viking).GetFaction(), out var value))
			{
				return true;
			}
			bool flag = ((Character)viking).IsTamed();
			bool flag2 = character.IsTamed();
			if (flag && flag2)
			{
				return false;
			}
			Faction faction = character.GetFaction();
			Faction val = faction;
			if ((int)val != 1)
			{
				switch (val - 8)
				{
				case 0:
					return flag;
				case 2:
					return character.GetBaseAI().IsAggravated();
				case 3:
					return false;
				default:
					if ((Object)(object)((Component)character).GetComponent<Tameable>() != (Object)null)
					{
						return value.targetTames || character.GetBaseAI().IsAlerted();
					}
					return true;
				}
			}
			return !flag;
		}

		public static bool IsEnemyToPlayers(Viking viking)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Invalid comparison between Unknown and I4
			if (!customFactions.TryGetValue(((Character)viking).GetFaction(), out var value))
			{
				return true;
			}
			if (((Character)viking).IsTamed())
			{
				return false;
			}
			if (!value.IsFriendly())
			{
				return true;
			}
			return ((BaseAI)viking.m_vikingAI).IsAggravated() && (int)viking.m_aggravatedReason != 1;
		}

		public static bool IsEnemyToOtherViking(Viking a, Viking b)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			if (!customFactions.TryGetValue(((Character)a).GetFaction(), out var value))
			{
				return true;
			}
			if (!customFactions.TryGetValue(((Character)b).GetFaction(), out var value2))
			{
				return true;
			}
			if (((Character)a).IsTamed() && ((Character)b).IsTamed())
			{
				return false;
			}
			return value != value2;
		}

		private static void Patch_Enum_GetValues(Type enumType, ref Array __result)
		{
			if (enumType == typeof(Faction) && factions.Count != 0)
			{
				Faction[] array = (Faction[])(object)new Faction[__result.Length + factions.Count];
				__result.CopyTo(array, 0);
				factions.Values.CopyTo(array, __result.Length);
				__result = array