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.Net.Http;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Serialization;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using System.Threading.Tasks;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using JetBrains.Annotations;
using Microsoft.CodeAnalysis;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using ServerSync;
using TMPro;
using TortalPortalLite.Core;
using TortalPortalLite.Core.Compat;
using TortalPortalLite.Core.Data;
using TortalPortalLite.Core.Hooks;
using TortalPortalLite.Subsystems.Foundations;
using TortalPortalLite.Subsystems.PlayerInterface;
using TortalPortalLite.Subsystems.Topology;
using TortalPortalLite.Subsystems.WorldOps;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: IgnoresAccessChecksTo("assembly_valheim")]
[assembly: AssemblyCompany("TortalPortalLite")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.9.0")]
[assembly: AssemblyInformationalVersion("1.0.9+e5ec1240d403b653414cd43edf2a8065089039f0")]
[assembly: AssemblyProduct("TortalPortalLite")]
[assembly: AssemblyTitle("TortalPortalLite")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.9.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

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

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

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

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

		public bool SynchronizedConfig = true;

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

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

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

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

		public readonly string Identifier;

		public readonly Type Type;

		private object? boxedValue;

		protected bool localIsOwner;

		public readonly int Priority;

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

		public event Action? ValueChanged;

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

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

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

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

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

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

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

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

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

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

				public volatile int versionMatchQueued = -1;

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

				public readonly ISocket Original;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

		private class PackageEntry
		{
			public string section;

			public string key;

			public Type type;

			public object? value;
		}

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

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

		private class InvalidDeserializationTypeException : Exception
		{
			public string expected;

			public string received;

			public string field = "";
		}

		public static bool ProcessingServerUpdate;

		public readonly string Name;

		public string? DisplayName;

		public string? CurrentVersion;

		public string? MinimumRequiredVersion;

		public bool ModRequired;

		private bool? forceConfigLocking;

		private bool isSourceOfTruth = true;

		private static readonly HashSet<ConfigSync> configSyncs;

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

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

		private static bool isServer;

		private static bool lockExempt;

		private OwnConfigEntryBase? lockedConfig;

		private const byte PARTIAL_CONFIGS = 1;

		private const byte FRAGMENTED_CONFIG = 2;

		private const byte COMPRESSED_CONFIG = 4;

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

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

		private static long packageCounter;

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

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

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

		public bool InitialSyncDone { get; private set; }

		public event Action<bool>? SourceOfTruthChanged;

		private event Action? lockedConfigChanged;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

		private static readonly Dictionary<string, string> notProcessedNames;

		public string Name;

		private string? displayName;

		private string? currentVersion;

		private string? minimumRequiredVersion;

		public bool ModRequired = true;

		private string? ReceivedCurrentVersion;

		private string? ReceivedMinimumRequiredVersion;

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

		private ConfigSync? ConfigSync;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

		public const string ModName = "TortalPortalLite";

		public const string ModVersion = "1.0.9";

		private const float ConfigPollInterval = 5f;

		private readonly Harmony _harmony = new Harmony("wubarrk.tortalportallite");

		private float _configPollTimer;

		private DateTime _configStamp;

		public static Plugin Instance { get; private set; }

		public static ConfigSync ConfigSync { get; private set; }

		public SubsystemRegistry Subsystems { get; } = new SubsystemRegistry();

		private void Awake()
		{
			Instance = this;
			PortalDebug.Init(((BaseUnityPlugin)this).Logger);
			PortalDebug.LogAlways("Starting TortalPortalLite v1.0.9 (server-only, built for Valheim 1.0.7+)...");
			GameShape.Detect();
			ConfigSync = new ConfigSync("wubarrk.tortalportallite")
			{
				DisplayName = "TortalPortalLite",
				CurrentVersion = "1.0.9",
				MinimumRequiredVersion = "1.0.9",
				ModRequired = false
			};
			GlobalConfig.Bind(((BaseUnityPlugin)this).Config, ConfigSync);
			_configStamp = ReadConfigStamp();
			HookInstaller.InstallAll(_harmony);
			RegisterSubsystems();
			Subsystems.InitializeAll(((BaseUnityPlugin)this).Config, ConfigSync, _harmony);
			SubsystemRegistry.SafePatch(_harmony, typeof(WorldReadyHook));
			PortalDebug.LogAlways("TortalPortalLite initialized successfully.");
		}

		private void RegisterSubsystems()
		{
			Subsystems.Register(new PortalOpsSubsystem());
			Subsystems.Register(new RoutingSubsystem());
			Subsystems.Register(new TargetedSubsystem());
			Subsystems.Register(new UxSubsystem());
			Subsystems.Register(new EconomySubsystem());
			Subsystems.Register(new WildcardBSubsystem());
		}

		private void Update()
		{
			PollConfigFile();
			Heartbeat.OnUpdate(Time.deltaTime);
			Subsystems.OnUpdate();
		}

		private void OnDestroy()
		{
			Subsystems.ShutdownAll();
			_harmony.UnpatchSelf();
			DiscordWebhook.SendBlocking("TortalPortalLite offline.");
		}

		private void PollConfigFile()
		{
			_configPollTimer += Time.deltaTime;
			if (_configPollTimer < 5f)
			{
				return;
			}
			_configPollTimer = 0f;
			try
			{
				if (!(ReadConfigStamp() == _configStamp))
				{
					bool saveOnConfigSet = ((BaseUnityPlugin)this).Config.SaveOnConfigSet;
					((BaseUnityPlugin)this).Config.SaveOnConfigSet = false;
					try
					{
						((BaseUnityPlugin)this).Config.Reload();
					}
					finally
					{
						((BaseUnityPlugin)this).Config.SaveOnConfigSet = saveOnConfigSet;
					}
					_configStamp = ReadConfigStamp();
					PortalDebug.LogAlways("[Config] config file changed on disk - settings reloaded without a restart.");
				}
			}
			catch (Exception ex)
			{
				PortalDebug.LogWarning("[Config] hot-reload failed: " + ex.GetType().Name + ": " + ex.Message);
			}
		}

		private DateTime ReadConfigStamp()
		{
			try
			{
				return File.Exists(((BaseUnityPlugin)this).Config.ConfigFilePath) ? File.GetLastWriteTimeUtc(((BaseUnityPlugin)this).Config.ConfigFilePath) : DateTime.MinValue;
			}
			catch
			{
				return DateTime.MinValue;
			}
		}
	}
	[HarmonyPatch(typeof(ZNetScene), "Awake")]
	public static class WorldReadyHook
	{
		[HarmonyPostfix]
		public static void Postfix()
		{
			Plugin.Instance.Subsystems.OnWorldReady();
		}
	}
}
namespace TortalPortalLite.Subsystems.WorldOps
{
	public static class EconomyConfig
	{
		public static ConfigEntry<bool>? Enabled;

