using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.IO.Compression;
using System.Linq;
using System.Numerics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Serialization;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using BepInEx;
using BepInEx.Configuration;
using Dyls123.Mods;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Newtonsoft.Json;
using SaveStructure.Core;
using ServerSync;
using Splatform;
using TMPro;
using UnityEngine;
using UnityEngine.Rendering;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: IgnoresAccessChecksTo("assembly_valheim")]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("SaveStructure")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyDescription("Select, save, and rebuild named structures with the Valheim hammer.")]
[assembly: AssemblyFileVersion("1.2.1.0")]
[assembly: AssemblyInformationalVersion("1.2.1")]
[assembly: AssemblyProduct("SaveStructure")]
[assembly: AssemblyTitle("SaveStructure")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.2.1.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

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

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

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

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

		public bool SynchronizedConfig = true;

		public abstract ConfigEntryBase BaseConfig { get; }
	}
	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;
			};
		}
	}
	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
	{
		public bool? ReadOnly = false;
	}
	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 || ownConfigEntryBase.LocalBaseValue == null)
				{
					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();
		}
	}
	[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 Dyls123.Mods
{
	internal static class ConfigLayout
	{
		internal static bool IsDedicated => Paths.ProcessName.StartsWith("valheim_server", StringComparison.OrdinalIgnoreCase);

		internal static void Migrate(ConfigFile config, Func<string, string> sectionName)
		{
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Expected O, but got Unknown
			Dictionary<ConfigDefinition, string> dictionary = (Dictionary<ConfigDefinition, string>)AccessTools.Property(typeof(ConfigFile), "OrphanedEntries").GetValue(config);
			KeyValuePair<ConfigDefinition, string>[] array = dictionary.ToArray();
			for (int i = 0; i < array.Length; i++)
			{
				KeyValuePair<ConfigDefinition, string> keyValuePair = array[i];
				ConfigDefinition val = new ConfigDefinition(sectionName(keyValuePair.Key.Section), keyValuePair.Key.Key);
				if (!val.Equals(keyValuePair.Key))
				{
					if (!dictionary.ContainsKey(val) && !config.ContainsKey(val))
					{
						dictionary[val] = keyValuePair.Value;
					}
					dictionary.Remove(keyValuePair.Key);
				}
			}
		}

		internal static void PatchGameplay(Harmony harmony, Type plugin)
		{
			foreach (Type item in from t in plugin.Assembly.GetTypes()
				where t.Namespace == plugin.Namespace || (t.Namespace?.StartsWith(plugin.Namespace + ".", StringComparison.Ordinal) ?? false)
				select t)
			{
				harmony.CreateClassProcessor(item).Patch();
			}
		}
	}
	internal static class ModConfigSync
	{
		internal static ConfigSync Create(ConfigFile config, string guid, string name, string version)
		{
			ConfigSync configSync = new ConfigSync(guid)
			{
				DisplayName = name,
				CurrentVersion = version,
				MinimumRequiredVersion = version,
				ModRequired = false
			};
			configSync.AddLockingConfigEntry<bool>(config.Bind<bool>("90 - Server", "LockConfiguration", true, "When installed on the server, synchronize gameplay settings and allow only server administrators to change them. Keybinds and display preferences stay local. This does not require players to install the mod."));
			ConfigEntryBase[] array = ((IEnumerable<KeyValuePair<ConfigDefinition, ConfigEntryBase>>)config).Select((KeyValuePair<ConfigDefinition, ConfigEntryBase> pair) => pair.Value).ToArray();
			foreach (ConfigEntryBase val in array)
			{
				string section = val.Definition.Section;
				if (!section.StartsWith("30 - ", StringComparison.Ordinal) && !section.StartsWith("40 - ", StringComparison.Ordinal) && !section.StartsWith("90 - ", StringComparison.Ordinal) && !section.StartsWith("99 - ", StringComparison.Ordinal))
				{
					typeof(ConfigSync).GetMethod("AddConfigEntry").MakeGenericMethod(val.SettingType).Invoke(configSync, new object[1] { val });
				}
			}
			return configSync;
		}
	}
}
namespace SaveStructure
{
	internal sealed class HologramManager : IDisposable
	{
		private sealed class LivePlan
		{
			internal readonly HologramPlan Data;

			internal readonly Piece[] Pieces;

			internal readonly List<Mesh> Meshes = new List<Mesh>();

			internal readonly Dictionary<int, GameObject> Visuals = new Dictionary<int, GameObject>();

			internal readonly Dictionary<int, Renderer[]> Renderers = new Dictionary<int, Renderer[]>();

			internal GameObject? Root;

			internal bool Dirty;

			internal LivePlan(HologramPlan data, Piece[] pieces)
			{
				Data = data;
				Pieces = pieces;
			}
		}

		private readonly SaveStructurePlugin plugin;

		private readonly string directory;

		private readonly List<LivePlan> plans = new List<LivePlan>();

		private HologramStore? store;

		private long worldId;

		private long playerId;

		private ZNetScene? scene;

		private Material? material;

		private LivePlan? targetPlan;

		private int targetIndex = -1;

		private int targetFrame = -1;

		private float retryAt;

		private float refreshAt;

		internal bool HasTarget
		{
			get
			{
				if (targetPlan != null)
				{
					return targetIndex >= 0;
				}
				return false;
			}
		}

		internal bool ReservesInteraction
		{
			get
			{
				//IL_0013: Unknown result type (might be due to invalid IL or missing references)
				//IL_0018: Unknown result type (might be due to invalid IL or missing references)
				//IL_002d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0032: Unknown result type (might be due to invalid IL or missing references)
				if (HasTarget)
				{
					KeyboardShortcut value = plugin.BuildKey.Value;
					if (!((KeyboardShortcut)(ref value)).IsPressed())
					{
						value = plugin.RemoveHologramKey.Value;
						return ((KeyboardShortcut)(ref value)).IsPressed();
					}
					return true;
				}
				return false;
			}
		}

		internal string Hint
		{
			get
			{
				//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
				if (!HasTarget)
				{
					return "";
				}
				LivePlan livePlan = targetPlan;
				Piece val = livePlan.Pieces[targetIndex];
				string text = string.Join(", ", from r in StructureBuilder.CostsForPiece(val)
					select $"{r.m_amount} {Localization.instance.Localize(r.m_resItem.m_itemData.m_shared.m_name)}");
				return $"{livePlan.Data.Name}: {livePlan.Data.Completed.Count}/{livePlan.Pieces.Length} built\n" + Localization.instance.Localize(val.m_name) + " — " + ((text.Length == 0) ? "No materials required" : ("Required: " + text)) + "\n" + $"{plugin.BuildKey.Value}: build this piece | {plugin.RemoveHologramKey.Value}: remove remaining hologram";
			}
		}

		internal HologramManager(SaveStructurePlugin plugin, string directory)
		{
			this.plugin = plugin;
			this.directory = directory;
		}

		internal void Tick(Player player)
		{
			//IL_0268: Unknown result type (might be due to invalid IL or missing references)
			//IL_026d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0275: Unknown result type (might be due to invalid IL or missing references)
			//IL_027a: Unknown result type (might be due to invalid IL or missing references)
			//IL_029e: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a3: Unknown result type (might be due to invalid IL or missing references)
			if (!Object.op_Implicit((Object)(object)ZNet.instance) || ZNet.instance.GetWorld() == null || !plugin.Catalog.Ready)
			{
				return;
			}
			long worldUID = ZNet.instance.GetWorldUID();
			long playerID = player.GetPlayerID();
			if (worldUID == 0L || playerID == 0L)
			{
				return;
			}
			if (store == null || worldId != worldUID || playerId != playerID || (Object)(object)scene != (Object)(object)ZNetScene.instance)
			{
				if (Time.unscaledTime < retryAt)
				{
					return;
				}
				Clear();
				try
				{
					HologramStore hologramStore = new HologramStore(directory, worldUID, playerID, plugin.Warn);
					worldId = worldUID;
					playerId = playerID;
					scene = ZNetScene.instance;
					store = hologramStore;
					foreach (HologramPlan item in store.Load())
					{
						if (item.Completed.Count != item.Blueprint.Pieces.Count)
						{
							try
							{
								plans.Add(new LivePlan(item, plugin.Catalog.Resolve(item.Blueprint)));
							}
							catch (Exception ex)
							{
								plugin.Warn("Cannot load hologram '" + item.Name + "': " + ex.Message + ". Its file is preserved.");
							}
						}
					}
				}
				catch (Exception ex2)
				{
					plugin.Warn("Cannot load holograms: " + ex2.Message);
					store = null;
					retryAt = Time.unscaledTime + 10f;
					return;
				}
			}
			if (Time.unscaledTime >= refreshAt)
			{
				refreshAt = Time.unscaledTime + 2f;
				LivePlan[] array = plans.ToArray();
				foreach (LivePlan livePlan in array)
				{
					if (livePlan.Dirty)
					{
						SaveProgress(livePlan);
					}
					if (livePlan.Data.Completed.Count == livePlan.Pieces.Length && !livePlan.Dirty)
					{
						DestroyVisuals(livePlan);
						plans.Remove(livePlan);
						continue;
					}
					Vector3 val = livePlan.Data.Position.Unity();
					bool flag = Vector3.Distance(((Component)player).transform.position, val) <= 180f || (Object.op_Implicit((Object)(object)GameCamera.instance) && Vector3.Distance(((Component)GameCamera.instance).transform.position, val) <= 180f);
					if (flag && !Object.op_Implicit((Object)(object)livePlan.Root))
					{
						try
						{
							MakeVisuals(livePlan);
						}
						catch (Exception ex3)
						{
							DestroyVisuals(livePlan);
							plugin.Warn("Cannot display hologram: " + ex3.Message);
						}
					}
					else if (!flag && Object.op_Implicit((Object)(object)livePlan.Root))
					{
						DestroyVisuals(livePlan);
					}
				}
			}
			UpdateTarget(player);
		}

		internal void Place(Player player, StructureEntry entry)
		{
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_012b: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				Tick(player);
				if (store == null)
				{
					throw new InvalidOperationException("Hologram storage is not ready.");
				}
				if (plans.Count >= plugin.MaximumHolograms.Value)
				{
					throw new InvalidOperationException($"Hologram limit: {plugin.MaximumHolograms.Value}. Finish or remove an existing plan first.");
				}
				StructureBuilder.BuildPart[] plan = StructureBuilder.PlacementPlan(player, entry);
				Physics.SyncTransforms();
				StructureBuilder.Validate(player, plan, includePlannedStations: false, planning: true);
				HologramPlan hologramPlan = new HologramPlan
				{
					WorldId = worldId,
					PlayerId = playerId,
					Blueprint = entry.Blueprint,
					Position = PositionData.From(player.m_placementGhost.transform.position.Numerics()),
					Rotation = RotationData.From(player.m_placementGhost.transform.rotation.Numerics())
				};
				store.Save(hologramPlan);
				plans.Add(new LivePlan(hologramPlan, entry.Pieces));
				refreshAt = 0f;
				player.m_lastToolUseTime = Time.time;
				SaveStructurePlugin.Tell($"Hologram placed: '{hologramPlan.Name}'. Aim at a piece and press {plugin.BuildKey.Value} to build it.");
			}
			catch (Exception ex)
			{
				plugin.Warn("Hologram placement failed: " + ex.Message);
				SaveStructurePlugin.Tell(ex.Message);
			}
		}

		private void MakeVisuals(LivePlan plan)
		{
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Expected O, but got Unknown
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_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)
			//IL_003b: 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_0055: Expected O, but got Unknown
			//IL_0129: Unknown result type (might be due to invalid IL or missing references)
			//IL_0154: Unknown result type (might be due to invalid IL or missing references)
			if (material == null)
			{
				material = new Material(Shader.Find("Sprites/Default") ?? Shader.Find("Unlit/Color"))
				{
					color = new Color(0.25f, 0.8f, 1f, 0.32f),
					renderQueue = 3000
				};
			}
			GameObject val = (plan.Root = new GameObject("SaveStructure hologram: " + plan.Data.Name));
			val.SetActive(false);
			val.transform.SetParent(((Component)plugin).transform, false);
			val.transform.position = plan.Data.Position.Unity();
			val.transform.rotation = plan.Data.Rotation.Unity();
			for (int i = 0; i < plan.Pieces.Length; i++)
			{
				if (!plan.Data.Completed.Contains(i))
				{
					GameObject val2 = PreviewFactory.CopyGeometry(((Component)plan.Pieces[i]).gameObject, val.transform, plan.Meshes, colliders: false);
					val2.transform.localPosition = plan.Data.Blueprint.Pieces[i].Position.Unity();
					val2.transform.localRotation = plan.Data.Blueprint.Pieces[i].Rotation.Unity();
					Renderer[] componentsInChildren = val2.GetComponentsInChildren<Renderer>();
					Renderer[] array = componentsInChildren;
					foreach (Renderer val3 in array)
					{
						val3.sharedMaterials = Enumerable.Repeat<Material>(material, val3.sharedMaterials.Length).ToArray();
						val3.shadowCastingMode = (ShadowCastingMode)0;
						val3.receiveShadows = false;
					}
					plan.Visuals[i] = val2;
					plan.Renderers[i] = componentsInChildren;
				}
			}
			val.SetActive(true);
		}

		internal void UpdateTarget(Player player, bool? placementInput = null)
		{
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0172: Unknown result type (might be due to invalid IL or missing references)
			//IL_017e: Unknown result type (might be due to invalid IL or missing references)
			//IL_019a: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d6: Unknown result type (might be due to invalid IL or missing references)
			if (!placementInput.HasValue && targetFrame == Time.frameCount)
			{
				return;
			}
			targetFrame = Time.frameCount;
			targetPlan = null;
			targetIndex = -1;
			if (!Object.op_Implicit((Object)(object)GameCamera.instance) || plugin.Selection.Active || !SelectionSession.HasHammer(player) || !SaveStructurePlugin.InputAllowed(player, placementInput))
			{
				return;
			}
			Transform transform = ((Component)GameCamera.instance).transform;
			Ray val = default(Ray);
			((Ray)(ref val))..ctor(transform.position, transform.forward);
			float num = SaveStructurePlugin.InteractionReach(player, plugin.BuildReach.Value);
			float num2 = num + Vector3.Distance(transform.position, ((Component)player).transform.position);
			int mask = LayerMask.GetMask(new string[5] { "piece", "piece_nonsolid", "terrain", "Default", "static_solid" });
			RaycastHit val2 = default(RaycastHit);
			if (Physics.Raycast(val, ref val2, num2, mask, (QueryTriggerInteraction)1))
			{
				num2 = ((RaycastHit)(ref val2)).distance + 0.1f;
			}
			float num3 = default(float);
			foreach (LivePlan plan in plans)
			{
				if (!Object.op_Implicit((Object)(object)plan.Root))
				{
					continue;
				}
				for (int i = 0; i < plan.Pieces.Length; i++)
				{
					if (plan.Data.Completed.Contains(i) || !plan.Visuals.TryGetValue(i, out GameObject value) || !Object.op_Implicit((Object)(object)value) || Vector3.Distance(((Component)player).transform.position, value.transform.position) > num || !ZoneSystem.instance.IsZoneLoaded(value.transform.position))
					{
						continue;
					}
					Renderer[] array = plan.Renderers[i];
					foreach (Renderer val3 in array)
					{
						if (Object.op_Implicit((Object)(object)val3))
						{
							Bounds bounds = val3.bounds;
							if (((Bounds)(ref bounds)).IntersectRay(val, ref num3) && num3 >= 0f && num3 < num2)
							{
								num2 = num3;
								targetPlan = plan;
								targetIndex = i;
							}
						}
					}
				}
			}
		}

		internal bool HandleInput(Player player)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			if (!HasTarget)
			{
				return false;
			}
			KeyboardShortcut value = plugin.BuildKey.Value;
			if (!((KeyboardShortcut)(ref value)).IsDown())
			{
				return false;
			}
			BuildTarget(player, targetPlan, targetIndex);
			return true;
		}

		internal void PromptRemoval(Player player)
		{
			if (!HasTarget || store == null)
			{
				return;
			}
			LivePlan plan = targetPlan;
			HologramStore expectedStore = store;
			plugin.ConfirmRemoval(player, "Remove hologram?", "Remove the remaining hologram '" + plan.Data.Name + "'?\n\nCompleted building pieces and the saved blueprint will remain.", delegate
			{
				if (store == expectedStore && plans.Contains(plan))
				{
					store.Delete(plan.Data);
					DestroyVisuals(plan);
					plans.Remove(plan);
					targetPlan = null;
					targetIndex = -1;
					SaveStructurePlugin.Tell("Removed hologram '" + plan.Data.Name + "'. Completed building pieces remain.");
				}
			});
		}

		private void BuildTarget(Player player, LivePlan plan, int index)
		{
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Expected O, but got Unknown
			//IL_0130: Unknown result type (might be due to invalid IL or missing references)
			//IL_013c: Unknown result type (might be due to invalid IL or missing references)
			//IL_014a: Unknown result type (might be due to invalid IL or missing references)
			//IL_015b: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bc: 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)
			if (plan.Data.Completed.Contains(index))
			{
				return;
			}
			GameObject val = null;
			List<Mesh> list = new List<Mesh>();
			try
			{
				store.Save(plan.Data);
				plan.Dirty = false;
				(Vector3, Quaternion) tuple = StructureMath.Place(plan.Data.Blueprint.Pieces[index], plan.Data.Position.ToVector(), plan.Data.Rotation.ToQuaternion());
				Vector3 position = default(Vector3);
				((Vector3)(ref position))..ctor(tuple.Item1.X, tuple.Item1.Y, tuple.Item1.Z);
				Quaternion rotation = default(Quaternion);
				((Quaternion)(ref rotation))..ctor(tuple.Item2.X, tuple.Item2.Y, tuple.Item2.Z, tuple.Item2.W);
				if (FindExisting(plan.Pieces[index], position, rotation))
				{
					Complete(plan, index);
					SaveStructurePlugin.Tell("This piece already exists. Hologram cleared without spending materials.");
					return;
				}
				val = new GameObject("SaveStructure placement check");
				val.SetActive(false);
				GameObject val2 = PreviewFactory.CopyGeometry(((Component)plan.Pieces[index]).gameObject, val.transform, list);
				val.transform.position = position;
				val.transform.rotation = rotation;
				val2.transform.localPosition = Vector3.zero;
				val2.transform.localRotation = Quaternion.identity;
				Transform[] componentsInChildren = val.GetComponentsInChildren<Transform>(true);
				for (int i = 0; i < componentsInChildren.Length; i++)
				{
					((Component)componentsInChildren[i]).gameObject.layer = LayerMask.NameToLayer("ghost");
				}
				val.SetActive(true);
				StructureBuilder.BuildPart part = new StructureBuilder.BuildPart
				{
					Piece = plan.Pieces[index],
					Position = position,
					Rotation = rotation,
					Preview = val2.transform
				};
				if (!StructureBuilder.TryBuildPart(player, part, out string failure))
				{
					if (failure.Length > 0)
					{
						SaveStructurePlugin.Tell(failure);
					}
				}
				else
				{
					Complete(plan, index);
					SaveStructurePlugin.Tell($"Built {plan.Data.Completed.Count}/{plan.Pieces.Length}: {plan.Data.Name}");
				}
			}
			catch (Exception ex)
			{
				plugin.Error(ex);
				SaveStructurePlugin.Tell("Could not build hologram piece: " + ex.Message);
			}
			finally
			{
				if (Object.op_Implicit((Object)(object)val))
				{
					val.SetActive(false);
					Object.Destroy((Object)(object)val);
				}
				foreach (Mesh item in list)
				{
					Object.Destroy((Object)(object)item);
				}
			}
		}

		private static bool FindExisting(Piece prefab, Vector3 position, Quaternion rotation)
		{
			//IL_000e: 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_001a: Unknown result type (might be due to invalid IL or missing references)
			List<Piece> list = new List<Piece>();
			Piece.GetAllPiecesInRadius(position, 0.08f, list);
			return list.Any(delegate(Piece piece)
			{
				//IL_0042: 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)
				if (Object.op_Implicit((Object)(object)piece))
				{
					ZNetView component = ((Component)piece).GetComponent<ZNetView>();
					if (component != null && component.IsValid() && component.GetZDO().GetPrefab() == StringExtensionMethods.GetStableHashCode(((Object)((Component)prefab).gameObject).name))
					{
						return Quaternion.Angle(((Component)piece).transform.rotation, rotation) < 1f;
					}
				}
				return false;
			});
		}

		private void Complete(LivePlan plan, int index)
		{
			plan.Data.Completed.Add(index);
			plan.Dirty = true;
			if (plan.Visuals.TryGetValue(index, out GameObject value) && Object.op_Implicit((Object)(object)value))
			{
				value.SetActive(false);
				Object.Destroy((Object)(object)value);
			}
			plan.Visuals.Remove(index);
			plan.Renderers.Remove(index);
			SaveProgress(plan);
			targetPlan = null;
			targetIndex = -1;
			if (plan.Data.Completed.Count == plan.Pieces.Length && !plan.Dirty)
			{
				DestroyVisuals(plan);
				plans.Remove(plan);
			}
		}

		private void SaveProgress(LivePlan plan)
		{
			try
			{
				store.Save(plan.Data);
				plan.Dirty = false;
			}
			catch (Exception ex)
			{
				plugin.Warn("Hologram progress write failed; will retry: " + ex.Message);
				SaveStructurePlugin.Tell("Piece built, but saving hologram progress failed. Keep the game open while storage recovers.");
			}
		}

		private static void DestroyVisuals(LivePlan plan)
		{
			if (Object.op_Implicit((Object)(object)plan.Root))
			{
				plan.Root.SetActive(false);
				Object.Destroy((Object)(object)plan.Root);
			}
			plan.Root = null;
			foreach (Mesh mesh in plan.Meshes)
			{
				if (Object.op_Implicit((Object)(object)mesh))
				{
					Object.Destroy((Object)(object)mesh);
				}
			}
			plan.Meshes.Clear();
			plan.Visuals.Clear();
			plan.Renderers.Clear();
		}

		internal void Clear()
		{
			foreach (LivePlan plan in plans)
			{
				if (plan.Dirty && store != null)
				{
					SaveProgress(plan);
				}
				DestroyVisuals(plan);
			}
			plans.Clear();
			targetPlan = null;
			targetIndex = -1;
			targetFrame = -1;
			store = null;
			worldId = (playerId = 0L);
			scene = null;
			refreshAt = 0f;
		}

		public void Dispose()
		{
			Clear();
			if (Object.op_Implicit((Object)(object)material))
			{
				Object.Destroy((Object)(object)material);
			}
		}
	}
	[BepInProcess("valheim.exe")]
	[BepInProcess("valheim.x86_64")]
	[BepInProcess("valheim_server.exe")]
	[BepInProcess("valheim_server.x86_64")]
	[BepInPlugin("dylan.valheim.savestructure", "SaveStructure", "1.2.1")]
	public sealed class SaveStructurePlugin : BaseUnityPlugin
	{
		public const string PluginId = "dylan.valheim.savestructure";

		public const string PluginVersion = "1.2.1";

		public const string ConfigFileName = "Dyls123.SaveStructure.cfg";

		internal ConfigEntry<KeyboardShortcut> ToggleKey;

		internal ConfigEntry<KeyboardShortcut> SaveKey;

		internal ConfigEntry<KeyboardShortcut> ClearKey;

		internal ConfigEntry<KeyboardShortcut> SelectionModeKey;

		internal ConfigEntry<KeyboardShortcut> PlacementModeKey;

		internal ConfigEntry<KeyboardShortcut> CollisionKey;

		internal ConfigEntry<KeyboardShortcut> SelectKey;

		internal ConfigEntry<KeyboardShortcut> BuildKey;

		internal ConfigEntry<KeyboardShortcut> RemoveHologramKey;

		internal ConfigEntry<KeyboardShortcut> TallerKey;

		internal ConfigEntry<KeyboardShortcut> ShorterKey;

		internal ConfigEntry<KeyboardShortcut> DeleteBlueprintKey;

		internal ConfigEntry<bool> DisableCollision;

		internal ConfigEntry<bool> ScrollBoxHeight;

		internal ConfigEntry<float> BoxHeightScrollStep;

		internal ConfigEntry<float> AreaHeight;

		internal ConfigEntry<float> BuildReach;

		internal ConfigEntry<int> MaxPieces;

		internal ConfigEntry<int> MaximumHolograms;

		internal ConfigEntry<float> SelectionDistance;

		private Harmony harmony;

		private GUIStyle? hintStyle;

		private bool removalPromptOpen;

		private int blockInputThroughFrame = -1;

		internal ConfigSync SettingsSync;

		internal static SaveStructurePlugin Instance { get; private set; }

		internal BlueprintStore Store { get; private set; }

		internal StructureCatalog Catalog { get; private set; }

		internal SelectionSession Selection { get; private set; }

		internal HologramManager Holograms { get; private set; }

		internal bool HologramMode { get; private set; }

		internal bool BlocksInput
		{
			get
			{
				if (!removalPromptOpen)
				{
					return Time.frameCount <= blockInputThroughFrame;
				}
				return true;
			}
		}

		private string CollisionHint => string.Format("Collision: {0} ({1})", DisableCollision.Value ? "OFF" : "ON", CollisionKey.Value);

		internal static string ConfigSection(string section)
		{
			return section switch
			{
				"Building" => "10 - Building", 
				"Selection" => "11 - Selection", 
				"Holograms" => "12 - Holograms", 
				"Controls" => "30 - Keybinds", 
				"Internal" => "99 - Internal", 
				_ => section, 
			};
		}

		private void Awake()
		{
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0173: Unknown result type (might be due to invalid IL or missing references)
			//IL_021d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0227: Expected O, but got Unknown
			//IL_027c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0286: Expected O, but got Unknown
			//IL_02ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c4: Expected O, but got Unknown
			//IL_02ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f8: Expected O, but got Unknown
			//IL_033d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0347: Expected O, but got Unknown
			//IL_03dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e7: Expected O, but got Unknown
			UseNamedConfig(((BaseUnityPlugin)this).Config, Paths.ConfigPath);
			ConfigLayout.Migrate(((BaseUnityPlugin)this).Config, ConfigSection);
			Instance = this;
			UpgradeControlDefaults(((BaseUnityPlugin)this).Config);
			ToggleKey = BindKey("ToggleSaveMode", (KeyCode)289, "Toggle save mode while holding the Hammer.");
			SaveKey = BindKey("SaveSelection", (KeyCode)288, "Name and save the selected pieces.");
			ClearKey = BindKey("ClearSelection", (KeyCode)8, "Clear the selection and reset the area box.");
			SelectionModeKey = ((BaseUnityPlugin)this).Config.Bind<KeyboardShortcut>("30 - Keybinds", "SwitchSelectionMode", new KeyboardShortcut((KeyCode)324, (KeyCode[])(object)new KeyCode[1] { (KeyCode)304 }), "Switch individual/box selection only in save mode. Configurable independently of placement mode.");
			PlacementModeKey = ((BaseUnityPlugin)this).Config.Bind<KeyboardShortcut>("30 - Keybinds", "SwitchPlacementMode", new KeyboardShortcut((KeyCode)324, (KeyCode[])(object)new KeyCode[1] { (KeyCode)304 }), "Switch whole-build/hologram placement only while positioning a saved structure. Default LeftShift + right-click leaves plain right-click available for the Hammer menu.");
			CollisionKey = BindKey("ToggleCollision", (KeyCode)291, "Toggle placement overlap checks while placing a saved structure or aiming at a hologram.");
			SelectKey = BindKey("SelectPiece", (KeyCode)323, "Select/deselect a piece or set/confirm a box corner in save mode.");
			BuildKey = BindKey("BuildHologramPiece", (KeyCode)101, "Build the aimed hologram piece using its full cost through the game's material system.");
			RemoveHologramKey = ((BaseUnityPlugin)this).Config.Bind<KeyboardShortcut>("30 - Keybinds", "RemoveHologram", new KeyboardShortcut((KeyCode)127, (KeyCode[])(object)new KeyCode[1] { (KeyCode)304 }), "Remove the aimed hologram plan after confirmation. Completed real pieces remain.");
			DeleteBlueprintKey = BindKey("DeleteSavedStructure", (KeyCode)127, "Delete the saved blueprint currently selected for placement, after confirmation. Existing holograms and built pieces remain.");
			TallerKey = BindKey("IncreaseBoxHeight", (KeyCode)0, "Optional keyboard shortcut to increase the area box height by one metre.");
			ShorterKey = BindKey("DecreaseBoxHeight", (KeyCode)0, "Optional keyboard shortcut to decrease the area box height by one metre.");
			ScrollBoxHeight = ((BaseUnityPlugin)this).Config.Bind<bool>("30 - Keybinds", "ScrollWheelBoxHeight", true, "Use scroll up/down to increase/decrease height in box-selection mode. Reserves the wheel from camera zoom and Hammer rotation only in this mode.");
			BoxHeightScrollStep = ((BaseUnityPlugin)this).Config.Bind<float>("11 - Selection", "ScrollHeightStep", 1f, new ConfigDescription("Metres added/removed per scroll input when adjusting box height.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.1f, 10f), Array.Empty<object>()));
			DisableCollision = ((BaseUnityPlugin)this).Config.Bind<bool>("10 - Building", "DisableCollision", false, "Ignore saved-structure placement overlap checks. Does not disable physical collision or ward/build restrictions.");
			AreaHeight = ((BaseUnityPlugin)this).Config.Bind<float>("11 - Selection", "BoxHeight", 20f, new ConfigDescription("Initial box height above its lower corner; adjusted in save mode.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(1f, 128f), Array.Empty<object>()));
			BuildReach = ((BaseUnityPlugin)this).Config.Bind<float>("12 - Holograms", "BuildReach", 8f, new ConfigDescription("Distance to an individual hologram piece in metres. A larger Hammer reach supplied by a building mod is also respected.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(2f, 25f), Array.Empty<object>()));
			MaximumHolograms = ((BaseUnityPlugin)this).Config.Bind<int>("12 - Holograms", "MaximumPlans", 20, new ConfigDescription("Maximum unfinished holograms per world and character.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(1, 100), Array.Empty<object>()));
			MaxPieces = BindPieceLimit(((BaseUnityPlugin)this).Config);
			SelectionDistance = ((BaseUnityPlugin)this).Config.Bind<float>("11 - Selection", "Reach", 25f, new ConfigDescription("Selection distance from the player in metres. A larger Hammer reach supplied by a building mod is also respected.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(2f, 100f), Array.Empty<object>()));
			SettingsSync = ModConfigSync.Create(((BaseUnityPlugin)this).Config, "dylan.valheim.savestructure", "SaveStructure", "1.2.1");
			if (!ConfigLayout.IsDedicated)
			{
				Store = new BlueprintStore(Path.Combine(Paths.ConfigPath, "SaveStructure", "structures"), Warn);
				Catalog = new StructureCatalog(this);
				Selection = new SelectionSession(this);
				Holograms = new HologramManager(this, Path.Combine(Paths.ConfigPath, "SaveStructure", "holograms"));
				harmony = new Harmony("dylan.valheim.savestructure");
				ConfigLayout.PatchGameplay(harmony, typeof(SaveStructurePlugin));
				((BaseUnityPlugin)this).Logger.LogInfo((object)("SaveStructure 1.2.1 loaded for Valheim " + Version.GetVersionString(false) + "."));
			}
		}

		private ConfigEntry<KeyboardShortcut> BindKey(string name, KeyCode key, string description)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			return ((BaseUnityPlugin)this).Config.Bind<KeyboardShortcut>("30 - Keybinds", name, new KeyboardShortcut(key, Array.Empty<KeyCode>()), description + " Accepts modifiers, e.g. F9 + LeftControl; None disables the shortcut.");
		}

		internal static ConfigEntry<int> BindPieceLimit(ConfigFile config)
		{
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Expected O, but got Unknown
			ConfigLayout.Migrate(config, ConfigSection);
			ConfigEntry<int> val = config.Bind<int>("11 - Selection", "MaximumPieces", 5000, new ConfigDescription("Maximum pieces per structure. Larger structures use more memory and may take longer to preview and place.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(1, 10000), Array.Empty<object>()));
			ConfigEntry<int> val2 = config.Bind<int>("99 - Internal", "PieceLimitRevision", 0, "Tracks the one-time piece-limit upgrade. Leave this value unchanged.");
			if (val2.Value < 1)
			{
				if (val.Value == 500)
				{
					val.Value = 5000;
				}
				val2.Value = 1;
			}
			return val;
		}

		internal static void UseNamedConfig(ConfigFile config, string directory)
		{
			string fullPath = Path.GetFullPath(Path.Combine(directory, "Dyls123.SaveStructure.cfg"));
			if (!string.Equals(config.ConfigFilePath, fullPath, StringComparison.OrdinalIgnoreCase))
			{
				FieldInfo obj = AccessTools.Field(typeof(ConfigFile), "<ConfigFilePath>k__BackingField") ?? throw new MissingFieldException("BepInEx ConfigFile path field is unavailable.");
				if (!File.Exists(fullPath) && File.Exists(config.ConfigFilePath))
				{
					File.Move(config.ConfigFilePath, fullPath);
				}
				obj.SetValue(config, fullPath);
				if (File.Exists(fullPath))
				{
					config.Reload();
				}
				ConfigLayout.Migrate(config, ConfigSection);
			}
		}

		internal static void UpgradeControlDefaults(ConfigFile config)
		{
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0187: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_0104: Unknown result type (might be due to invalid IL or missing references)
			//IL_0109: Unknown result type (might be due to invalid IL or missing references)
			//IL_0117: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0140: Unknown result type (might be due to invalid IL or missing references)
			//IL_0145: Unknown result type (might be due to invalid IL or missing references)
			//IL_0153: Unknown result type (might be due to invalid IL or missing references)
			//IL_0135: Unknown result type (might be due to invalid IL or missing references)
			//IL_0171: Unknown result type (might be due to invalid IL or missing references)
			ConfigLayout.Migrate(config, ConfigSection);
			ConfigEntry<int> val = config.Bind<int>("99 - Internal", "ControlDefaultsRevision", 0, "Tracks the one-time control-default upgrade. Leave this value unchanged.");
			if (val.Value >= 2)
			{
				return;
			}
			ConfigEntry<KeyboardShortcut> val2 = config.Bind<KeyboardShortcut>("30 - Keybinds", "SwitchMode", new KeyboardShortcut((KeyCode)324, (KeyCode[])(object)new KeyCode[1] { (KeyCode)304 }), (ConfigDescription)null);
			ConfigEntry<KeyboardShortcut> val3 = config.Bind<KeyboardShortcut>("30 - Keybinds", "IncreaseBoxHeight", new KeyboardShortcut((KeyCode)0, Array.Empty<KeyCode>()), "Optional keyboard shortcut to increase the area box height by one metre. Accepts modifiers, e.g. F9 + LeftControl; None disables the shortcut.");
			ConfigEntry<KeyboardShortcut> val4 = config.Bind<KeyboardShortcut>("30 - Keybinds", "DecreaseBoxHeight", new KeyboardShortcut((KeyCode)0, Array.Empty<KeyCode>()), "Optional keyboard shortcut to decrease the area box height by one metre. Accepts modifiers, e.g. F9 + LeftControl; None disables the shortcut.");
			if (val.Value < 1)
			{
				if (((object)val2.Value/*cast due to .constrained prefix*/).Equals((object)new KeyboardShortcut((KeyCode)290, Array.Empty<KeyCode>())))
				{
					val2.Value = new KeyboardShortcut((KeyCode)324, (KeyCode[])(object)new KeyCode[1] { (KeyCode)304 });
				}
				if (((object)val3.Value/*cast due to .constrained prefix*/).Equals((object)new KeyboardShortcut((KeyCode)280, Array.Empty<KeyCode>())))
				{
					val3.Value = new KeyboardShortcut((KeyCode)0, Array.Empty<KeyCode>());
				}
				if (((object)val4.Value/*cast due to .constrained prefix*/).Equals((object)new KeyboardShortcut((KeyCode)281, Array.Empty<KeyCode>())))
				{
					val4.Value = new KeyboardShortcut((KeyCode)0, Array.Empty<KeyCode>());
				}
			}
			config.Bind<KeyboardShortcut>("30 - Keybinds", "SwitchSelectionMode", val2.Value, "Switch individual/box selection only in save mode. Configurable independently of placement mode.");
			config.Bind<KeyboardShortcut>("30 - Keybinds", "SwitchPlacementMode", val2.Value, "Switch whole-build/hologram placement only while positioning a saved structure. Default LeftShift + right-click leaves plain right-click available for the Hammer menu.");
			config.Remove(((ConfigEntryBase)val2).Definition);
			val.Value = 2;
		}

		internal static bool ModeSwitchDown(KeyboardShortcut shortcut)
		{
			//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_0013: 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)
			if ((int)((KeyboardShortcut)(ref shortcut)).MainKey == 0 || !ZInput.GetKeyDown(((KeyboardShortcut)(ref shortcut)).MainKey, true))
			{
				return false;
			}
			if (((KeyboardShortcut)(ref shortcut)).Modifiers.Any((KeyCode key) => !ZInput.GetKey(key, true)))
			{
				return false;
			}
			KeyCode[] array = new KeyCode[6];
			RuntimeHelpers.InitializeArray(array, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
			return ((IEnumerable<KeyCode>)(object)array).All((KeyCode key) => key == ((KeyboardShortcut)(ref shortcut)).MainKey || ((KeyboardShortcut)(ref shortcut)).Modifiers.Contains(key) || !ZInput.GetKey(key, true));
		}

		internal static bool InputAllowed(Player player, bool? placementInput = null)
		{
			if (Object.op_Implicit((Object)(object)player) && (placementInput ?? ((Character)player).TakeInput()) && !UnifiedPopup.WasVisibleThisFrame() && !Hud.IsPieceSelectionVisible())
			{
				return !Hud.InRadial();
			}
			return false;
		}

		internal static float InteractionReach(Player player, float configuredReach)
		{
			if (!(player.m_maxPlaceDistance > 5f))
			{
				return configuredReach;
			}
			return Mathf.Max(configuredReach, player.m_maxPlaceDistance);
		}

		internal bool HandleInput(Player player, bool takeInput)
		{
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_0102: Unknown result type (might be due to invalid IL or missing references)
			//IL_0162: Unknown result type (might be due to invalid IL or missing references)
			//IL_0167: Unknown result type (might be due to invalid IL or missing references)
			if (BlocksInput)
			{
				SelectionSession.ResetBufferedActions(player);
				return false;
			}
			bool flag = InputAllowed(player, takeInput);
			if (!Selection.HandleInput(player, flag))
			{
				return false;
			}
			if (!flag || !SelectionSession.HasHammer(player))
			{
				return true;
			}
			Holograms.UpdateTarget(player, takeInput);
			StructureEntry entry;
			bool flag2 = Catalog.TryGet(player.GetSelectedPiece(), out entry);
			if (Holograms.HasTarget && ModeSwitchDown(RemoveHologramKey.Value))
			{
				Holograms.PromptRemoval(player);
				SelectionSession.ResetBufferedActions(player);
				return false;
			}
			if (flag2 && ModeSwitchDown(DeleteBlueprintKey.Value))
			{
				ConfirmRemoval(player, "Delete saved structure?", "Delete '" + entry.Blueprint.Name + "' from your saved structures and Hammer menu?\n\nExisting holograms and completed building pieces will remain.", delegate
				{
					Store.Delete(entry.Blueprint);
					Catalog.Remove(entry);
					Tell("Deleted saved structure '" + entry.Blueprint.Name + "'.");
				});
				SelectionSession.ResetBufferedActions(player);
				return false;
			}
			if (flag2 && ModeSwitchDown(PlacementModeKey.Value))
			{
				HologramMode = !HologramMode;
				Catalog.ApplyPlacementMode();
				SelectionSession.ResetBufferedActions(player);
				Tell(HologramMode ? "Placement: HOLOGRAM (no upfront materials)." : "Placement: WHOLE STRUCTURE.");
				return false;
			}
			if (flag2 || Holograms.HasTarget)
			{
				KeyboardShortcut value = CollisionKey.Value;
				if (((KeyboardShortcut)(ref value)).IsDown())
				{
					if (!SettingsSync.IsSourceOfTruth && SettingsSync.IsLocked)
					{
						Tell("Placement collision is controlled by the server.");
						SelectionSession.ResetBufferedActions(player);
						return false;
					}
					DisableCollision.Value = !DisableCollision.Value;
					Tell("Placement collision: " + (DisableCollision.Value ? "OFF" : "ON"));
					SelectionSession.ResetBufferedActions(player);
					return false;
				}
			}
			if (Holograms.HandleInput(player))
			{
				SelectionSession.ResetBufferedActions(player);
				return false;
			}
			return true;
		}

		private void Update()
		{
			if (!ConfigLayout.IsDedicated)
			{
				if (removalPromptOpen && !UnifiedPopup.IsVisible())
				{
					FinishRemovalPrompt();
				}
				if (!Object.op_Implicit((Object)(object)ZNetScene.instance) || !Object.op_Implicit((Object)(object)Player.m_localPlayer))
				{
					Selection.Cancel();
					Holograms.Clear();
					Catalog.Clear();
				}
				else
				{
					Catalog.EnsureRegistered();
					Selection.CheckPlayer();
					Holograms.Tick(Player.m_localPlayer);
				}
			}
		}

		private void OnGUI()
		{
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: 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)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Expected O, but got Unknown
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cc: Expected O, but got Unknown
			//IL_01ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_0121: Unknown result type (might be due to invalid IL or missing references)
			//IL_013d: Unknown result type (might be due to invalid IL or missing references)
			if (ConfigLayout.IsDedicated)
			{
				return;
			}
			Player localPlayer = Player.m_localPlayer;
			if (!Object.op_Implicit((Object)(object)localPlayer) || !SelectionSession.HasHammer(localPlayer) || !InputAllowed(localPlayer))
			{
				return;
			}
			if (hintStyle == null)
			{
				hintStyle = new GUIStyle(GUI.skin.box)
				{
					fontSize = 16,
					alignment = (TextAnchor)4,
					wordWrap = true,
					richText = false
				};
			}
			string text = (Selection.Active ? Selection.Hint : $"SaveStructure  |  {ToggleKey.Value}: select a structure to save");
			if (!Selection.Active)
			{
				Piece selectedPiece = localPlayer.GetSelectedPiece();
				if (selectedPiece != null && Catalog.TryGet(selectedPiece, out StructureEntry entry))
				{
					text += string.Format("\n{0} — {1} pieces | {2}\n{3}: switch placement mode | {4}\n{5}: delete saved blueprint | Rotate and place with the normal Hammer controls.", entry.Blueprint.Name, entry.Blueprint.Pieces.Count, HologramMode ? "HOLOGRAM" : "WHOLE STRUCTURE", PlacementModeKey.Value, CollisionHint, DeleteBlueprintKey.Value);
				}
			}
			if (!Selection.Active && Holograms.HasTarget)
			{
				text = text + "\n" + Holograms.Hint + "\n" + CollisionHint;
			}
			float num = Mathf.Min(750, Screen.width - 24);
			float num2 = hintStyle.CalcHeight(new GUIContent(text), num);
			GUI.Box(new Rect(((float)Screen.width - num) / 2f, 30f, num, num2 + 8f), text, hintStyle);
		}

		internal void ConfirmRemoval(Player player, string title, string message, Action remove)
		{
			//IL_0059: 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_0071: Expected O, but got Unknown
			//IL_0071: Expected O, but got Unknown
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Expected O, but got Unknown
			if (removalPromptOpen || !UnifiedPopup.IsAvailable() || UnifiedPopup.IsVisible())
			{
				return;
			}
			ZNetScene expectedScene = ZNetScene.instance;
			removalPromptOpen = true;
			SelectionSession.ResetBufferedActions(player);
			UnifiedPopup.Push((PopupBase)new YesNoPopup(title, message, (PopupButtonCallback)delegate
			{
				UnifiedPopup.Pop();
				FinishRemovalPrompt();
				if (!Object.op_Implicit((Object)(object)player) || (Object)(object)player != (Object)(object)Player.m_localPlayer || !Object.op_Implicit((Object)(object)expectedScene) || (Object)(object)expectedScene != (Object)(object)ZNetScene.instance)
				{
					return;
				}
				try
				{
					remove();
				}
				catch (Exception ex)
				{
					Error(ex);
					Tell("Could not delete: " + ex.Message);
				}
			}, (PopupButtonCallback)delegate
			{
				UnifiedPopup.Pop();
				FinishRemovalPrompt();
			}, false, false));
		}

		private void FinishRemovalPrompt()
		{
			removalPromptOpen = false;
			blockInputThroughFrame = Time.frameCount + 1;
			if (Object.op_Implicit((Object)(object)Player.m_localPlayer))
			{
				SelectionSession.ResetBufferedActions(Player.m_localPlayer);
			}
		}

		private void OnDestroy()
		{
			Selection?.Dispose();
			Holograms?.Dispose();
			Catalog?.Dispose();
			Harmony obj = harmony;
			if (obj != null)
			{
				obj.UnpatchSelf();
			}
			if ((Object)(object)Instance == (Object)(object)this)
			{
				Instance = null;
			}
		}

		internal void Warn(string message)
		{
			((BaseUnityPlugin)this).Logger.LogWarning((object)message);
		}

		internal void Error(Exception exception)
		{
			((BaseUnityPlugin)this).Logger.LogError((object)exception);
		}

		internal static void Tell(string text)
		{
			Player localPlayer = Player.m_localPlayer;
			if (localPlayer != null)
			{
				((Character)localPlayer).Message((MessageType)2, text, 0, (Sprite)null, false);
			}
		}
	}
	[HarmonyPatch]
	internal static class GamePatches
	{
		[HarmonyPostfix]
		[HarmonyPatch(typeof(Player), "TakeInput")]
		private static void BlockRemovalDialogInput(Player __instance, ref bool __result)
		{
			if ((Object)(object)__instance == (Object)(object)Player.m_localPlayer && Object.op_Implicit((Object)(object)SaveStructurePlugin.Instance) && SaveStructurePlugin.Instance.BlocksInput)
			{
				__result = false;
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(ZInput), "GetMouseScrollWheel")]
		private static void ReserveBoxHeightScroll(ref float __result)
		{
			SaveStructurePlugin instance = SaveStructurePlugin.Instance;
			if (Object.op_Implicit((Object)(object)instance) && instance.Selection != null && instance.Selection.ReservesScroll && !instance.Selection.ReadingHeightScroll)
			{
				__result = 0f;
			}
		}

		[HarmonyPrefix]
		[HarmonyPriority(0)]
		[HarmonyPatch(typeof(Player), "UpdatePlacement")]
		private static bool UpdatePlacement(Player __instance, bool takeInput)
		{
			if ((Object)(object)__instance != (Object)(object)Player.m_localPlayer)
			{
				return true;
			}
			return SaveStructurePlugin.Instance.HandleInput(__instance, takeInput);
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(Player), "CheckPlacementGhostVSPlayers")]
		private static bool IgnorePlacementOverlap(Player __instance, ref bool __result)
		{
			SaveStructurePlugin instance = SaveStructurePlugin.Instance;
			if ((Object)(object)__instance != (Object)(object)Player.m_localPlayer || !instance.DisableCollision.Value || !instance.Catalog.TryGet(__instance.GetSelectedPiece(), out StructureEntry _))
			{
				return true;
			}
			__result = false;
			return false;
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(Player), "Interact")]
		private static bool ReserveHologramInteraction(Player __instance)
		{
			if ((Object)(object)__instance != (Object)(object)Player.m_localPlayer || !SaveStructurePlugin.InputAllowed(__instance) || !SelectionSession.HasHammer(__instance))
			{
				return true;
			}
			SaveStructurePlugin instance = SaveStructurePlugin.Instance;
			if (instance.S