		public static ConfigEntry<string>? RegistryFile;

		public static void Bind(ConfigFile config, ConfigSync configSync)
		{
			Enabled = ConfigBinder.BindSynced(config, configSync, "90 - Economy: Core Kernel", "Enabled", def: true, "Master switch for the whole economy domain. If off, every economy engine still registers but no-ops.");
			RegistryFile = ConfigBinder.BindLocal(config, "90 - Economy: Core Kernel", "File", "economy.json", "Path (relative to the plugin folder) to the hot-reloaded economy declarations (Ore Gate upgrades, section \"oreGates\"). Local, not synced - a file path is server-machine-specific.");
		}
	}
	public sealed class EconomyOreGateDeclaration
	{
		public EconomyPosition Portal = new EconomyPosition();

		public bool AllowAllItems = true;

		public float? ExitDistance;
	}
	public static class EconomyOreGateEngine
	{
		private const float ReassertSeconds = 5f;

		private static int _lastVersion = -1;

		private static List<EconomyOreGateDeclaration> _gates = new List<EconomyOreGateDeclaration>();

		private static float _timer;

		public static void OnUpdate(float dt)
		{
			RefreshIfNeeded();
			_timer += dt;
			if (_timer < 5f || _gates.Count == 0)
			{
				return;
			}
			_timer = 0f;
			foreach (EconomyOreGateDeclaration gate in _gates)
			{
				Apply(gate);
			}
		}

		private static void RefreshIfNeeded()
		{
			if (EconomyRegistry.Version != _lastVersion)
			{
				_lastVersion = EconomyRegistry.Version;
				_gates = EconomyRegistry.Section<EconomyOreGateDeclaration>("oreGates");
			}
		}

		private static void Apply(EconomyOreGateDeclaration decl)
		{
			ZDO val = EconomyWriteOps.ResolveLivePortal(decl.Portal);
			if (val == null)
			{
				return;
			}
			bool flag = val.GetBool("HasFields", false);
			bool flag2 = val.GetBool("HasFieldsTeleportWorld", false);
			bool flag3 = val.GetBool("TeleportWorld.m_allowAllItems", false);
			bool flag4 = !decl.ExitDistance.HasValue || Mathf.Approximately(val.GetFloat("TeleportWorld.m_exitDistance", 0f), decl.ExitDistance.Value);
			if (flag && flag2 && flag3 == decl.AllowAllItems && flag4)
			{
				return;
			}
			PortalOwnership.ClaimAndWrite(val, delegate(ZDO z)
			{
				z.Set("HasFields", true);
				z.Set("HasFieldsTeleportWorld", true);
				z.Set("TeleportWorld.m_allowAllItems", decl.AllowAllItems);
				if (decl.ExitDistance.HasValue)
				{
					z.Set("TeleportWorld.m_exitDistance", decl.ExitDistance.Value);
				}
			});
			ZDOMan instance = ZDOMan.instance;
			if (instance != null)
			{
				instance.SetDirtyPortals();
			}
		}
	}
	public static class EconomyRegistry
	{
		private const float PollInterval = 5f;

		private static float _timer;

		private static DateTime _fileStamp = DateTime.MinValue;

		private static JObject? _root;

		public static int Version { get; private set; }

		private static string FilePath
		{
			get
			{
				ConfigEntry<string>? registryFile = EconomyConfig.RegistryFile;
				object obj;
				if (registryFile == null)
				{
					obj = null;
				}
				else
				{
					ConfigFile configFile = ((ConfigEntryBase)registryFile).ConfigFile;
					obj = ((configFile != null) ? configFile.ConfigFilePath : null);
				}
				if (obj == null)
				{
					obj = "";
				}
				return Path.Combine(Path.GetDirectoryName((string?)obj) ?? ".", EconomyConfig.RegistryFile?.Value ?? "economy.json");
			}
		}

		public static void OnUpdate(float dt)
		{
			_timer += dt;
			if (!(_timer < 5f))
			{
				_timer = 0f;
				TryReload();
			}
		}

		private static void TryReload()
		{
			try
			{
				string filePath = FilePath;
				if (!File.Exists(filePath))
				{
					if (_root != null)
					{
						_root = null;
						Version++;
					}
					return;
				}
				DateTime lastWriteTimeUtc = File.GetLastWriteTimeUtc(filePath);
				if (!(lastWriteTimeUtc == _fileStamp))
				{
					_root = JObject.Parse(File.ReadAllText(filePath));
					_fileStamp = lastWriteTimeUtc;
					Version++;
					PortalDebug.LogAlways($"[EconomyRegistry] reloaded '{filePath}' (version {Version}).");
				}
			}
			catch (Exception ex)
			{
				PortalDebug.LogError("[EconomyRegistry] failed to load economy.json: " + ex.GetType().Name + ": " + ex.Message);
			}
		}

		public static List<T> Section<T>(string key)
		{
			List<T> list = new List<T>();
			JObject? root = _root;
			JToken val = ((root != null) ? root[key] : null);
			if (val == null)
			{
				return list;
			}
			try
			{
				foreach (JToken item in (IEnumerable<JToken>)val)
				{
					try
					{
						T val2 = item.ToObject<T>();
						if (val2 != null)
						{
							list.Add(val2);
						}
					}
					catch (Exception ex)
					{
						PortalDebug.LogWarning("[EconomyRegistry] section '" + key + "': one entry failed to parse and was skipped: " + ex.Message);
					}
				}
			}
			catch (Exception ex2)
			{
				PortalDebug.LogWarning("[EconomyRegistry] section '" + key + "' is not an array - ignoring: " + ex2.Message);
			}
			return list;
		}
	}
	public sealed class EconomyPosition
	{
		public float X;

		public float Y;

		public float Z;

		public Vector3 ToVector3()
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			return new Vector3(X, Y, Z);
		}
	}
	public class EconomySubsystem : IPortalSubsystem
	{
		public string Name => "Economy";

		public bool IsEnabled => EconomyConfig.Enabled?.Value ?? true;

		public void Initialize(ConfigFile config, ConfigSync configSync, Harmony harmony)
		{
			EconomyConfig.Bind(config, configSync);
		}

		public void OnWorldReady()
		{
		}

		public void OnUpdate()
		{
			float deltaTime = Time.deltaTime;
			EconomyRegistry.OnUpdate(deltaTime);
			EconomyOreGateEngine.OnUpdate(deltaTime);
		}

		public void Shutdown()
		{
		}
	}
	public static class EconomyWriteOps
	{
		public static bool Reassert(ZDO zdo, string? tag, ZDOID? connection)
		{
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			if (zdo == null || !zdo.IsValid())
			{
				return false;
			}
			string text = zdo.GetString(ZDOVars.s_tag, "");
			ZDOID connectionZDOID = zdo.GetConnectionZDOID((ConnectionType)1);
			bool tagWrong = tag != null && text != tag;
			bool connectionWrong = connection.HasValue && connectionZDOID != connection.Value;
			if (!tagWrong && !connectionWrong)
			{
				return false;
			}
			PortalOwnership.ClaimAndWrite(zdo, delegate(ZDO z)
			{
				//IL_0029: Unknown result type (might be due to invalid IL or missing references)
				if (tagWrong)
				{
					z.Set(ZDOVars.s_tag, tag);
				}
				if (connectionWrong)
				{
					z.SetConnection((ConnectionType)1, connection.Value);
				}
			});
			ZDOMan instance = ZDOMan.instance;
			if (instance != null)
			{
				instance.SetDirtyPortals();
			}
			return true;
		}

		public static bool Disconnect(ZDO zdo, string? tag = null)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			return Reassert(zdo, tag, ZDOID.None);
		}

		public static ZDO? ResolveLivePortal(EconomyPosition pos)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			if (ZDOMan.instance == null || pos == null || !PortalCensus.TryGetByPosition(pos.ToVector3(), out var record))
			{
				return null;
			}
			ZDO zDO = ZDOMan.instance.GetZDO(record.Uid);
			if (zDO == null || !zDO.IsValid())
			{
				return null;
			}
			return zDO;
		}

		public static void PrewarmToPeer(long peerUid, ZDOID targetZdoId)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			ZDOMan instance = ZDOMan.instance;
			if (instance != null)
			{
				instance.ForceSendZDO(peerUid, targetZdoId);
			}
		}

		public static void PrewarmToPeersNear(Vector3 sourcePos, float radius, ZDOID targetZdoId)
		{
			//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_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0051: Unknown result type (might be due to invalid IL or missing references)
			if (ZDOMan.instance == null || targetZdoId == ZDOID.None)
			{
				return;
			}
			float num = radius * radius;
			foreach (ConnectedCharacter item in ConnectedCharacters.All())
			{
				Vector3 val = item.Position - sourcePos;
				if (((Vector3)(ref val)).sqrMagnitude <= num)
				{
					PrewarmToPeer(item.Peer.m_uid, targetZdoId);
				}
			}
		}

		public static void NotifyNear(Vector3 sourcePos, float radius, string message)
		{
			//IL_001b: 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)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			float num = radius * radius;
			foreach (ConnectedCharacter item in ConnectedCharacters.All())
			{
				Vector3 val = item.Position - sourcePos;
				if (((Vector3)(ref val)).sqrMagnitude <= num)
				{
					PlayerNotify.Toast(item, message);
				}
			}
		}
	}
	internal sealed class PortalCapTracker<TKey> where TKey : IEquatable<TKey>
	{
		internal readonly struct Item
		{
			public readonly TKey Key;

			public readonly long Creator;

			public readonly long OrderMajor;

			public readonly long OrderMinor;

			public Item(TKey key, long creator, long orderMajor, long orderMinor)
			{
				Key = key;
				Creator = creator;
				OrderMajor = orderMajor;
				OrderMinor = orderMinor;
			}
		}

		internal sealed class Verdict
		{
			public long Creator;

			public int Kept;

			public readonly List<TKey> Victims = new List<TKey>();
		}

		internal sealed class Result
		{
			public bool BaselineEstablished;

			public readonly List<Verdict> Verdicts = new List<Verdict>();
		}

		private const int RetryAfterSnapshots = 3;

		private HashSet<TKey> _known = new HashSet<TKey>();

		private readonly Dictionary<TKey, int> _condemned = new Dictionary<TKey, int>();

		private bool _baselinePending = true;

		public int KnownCount => _known.Count;

		public void Rebaseline()
		{
			_baselinePending = true;
		}

		public void Forget(TKey key)
		{
			_known.Remove(key);
			_condemned.Remove(key);
		}

		public Result Evaluate(IReadOnlyList<Item> snapshot, int cap, bool enforce)
		{
			Result result = new Result();
			if (_baselinePending || !enforce)
			{
				result.BaselineEstablished = _baselinePending;
				_baselinePending = false;
				_condemned.Clear();
				_known = new HashSet<TKey>();
				{
					foreach (Item item in snapshot)
					{
						if (item.Creator != 0L)
						{
							_known.Add(item.Key);
						}
					}
					return result;
				}
			}
			HashSet<TKey> hashSet = new HashSet<TKey>();
			Dictionary<long, int> dictionary = new Dictionary<long, int>();
			foreach (Item item2 in snapshot)
			{
				if (item2.Creator != 0L)
				{
					hashSet.Add(item2.Key);
					dictionary.TryGetValue(item2.Creator, out var value);
					dictionary[item2.Creator] = value + 1;
				}
			}
			_known.IntersectWith(hashSet);
			if (_condemned.Count > 0)
			{
				List<TKey> list = new List<TKey>();
				List<TKey> list2 = new List<TKey>();
				foreach (TKey item3 in new List<TKey>(_condemned.Keys))
				{
					if (!hashSet.Contains(item3))
					{
						list2.Add(item3);
					}
					else if (++_condemned[item3] >= 3)
					{
						list.Add(item3);
					}
				}
				foreach (TKey item4 in list2)
				{
					_condemned.Remove(item4);
				}
				foreach (TKey item5 in list)
				{
					_condemned.Remove(item5);
					_known.Remove(item5);
				}
			}
			Dictionary<long, List<Item>> dictionary2 = new Dictionary<long, List<Item>>();
			foreach (Item item6 in snapshot)
			{
				if (item6.Creator != 0L && !_known.Contains(item6.Key))
				{
					if (!dictionary2.TryGetValue(item6.Creator, out var value2))
					{
						value2 = (dictionary2[item6.Creator] = new List<Item>());
					}
					value2.Add(item6);
				}
			}
			foreach (KeyValuePair<long, List<Item>> item7 in dictionary2)
			{
				List<Item> value3 = item7.Value;
				value3.Sort(delegate(Item a, Item b)
				{
					long orderMinor;
					if (a.OrderMajor == b.OrderMajor)
					{
						orderMinor = a.OrderMinor;
						return orderMinor.CompareTo(b.OrderMinor);
					}
					orderMinor = a.OrderMajor;
					return orderMinor.CompareTo(b.OrderMajor);
				});
				int num = dictionary[item7.Key];
				int num2 = Math.Max(0, cap - (num - value3.Count));
				foreach (Item item8 in value3)
				{
					_known.Add(item8.Key);
				}
				if (value3.Count > num2)
				{
					Verdict verdict = new Verdict
					{
						Creator = item7.Key,
						Kept = num - (value3.Count - num2)
					};
					for (int num3 = num2; num3 < value3.Count; num3++)
					{
						verdict.Victims.Add(value3[num3].Key);
						_condemned[value3[num3].Key] = 0;
					}
					result.Verdicts.Add(verdict);
				}
			}
			return result;
		}
	}
	public static class WildcardBConfig
	{
		public static ConfigEntry<bool>? Enabled;

		public static ConfigEntry<bool>? PortalCapEnabled;

		public static ConfigEntry<int>? PortalCapPerCreator;

		public static ConfigEntry<float>? PortalCapSweepSeconds;

		public static void Bind(ConfigFile config, ConfigSync configSync)
		{
			Enabled = ConfigBinder.BindSynced(config, configSync, "150 - WildcardB: General", "Enabled", def: true, "Master switch for the whole wildcard cluster B domain.");
			PortalCapEnabled = ConfigBinder.BindSynced(config, configSync, "155 - WildcardB: Portal Caps", "Enabled", def: false, "Master switch for #148 Server-Enforced Portal Caps - once a creator holds the configured number of portals, any further portal they place is removed a moment after it appears. An unmodified client cannot be stopped from placing it, but cannot keep it either. Portals that already exist are never removed, so switching this on or lowering the cap only affects what is built afterwards.");
			PortalCapPerCreator = ConfigBinder.BindSyncedInt(config, configSync, "155 - WildcardB: Portal Caps", "PerCreatorCap", 6, "Maximum live portals a single s_creator (character id) may hold; the next one they place is removed. Existing portals are never removed, even if this is lowered below what someone already has.", 1, 999);
			PortalCapSweepSeconds = ConfigBinder.BindLocal(config, "155 - WildcardB: Portal Caps", "SweepSeconds", 2f, "How often (seconds) the engine looks for newly placed portals to judge. A new portal cannot be seen sooner than the census interval (section 2 - Foundations: Census).");
		}
	}
	public static class WildcardBPortalCapEngine
	{
		private const float ContinuityGapSeconds = 15f;

		private static readonly PortalCapTracker<ZDOID> Tracker = new PortalCapTracker<ZDOID>();

		private static bool _installed;

		private static float _timer;

		private static bool _recheckSoon;

		private static DateTime _lastScanProcessed;

		private static float _lastUpdateAt = -1f;

		public static void Initialize()
		{
			if (!_installed)
			{
				_installed = true;
				RpcZdoDataHook.RegisterPostfix(100, OnAnyZdoArrived);
			}
		}

		private static void OnAnyZdoArrived(ZNetPeer? sender, ZDOID zdoid)
		{
			_recheckSoon = true;
		}

		public static void OnUpdate(float dt)
		{
			float realtimeSinceStartup = Time.realtimeSinceStartup;
			if (_lastUpdateAt >= 0f && realtimeSinceStartup - _lastUpdateAt > 15f)
			{
				Tracker.Rebaseline();
			}
			_lastUpdateAt = realtimeSinceStartup;
			ConfigEntry<bool>? portalCapEnabled = WildcardBConfig.PortalCapEnabled;
			if (portalCapEnabled == null || !portalCapEnabled.Value)
			{
				Tracker.Rebaseline();
				return;
			}
			_timer += dt;
			float num = WildcardBConfig.PortalCapSweepSeconds?.Value ?? 2f;
			if (_recheckSoon || !(_timer < num))
			{
				_timer = 0f;
				_recheckSoon = false;
				Sweep();
			}
		}

		private static void Sweep()
		{
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_0127: Unknown result type (might be due to invalid IL or missing references)
			//IL_0129: Unknown result type (might be due to invalid IL or missing references)
			//IL_0147: Unknown result type (might be due to invalid IL or missing references)
			if (ZDOMan.instance == null)
			{
				return;
			}
			int num = WildcardBConfig.PortalCapPerCreator?.Value ?? 6;
			if (num <= 0)
			{
				Tracker.Rebaseline();
				return;
			}
			DateTime lastScanUtc = PortalCensus.LastScanUtc;
			if (lastScanUtc == default(DateTime) || lastScanUtc == _lastScanProcessed)
			{
				return;
			}
			_lastScanProcessed = lastScanUtc;
			IReadOnlyList<PortalRecord> latest = PortalCensus.Latest;
			List<PortalCapTracker<ZDOID>.Item> list = new List<PortalCapTracker<ZDOID>.Item>(latest.Count);
			foreach (PortalRecord item in latest)
			{
				PortalRecord current = item;
				ZDOID uid = current.Uid;
				long creator = current.Creator;
				ZDOID uid2 = current.Uid;
				list.Add(new PortalCapTracker<ZDOID>.Item(uid, creator, ((ZDOID)(ref uid2)).UserID, ((ZDOID)(ref current.Uid)).ID));
			}
			List<ConnectedCharacter> list2 = ConnectedCharacters.All();
			PortalCapTracker<ZDOID>.Result result = Tracker.Evaluate(list, num, list2.Count > 0);
			if (result.BaselineEstablished)
			{
				LogBaseline(latest, num);
			}
			foreach (PortalCapTracker<ZDOID>.Verdict verdict in result.Verdicts)
			{
				int num2 = 0;
				foreach (ZDOID victim in verdict.Victims)
				{
					if (TryRemove(victim, verdict.Creator, num))
					{
						num2++;
					}
					else
					{
						Tracker.Forget(victim);
					}
				}
				if (num2 > 0)
				{
					NotifyCreator(list2, verdict.Creator, verdict.Kept, num, num2);
				}
			}
		}

		private static bool TryRemove(ZDOID uid, long creatorId, int cap)
		{
			//IL_0005: 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_001f: 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_0069: Unknown result type (might be due to invalid IL or missing references)
			ZDO zDO = ZDOMan.instance.GetZDO(uid);
			if (zDO == null || !zDO.IsValid())
			{
				return true;
			}
			string text = "";
			if (PortalCensus.TryGet(uid, out var record))
			{
				text = $" at {record.Position:F0}, tag '{record.Tag}'";
			}
			try
			{
				zDO.SetOwner(ZDOMan.GetSessionID());
				ZDOMan.instance.DestroyZDO(zDO);
				PortalDebug.LogAlways($"[WildcardBPortalCapEngine] destroyed excess portal {uid} (creator {creatorId}, cap {cap}){text}.");
				return true;
			}
			catch (Exception ex)
			{
				PortalDebug.LogWarning($"[WildcardBPortalCapEngine] destroy failed for {uid}: {ex.Message}");
				return false;
			}
		}

		private static void NotifyCreator(List<ConnectedCharacter> players, long creatorId, int kept, int cap, int removed)
		{
			string message = ((removed == 1) ? $"Portal limit reached ({kept} of {cap}). The portal you just built was removed - dismantle an old one to make room." : $"Portal limit reached ({kept} of {cap}). The {removed} portals you just built were removed - dismantle old ones to make room.");
			foreach (ConnectedCharacter player in players)
			{
				if (player.PlayerId == creatorId)
				{
					PlayerNotify.Toast(player, message, center: true);
					break;
				}
			}
		}

		private static void LogBaseline(IReadOnlyList<PortalRecord> census, int cap)
		{
			Dictionary<long, int> dictionary = new Dictionary<long, int>();
			foreach (PortalRecord censu in census)
			{
				if (censu.Creator != 0L)
				{
					dictionary.TryGetValue(censu.Creator, out var value);
					dictionary[censu.Creator] = value + 1;
				}
			}
			int num = 0;
			foreach (int value2 in dictionary.Values)
			{
				num += value2;
			}
			PortalDebug.LogAlways($"[WildcardBPortalCapEngine] watching {num} existing portal(s) from {dictionary.Count} creator(s) with a cap of {cap}; none of them will be removed.");
			foreach (KeyValuePair<long, int> item in dictionary)
			{
				if (item.Value > cap)
				{
					PortalDebug.LogAlways($"[WildcardBPortalCapEngine] creator {item.Key} already holds {item.Value} (cap {cap}); they keep them, and any portal they build before dropping under the cap is removed.");
				}
			}
		}
	}
	public class WildcardBSubsystem : IPortalSubsystem
	{
		public string Name => "WildcardB";

		public bool IsEnabled
		{
			get
			{
				ConfigEntry<bool>? enabled = GlobalConfig.Enabled;
				if (enabled == null || enabled.Value)
				{
					return WildcardBConfig.Enabled?.Value ?? true;
				}
				return false;
			}
		}

		public void Initialize(ConfigFile config, ConfigSync configSync, Harmony harmony)
		{
			WildcardBConfig.Bind(config, configSync);
			WildcardBPortalCapEngine.Initialize();
		}

		public void OnWorldReady()
		{
		}

		public void OnUpdate()
		{
			WildcardBPortalCapEngine.OnUpdate(Time.deltaTime);
		}

		public void Shutdown()
		{
		}
	}
}
namespace TortalPortalLite.Subsystems.Topology
{
	public sealed class RoutingApproachWatcher
	{
		public delegate void GateCharacterEvent(string gateKey, ConnectedCharacter character);

		private readonly Dictionary<string, HashSet<long>> _armed = new Dictionary<string, HashSet<long>>();

		private readonly Dictionary<string, HashSet<long>> _committed = new Dictionary<string, HashSet<long>>();

		public void Poll(IEnumerable<(string key, Vector3 pos)> gates, float armRadius, float disarmHysteresis, GateCharacterEvent? onArm = null, GateCharacterEvent? onDisarm = null, GateCharacterEvent? onCommit = null, float innerCommitRadius = 0f)
		{
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: 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)
			List<ConnectedCharacter> list = ConnectedCharacters.All();
			float num = armRadius * armRadius;
			float num2 = armRadius + disarmHysteresis;
			float num3 = num2 * num2;
			float num4 = innerCommitRadius * innerCommitRadius;
			HashSet<long> hashSet = new HashSet<long>();
			HashSet<string> hashSet2 = new HashSet<string>();
			foreach (var (text, val) in gates)
			{
				hashSet2.Add(text);
				if (!_armed.TryGetValue(text, out HashSet<long> value))
				{
					value = new HashSet<long>();
					_armed[text] = value;
				}
				HashSet<long> value2 = null;
				if (onCommit != null && !_committed.TryGetValue(text, out value2))
				{
					value2 = new HashSet<long>();
					_committed[text] = value2;
				}
				foreach (ConnectedCharacter item in list)
				{
					long playerId = item.PlayerId;
					if (playerId != 0L && !item.Zdo.GetBool(ZDOVars.s_dead, false))
					{
						hashSet.Add(playerId);
						Vector3 val2 = item.Position - val;
						float sqrMagnitude = ((Vector3)(ref val2)).sqrMagnitude;
						bool flag = value.Contains(playerId);
						if (!flag && sqrMagnitude <= num)
						{
							value.Add(playerId);
							onArm?.Invoke(text, item);
							flag = true;
						}
						else if (flag && sqrMagnitude > num3)
						{
							value.Remove(playerId);
							value2?.Remove(playerId);
							onDisarm?.Invoke(text, item);
							flag = false;
						}
						if (flag && value2 != null && !value2.Contains(playerId) && sqrMagnitude <= num4)
						{
							value2.Add(playerId);
							onCommit(text, item);
						}
					}
				}
			}
			PruneDisconnected(hashSet);
			PruneStaleGates(hashSet2);
		}

		public bool IsArmed(string gateKey, long playerId)
		{
			if (_armed.TryGetValue(gateKey, out HashSet<long> value))
			{
				return value.Contains(playerId);
			}
			return false;
		}

		public int ArmedCount(string gateKey)
		{
			if (!_armed.TryGetValue(gateKey, out HashSet<long> value))
			{
				return 0;
			}
			return value.Count;
		}

		private void PruneDisconnected(HashSet<long> stillConnected)
		{
			foreach (HashSet<long> value in _armed.Values)
			{
				value.RemoveWhere((long id) => !stillConnected.Contains(id));
			}
			foreach (HashSet<long> value2 in _committed.Values)
			{
				value2.RemoveWhere((long id) => !stillConnected.Contains(id));
			}
		}

		private void PruneStaleGates(HashSet<string> stillDeclared)
		{
			PruneMissing(_armed, stillDeclared);
			PruneMissing(_committed, stillDeclared);
		}

		private static void PruneMissing(Dictionary<string, HashSet<long>> map, HashSet<string> stillDeclared)
		{
			List<string> list = null;
			foreach (string key in map.Keys)
			{
				if (!stillDeclared.Contains(key))
				{
					(list ?? (list = new List<string>())).Add(key);
				}
			}
			if (list == null)
			{
				return;
			}
			foreach (string item in list)
			{
				map.Remove(item);
			}
		}
	}
	public static class RoutingConfig
	{
		public static ConfigEntry<bool>? TakeoverEnabled;

		public static ConfigEntry<float>? ReassertSeconds;

		public static ConfigEntry<string>? RegistryFile;

		public static ConfigEntry<int>? MaxWritesPerTick;

		public static ConfigEntry<float>? SealedGateEvalSeconds;

		public static ConfigEntry<float>? ApproachPollSeconds;

		public static ConfigEntry<float>? PrewarmRadius;

		public static ConfigEntry<float>? FastTransitTriggerRadius;

		public static ConfigEntry<int>? ZoneGhostBudgetPerTick;

		public static void Bind(ConfigFile config, ConfigSync configSync)
		{
			TakeoverEnabled = ConfigBinder.BindSynced(config, configSync, "9 - Routing: Core", "TakeoverEnabled", def: true, "Master switch for every dynamic-routing engine in this domain (catalog #23). ConnectPortalsHook only exposes a postfix (no prefix-cancel broker exists yet), so 'takeover' here means: reassert every managed portal's tag/connection faster than vanilla's 5s reconciler, not a true prefix veto - see RoutingPairingAuthorityEngine's doc comment.");
			ReassertSeconds = ConfigBinder.BindSynced(config, configSync, "9 - Routing: Core", "ReassertSeconds", 1f, "How often the pairing-authority engine re-checks and, if needed, re-writes each dynamically-managed portal's tag/connection. Must stay well under vanilla's own 5s Game.ConnectPortals pass.", 0.2f, 4.5f);
			RegistryFile = ConfigBinder.BindLocal(config, "9 - Routing: Core", "File", "routing.json", "Path (relative to the plugin folder) to the hot-reloaded dynamic-routing declarations (sealed gates, parked terminals, ...). Local, not synced - a file path is server-machine-specific.");
			MaxWritesPerTick = ConfigBinder.BindSyncedInt(config, configSync, "9 - Routing: Core", "MaxWritesPerTick", 64, "Caps how many portal ZDOs any single routing engine will rewrite in one tick, so a large managed set never spikes a frame (ZDOMan.SendZDOs re-serializes whole ZDOs with no delta encoding).", 1, 4000);
			SealedGateEvalSeconds = ConfigBinder.BindSynced(config, configSync, "11 - Routing: Schedules and Conditions", "SealedGateEvalSeconds", 1f, "Progression-Gated Sealed Gate (#29) global-key evaluation tick.", 0.2f, 10f);
			ApproachPollSeconds = ConfigBinder.BindSynced(config, configSync, "12 - Routing: Approach and JIT", "ApproachPollSeconds", 0.1f, "How often the shared approach/arm watcher (Parked Terminal, #225/#227) samples connected-character positions against managed portal positions.", 0.05f, 1f);
			PrewarmRadius = ConfigBinder.BindSynced(config, configSync, "16 - Routing: Delivery Pipeline", "PrewarmRadius", 30f, "DestinationPrewarm (#224): radius around a source portal within which nearby peers are force-sent the destination ZDO the instant a managed connection write happens.", 5f, 100f);
			FastTransitTriggerRadius = ConfigBinder.BindSynced(config, configSync, "16 - Routing: Delivery Pipeline", "FastTransitTriggerRadius", 1.2f, "Fast-Transit Mode (#225) / Parked Terminal (#227): XZ radius of the position-based trigger substituting for the (server-invisible) TeleportWorldTrigger collider.", 0.5f, 5f);
			ZoneGhostBudgetPerTick = ConfigBinder.BindSyncedInt(config, configSync, "16 - Routing: Delivery Pipeline", "ZoneGhostBudgetPerTick", 1, "Destination Zone Ghost Pre-Generation (#228): zones ghost-generated per tick (ZoneSystem.SpawnZone already budgets internally; this caps how many calls this engine makes per tick).", 1, 25);
		}
	}
	public static class RoutingManagedPortalRegistry
	{
		private const float PollInterval = 5f;

		private static float _timer;

		private static DateTime _fileStamp = DateTime.MinValue;

		private static JObject? _root;

		public static int Version { get; private set; }

		private static string FilePath
		{
			get
			{
				ConfigEntry<string>? registryFile = RoutingConfig.RegistryFile;
				object obj;
				if (registryFile == null)
				{
					obj = null;
				}
				else
				{
					ConfigFile configFile = ((ConfigEntryBase)registryFile).ConfigFile;
					obj = ((configFile != null) ? configFile.ConfigFilePath : null);
				}
				if (obj == null)
				{
					obj = "";
				}
				return Path.Combine(Path.GetDirectoryName((string?)obj) ?? ".", RoutingConfig.RegistryFile?.Value ?? "routing.json");
			}
		}

		public static void OnUpdate(float dt)
		{
			_timer += dt;
			if (!(_timer < 5f))
			{
				_timer = 0f;
				TryReload();
			}
		}

		private static void TryReload()
		{
			try
			{
				string filePath = FilePath;
				if (!File.Exists(filePath))
				{
					if (_root != null)
					{
						_root = null;
						Version++;
					}
					return;
				}
				DateTime lastWriteTimeUtc = File.GetLastWriteTimeUtc(filePath);
				if (!(lastWriteTimeUtc == _fileStamp))
				{
					_root = JObject.Parse(File.ReadAllText(filePath));
					_fileStamp = lastWriteTimeUtc;
					Version++;
					PortalDebug.LogAlways($"[RoutingManagedPortalRegistry] reloaded '{filePath}' (version {Version}).");
				}
			}
			catch (Exception ex)
			{
				PortalDebug.LogError("[RoutingManagedPortalRegistry] failed to load routing.json: " + ex.GetType().Name + ": " + ex.Message);
			}
		}

		public static List<T> Section<T>(string key)
		{
			List<T> list = new List<T>();
			JObject? root = _root;
			JToken val = ((root != null) ? root[key] : null);
			if (val == null)
			{
				return list;
			}
			try
			{
				foreach (JToken item in (IEnumerable<JToken>)val)
				{
					try
					{
						T val2 = item.ToObject<T>();
						if (val2 != null)
						{
							list.Add(val2);
						}
					}
					catch (Exception ex)
					{
						PortalDebug.LogWarning("[RoutingManagedPortalRegistry] section '" + key + "': one entry failed to parse and was skipped: " + ex.Message);
					}
				}
			}
			catch (Exception ex2)
			{
				PortalDebug.LogWarning("[RoutingManagedPortalRegistry] section '" + key + "' is not an array - ignoring: " + ex2.Message);
			}
			return list;
		}
	}
	public sealed class RoutingPosition
	{
		public float X;

		public float Y;

		public float Z;

		public Vector3 ToVector3()
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			return new Vector3(X, Y, Z);
		}
	}
	public static class RoutingPairingAuthorityEngine
	{
		private readonly struct RoutingPositionKey
		{
			private readonly int _x;

			private readonly int _y;

			private readonly int _z;

			public RoutingPositionKey(RoutingPosition p)
			{
				_x = Mathf.RoundToInt(p.X * 2f);
				_y = Mathf.RoundToInt(p.Y * 2f);
				_z = Mathf.RoundToInt(p.Z * 2f);
			}
		}

		private static readonly Dictionary<ZDOID, (string? tag, ZDOID? connection)> _desired = new Dictionary<ZDOID, (string, ZDOID?)>();

		private static readonly Dictionary<RoutingPositionKey, string> _claims = new Dictionary<RoutingPositionKey, string>();

		private static float _timer;

		public static void Initialize()
		{
			ConnectPortalsHook.RegisterPostfix(-1000, ReassertAfterVanillaPass);
		}

		public static void OnUpdate(float dt)
		{
			ConfigEntry<bool>? takeoverEnabled = RoutingConfig.TakeoverEnabled;
			if (takeoverEnabled == null || takeoverEnabled.Value)
			{
				_timer += dt;
				float num = RoutingConfig.ReassertSeconds?.Value ?? 1f;
				if (!(_timer < num))
				{
					_timer = 0f;
					ReassertAfterVanillaPass();
				}
			}
		}

		public static void Publish(ZDOID portalUid, string? tag, ZDOID? connection)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			_desired[portalUid] = (tag, connection);
		}

		public static void Clear(ZDOID portalUid)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			_desired.Remove(portalUid);
		}

		public static bool TryClaim(RoutingPosition pos, string mechanism)
		{
			RoutingPositionKey key = new RoutingPositionKey(pos);
			if (_claims.TryGetValue(key, out string value))
			{
				if (value == mechanism)
				{
					return true;
				}
				PortalDebug.LogWarning($"[RoutingPairingAuthorityEngine] position {pos.X:F1},{pos.Y:F1},{pos.Z:F1} is declared by both '{value}' and '{mechanism}' in routing.json - '{mechanism}' will not manage it.");
				return false;
			}
			_claims[key] = mechanism;
			return true;
		}

		public static void ResetClaims()
		{
			_claims.Clear();
		}

		private static void ReassertAfterVanillaPass()
		{
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			if (ZDOMan.instance == null || _desired.Count == 0)
			{
				return;
			}
			int num = RoutingConfig.MaxWritesPerTick?.Value ?? 64;
			int num2 = 0;
			foreach (KeyValuePair<ZDOID, (string, ZDOID?)> item in _desired)
			{
				if (num2 >= num)
				{
					break;
				}
				ZDO zDO = ZDOMan.instance.GetZDO(item.Key);
				if (zDO != null && zDO.IsValid() && RoutingWriteOps.Reassert(zDO, item.Value.Item1, item.Value.Item2))
				{
					num2++;
				}
			}
		}
	}
	public sealed class RoutingParkedTerminalDefinition
	{
		public string Name = "";

		public RoutingPosition Position = new RoutingPosition();

		public RoutingPosition? FixedDestination;

		public bool Distant = true;

		public string ReservedTag = "parked";
	}
	public static class RoutingParkedTerminalEngine
	{
		private static float _timer;

		private static int _lastRegistryVersion = -1;

		private static List<RoutingParkedTerminalDefinition> _terminals = new List<RoutingParkedTerminalDefinition>();

		private static readonly RoutingApproachWatcher _watcher = new RoutingApproachWatcher();

		private static readonly Dictionary<string, RoutingParkedTerminalDefinition> _byName = new Dictionary<string, RoutingParkedTerminalDefinition>();

		public static void OnUpdate(float dt)
		{
			//IL_0177: 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_014d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0159: Unknown result type (might be due to invalid IL or missing references)
			ConfigEntry<bool>? takeoverEnabled = RoutingConfig.TakeoverEnabled;
			if ((takeoverEnabled != null && !takeoverEnabled.Value) || ZDOMan.instance == null || ZRoutedRpc.instance == null)
			{
				return;
			}
			_timer += dt;
			float num = RoutingConfig.ApproachPollSeconds?.Value ?? 0.1f;
			if (_timer < num)
			{
				return;
			}
			_timer = 0f;
			if (RoutingManagedPortalRegistry.Version != _lastRegistryVersion)
			{
				_lastRegistryVersion = RoutingManagedPortalRegistry.Version;
				_terminals = RoutingManagedPortalRegistry.Section<RoutingParkedTerminalDefinition>("parkedTerminals");
				_byName.Clear();
				foreach (RoutingParkedTerminalDefinition terminal in _terminals)
				{
					_byName[terminal.Name] = terminal;
				}
			}
			if (_terminals.Count == 0)
			{
				return;
			}
			List<(string, Vector3)> list = new List<(string, Vector3)>(_terminals.Count);
			foreach (RoutingParkedTerminalDefinition terminal2 in _terminals)
			{
				if (RoutingPairingAuthorityEngine.TryClaim(terminal2.Position, "parkedterminal:" + terminal2.Name))
				{
					ZDO val = RoutingWriteOps.ResolveLive(terminal2.Position);
					if (val != null)
					{
						RoutingWriteOps.Reassert(val, terminal2.ReservedTag, ZDOID.None);
						RoutingPairingAuthorityEngine.Publish(val.m_uid, terminal2.ReservedTag, ZDOID.None);
					}
					list.Add((terminal2.Name, terminal2.Position.ToVector3()));
				}
			}
			float armRadius = RoutingConfig.FastTransitTriggerRadius?.Value ?? 1.2f;
			_watcher.Poll(list, armRadius, 0f, HandleArm);
		}

		private static void HandleArm(string terminalName, ConnectedCharacter character)
		{
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: 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_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: 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_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			if (!_byName.TryGetValue(terminalName, out RoutingParkedTerminalDefinition value) || ZRoutedRpc.instance == null || character.Zdo.GetBool(ZDOVars.s_dead, false) || character.Zdo.GetBool(ZDOVars.s_inBed, false))
			{
				return;
			}
			RoutingPosition destination = value.FixedDestination;
			if (destination != null || RoutingPlayerSelectionStore.TryGetSelection(value.Name, character.PlayerId, out destination))
			{
				ZDO val = RoutingWriteOps.ResolveLive(destination);
				if (val != null)
				{
					Vector3 position = val.GetPosition();
					Quaternion rotation = val.GetRotation();
					Vector3 val2 = position + rotation * Vector3.forward * 1f + Vector3.up;
					bool flag = value.Distant || !FastPathIsSafe(position);
					ZRoutedRpc.instance.InvokeRoutedRPC(character.Peer.m_uid, character.Zdo.m_uid, "RPC_TeleportTo", new object[3] { val2, rotation, flag });
				}
			}
		}

		private static bool FastPathIsSafe(Vector3 destinationPos)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)ZoneSystem.instance == (Object)null || WorldGenerator.instance == null)
			{
				return false;
			}
			if (!ZoneSystem.instance.IsZoneGenerated(ZoneSystem.GetZone(destinationPos)))
			{
				RoutingZoneGhostPreGenEngine.Enqueue(destinationPos, 1);
				return false;
			}
			float height = WorldGenerator.instance.GetHeight(destinationPos.x, destinationPos.z);
			return destinationPos.y >= height - 0.5f;
		}
	}
	public sealed class RoutingPhantomAnchorDefinition
	{
		public string Name = "";

		public RoutingPosition Position = new RoutingPosition();

		public float RotationY;

		public bool Void;
	}
	public static class RoutingPhantomAnchorEngine
	{
		private static readonly int VoidRegistrationHash = StringExtensionMethods.GetStableHashCode("tortalportallite_routing_void_anchor_v1");

		private static int _lastRegistryVersion = -1;

		private static List<RoutingPhantomAnchorDefinition> _declared = new List<RoutingPhantomAnchorDefinition>();

		public static void OnUpdate(float dt)
		{
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: 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)
			if (ZDOMan.instance == null || RoutingManagedPortalRegistry.Version == _lastRegistryVersion)
			{
				return;
			}
			_lastRegistryVersion = RoutingManagedPortalRegistry.Version;
			_declared = RoutingManagedPortalRegistry.Section<RoutingPhantomAnchorDefinition>("phantomAnchors");
			foreach (RoutingPhantomAnchorDefinition item in _declared)
			{
				if (!string.IsNullOrEmpty(item.Name) && RoutingPairingAuthorityEngine.TryClaim(item.Position, "phantomanchor:" + item.Name) && RoutingWriteOps.ResolveLive(item.Position) == null)
				{
					Quaternion rot = Quaternion.Euler(0f, item.RotationY, 0f);
					if ((item.Void ? FabricateVoidAnchor(item.Position.ToVector3(), rot) : FabricatePortalAnchor(item.Position.ToVector3(), rot)) == null)
					{
						PortalDebug.LogWarning("[RoutingPhantomAnchorEngine] failed to provision declared anchor '" + item.Name + "'.");
					}
				}
			}
		}

		public static ZDO? FabricatePortalAnchor(Vector3 pos, Quaternion rot)
		{
			//IL_0024: 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 (PortalRegistry.PrefabHashes.Count == 0)
			{
				PortalDebug.LogWarning("[RoutingPhantomAnchorEngine] cannot fabricate a portal anchor - PortalRegistry has no known portal prefab hash yet.");
				return null;
			}
			int num = PortalRegistry.PrefabHashes[0];
			return Fabricate(pos, rot, num, num);
		}

		public static ZDO? FabricateVoidAnchor(Vector3 pos, Quaternion rot)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			return Fabricate(pos, rot, VoidRegistrationHash, 0);
		}

		private static ZDO? Fabricate(Vector3 pos, Quaternion rot, int registrationHash, int finalPrefabHash)
		{
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			if (ZDOMan.instance == null)
			{
				return null;
			}
			try
			{
				ZDO obj = ZDOMan.instance.CreateNewZDO(pos, registrationHash);
				obj.Persistent = true;
				obj.Type = (ObjectType)0;
				obj.Distant = false;
				obj.SetPrefab(finalPrefabHash);
				obj.SetRotation(rot);
				return obj;
			}
			catch (Exception ex)
			{
				PortalDebug.LogError($"[RoutingPhantomAnchorEngine] fabrication failed at {pos:F0}: {ex.GetType().Name}: {ex.Message}");
				return null;
			}
		}

		public static void Destroy(ZDO zdo)
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			if (zdo == null || !zdo.IsValid() || ZDOMan.instance == null)
			{
				return;
			}
			try
			{
				zdo.SetOwner(ZDOMan.GetSessionID());
				ZDOMan.instance.DestroyZDO(zdo);
			}
			catch (Exception ex)
			{
				PortalDebug.LogError($"[RoutingPhantomAnchorEngine] destroy failed for {zdo.m_uid}: {ex.GetType().Name}: {ex.Message}");
			}
		}
	}
	public static class RoutingPlayerSelectionStore
	{
		private static readonly Dictionary<(string gate, long playerId), RoutingPosition> _selections = new Dictionary<(string, long), RoutingPosition>();

		private static readonly Dictionary<(string gate, long playerId), int> _cycleIndex = new Dictionary<(string, long), int>();

		public static void SetSelection(string gate, long playerId, RoutingPosition destination)
		{
			_selections[(gate, playerId)] = destination;
		}

		public static bool TryGetSelection(string gate, long playerId, out RoutingPosition destination)
		{
			return _selections.TryGetValue((gate, playerId), out destination);
		}

		public static void ClearSelection(string gate, long playerId)
		{
			_selections.Remov