using System;
using System.Collections;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Drawing;
using System.IO;
using System.Linq;
using System.Linq.Expressions;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Text;
using System.Text.RegularExpressions;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Mono.Cecil;
using Mono.Cecil.Cil;
using Mono.Collections.Generic;
using MonoMod.Cil;
using MonoMod.Utils;
using UnityEngine;
using Valheim.ServersideQoL.Processors;
using YamlDotNet.Serialization;
using YamlDotNet.Serialization.TypeInspectors;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("Valheim.ServersideQoL")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.1.0.0")]
[assembly: AssemblyInformationalVersion("1.1.0+07f66f7bf1d9476b17009839a8f4ffee048f54dc")]
[assembly: AssemblyProduct("Valheim.ServersideQoL")]
[assembly: AssemblyTitle("Valheim.ServersideQoL")]
[assembly: AssemblyVersion("1.0.0.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class IsUnmanagedAttribute : Attribute
	{
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.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]
	[Microsoft.CodeAnalysis.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]
	[Microsoft.CodeAnalysis.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 Valheim.ServersideQoL
{
	internal sealed class ConcurrentHashSet<T> : ICollection<T>, IEnumerable<T>, IEnumerable, IReadOnlyCollection<T> where T : notnull
	{
		private readonly ConcurrentDictionary<T, object?> _dict = new ConcurrentDictionary<T, object>();

		public int Count => _dict.Count;

		bool ICollection<T>.IsReadOnly => false;

		public bool Add(T value)
		{
			return _dict.TryAdd(value, null);
		}

		public bool Remove(T value)
		{
			object value2;
			return _dict.TryRemove(value, out value2);
		}

		void ICollection<T>.Add(T item)
		{
			if (!Add(item))
			{
				throw new InvalidOperationException();
			}
		}

		public void Clear()
		{
			_dict.Clear();
		}

		public bool Contains(T item)
		{
			return _dict.ContainsKey(item);
		}

		void ICollection<T>.CopyTo(T[] array, int arrayIndex)
		{
			throw new NotImplementedException();
		}

		IEnumerator<T> IEnumerable<T>.GetEnumerator()
		{
			return _dict.Keys.GetEnumerator();
		}

		IEnumerator IEnumerable.GetEnumerator()
		{
			return _dict.Keys.GetEnumerator();
		}
	}
	internal static class EnumUtils
	{
		private static class Generic<T> where T : unmanaged, Enum
		{
			public static bool IsBitSet { get; } = OfType(typeof(T)).IsBitSet;


			public static Func<T, ulong> EnumToUInt64 { get; }

			public static Func<ulong, T> UInt64ToEnum { get; }

			public static Func<T, long> EnumToInt64 { get; }

			public static Func<long, T> Int64ToEnum { get; }

			static Generic()
			{
				ParameterExpression parameterExpression = Expression.Parameter(typeof(T));
				EnumToUInt64 = Expression.Lambda<Func<T, ulong>>(Expression.ConvertChecked(parameterExpression, typeof(ulong)), new ParameterExpression[1] { parameterExpression }).Compile();
				ParameterExpression parameterExpression2 = Expression.Parameter(typeof(ulong));
				UInt64ToEnum = Expression.Lambda<Func<ulong, T>>(Expression.ConvertChecked(parameterExpression2, typeof(T)), new ParameterExpression[1] { parameterExpression2 }).Compile();
				ParameterExpression parameterExpression3 = Expression.Parameter(typeof(T));
				EnumToInt64 = Expression.Lambda<Func<T, long>>(Expression.ConvertChecked(parameterExpression3, typeof(long)), new ParameterExpression[1] { parameterExpression3 }).Compile();
				ParameterExpression parameterExpression4 = Expression.Parameter(typeof(long));
				Int64ToEnum = Expression.Lambda<Func<long, T>>(Expression.ConvertChecked(parameterExpression4, typeof(T)), new ParameterExpression[1] { parameterExpression4 }).Compile();
			}
		}

		public sealed class ObjectEnumUtils
		{
			public bool IsBitSet { get; } = enumType.GetCustomAttribute<FlagsAttribute>() != null;


			public Func<object, ulong> EnumToUInt64 { get; }

			public Func<ulong, object> UInt64ToEnum { get; }

			public Func<object, long> EnumToInt64 { get; }

			public Func<long, object> Int64ToEnum { get; }

			public ObjectEnumUtils(Type enumType)
			{
				ParameterExpression parameterExpression = Expression.Parameter(typeof(object));
				EnumToUInt64 = Expression.Lambda<Func<object, ulong>>(Expression.ConvertChecked(Expression.Convert(parameterExpression, enumType), typeof(ulong)), new ParameterExpression[1] { parameterExpression }).Compile();
				ParameterExpression parameterExpression2 = Expression.Parameter(typeof(ulong));
				UInt64ToEnum = Expression.Lambda<Func<ulong, object>>(Expression.Convert(Expression.ConvertChecked(parameterExpression2, enumType), typeof(object)), new ParameterExpression[1] { parameterExpression2 }).Compile();
				ParameterExpression parameterExpression3 = Expression.Parameter(typeof(object));
				EnumToInt64 = Expression.Lambda<Func<object, long>>(Expression.ConvertChecked(Expression.Convert(parameterExpression3, enumType), typeof(long)), new ParameterExpression[1] { parameterExpression3 }).Compile();
				ParameterExpression parameterExpression4 = Expression.Parameter(typeof(long));
				Int64ToEnum = Expression.Lambda<Func<long, object>>(Expression.Convert(Expression.ConvertChecked(parameterExpression4, enumType), typeof(object)), new ParameterExpression[1] { parameterExpression4 }).Compile();
				base..ctor();
			}
		}

		private static readonly ConcurrentDictionary<Type, ObjectEnumUtils> __isBitSet = new ConcurrentDictionary<Type, ObjectEnumUtils>();

		public static ObjectEnumUtils OfType(Type type)
		{
			return __isBitSet.GetOrAdd(type, (Type t) => new ObjectEnumUtils(t));
		}

		public static bool IsBitSet<T>() where T : unmanaged, Enum
		{
			return Generic<T>.IsBitSet;
		}

		public static ulong ToUInt64<T>(this T value) where T : unmanaged, Enum
		{
			return Generic<T>.EnumToUInt64(value);
		}

		public static T ToEnum<T>(ulong value) where T : unmanaged, Enum
		{
			return Generic<T>.UInt64ToEnum(value);
		}

		public static long ToInt64<T>(this T value) where T : unmanaged, Enum
		{
			return Generic<T>.EnumToInt64(value);
		}

		public static T ToEnum<T>(long value) where T : unmanaged, Enum
		{
			return Generic<T>.Int64ToEnum(value);
		}
	}
	internal interface IZDOInventoryReadOnly
	{
		IReadOnlyList<ItemData> Items { get; }
	}
	internal interface IZDOInventory
	{
		Inventory Inventory { get; }

		IList<ItemData> Items { get; }

		int? PickupRange { get; set; }

		int? FeedRange { get; set; }

		void Save();
	}
	internal sealed class ExtendedZDO : ZDO
	{
		public delegate void RecreateHandler(ExtendedZDO oldZdo, ExtendedZDO newZdo);

		public readonly struct ZDOVars_
		{
			private readonly ExtendedZDO _zdo;

			private static int __intTag = StringExtensionMethods.GetStableHashCode("argusmagnus.ServersideQoL.IntTag");

			private static int __lastSpawnedTime = StringExtensionMethods.GetStableHashCode("argusmagnus.ServersideQoL.LastSpawnedTime");

			private static int __spawnedByTrophy = StringExtensionMethods.GetStableHashCode("argusmagnus.ServersideQoL.SpawnedByTrophy");

			private static int __portalHubId = StringExtensionMethods.GetStableHashCode("argusmagnus.ServersideQoL.PortalHubId");

			private static int __returnContentToCreator = StringExtensionMethods.GetStableHashCode("argusmagnus.ServersideQoL.ReturnContentToCreator");

			public ZDOVars_(ExtendedZDO zdo)
			{
				_zdo = zdo;
			}

			private void ValidateOwnership(string filePath, int lineNo)
			{
				if (Main.Instance.Config.General.DiagnosticLogs.Value && _zdo.PrefabInfo.Container.HasValue && !_zdo.IsOwnerOrUnassigned() && !_zdo.IsModCreator())
				{
					Main.Instance.Logger.LogWarning((object)$"{Path.GetFileName(filePath)} L{lineNo}: Container was modified while it is owned by a client, which can lead to the loss of items.");
				}
			}

			public int GetState(int defaultValue = 0)
			{
				return ((ZDO)_zdo).GetInt(ZDOVars.s_state, defaultValue);
			}

			public void SetState(int value, [CallerFilePath] string filePath = "", [CallerLineNumber] int lineNo = 0)
			{
				ValidateOwnership(filePath, lineNo);
				((ZDO)_zdo).Set(ZDOVars.s_state, value, false);
			}

			public long GetCreator(long defaultValue = 0L)
			{
				return ((ZDO)_zdo).GetLong(ZDOVars.s_creator, defaultValue);
			}

			public void SetCreator(long value, [CallerFilePath] string filePath = "", [CallerLineNumber] int lineNo = 0)
			{
				ValidateOwnership(filePath, lineNo);
				((ZDO)_zdo).Set(ZDOVars.s_creator, value);
			}

			public bool GetInUse(bool defaultValue = false)
			{
				return ((ZDO)_zdo).GetBool(ZDOVars.s_inUse, defaultValue);
			}

			public void SetInUse(bool value, [CallerFilePath] string filePath = "", [CallerLineNumber] int lineNo = 0)
			{
				ValidateOwnership(filePath, lineNo);
				((ZDO)_zdo).Set(ZDOVars.s_inUse, value);
			}

			public float GetFuel(float defaultValue = 0f)
			{
				return ((ZDO)_zdo).GetFloat(ZDOVars.s_fuel, defaultValue);
			}

			public void SetFuel(float value, [CallerFilePath] string filePath = "", [CallerLineNumber] int lineNo = 0)
			{
				ValidateOwnership(filePath, lineNo);
				((ZDO)_zdo).Set(ZDOVars.s_fuel, value);
			}

			public bool GetPiece(bool defaultValue = false)
			{
				return ((ZDO)_zdo).GetBool(ZDOVars.s_piece, defaultValue);
			}

			public void SetPiece(bool value, [CallerFilePath] string filePath = "", [CallerLineNumber] int lineNo = 0)
			{
				ValidateOwnership(filePath, lineNo);
				((ZDO)_zdo).Set(ZDOVars.s_piece, value);
			}

			public string GetItems(string defaultValue = "")
			{
				return ((ZDO)_zdo).GetString(ZDOVars.s_items, defaultValue);
			}

			public void SetItems(string value, [CallerFilePath] string filePath = "", [CallerLineNumber] int lineNo = 0)
			{
				ValidateOwnership(filePath, lineNo);
				((ZDO)_zdo).Set(ZDOVars.s_items, value);
			}

			public string GetTag(string defaultValue = "")
			{
				return ((ZDO)_zdo).GetString(ZDOVars.s_tag, defaultValue);
			}

			public void SetTag(string value, [CallerFilePath] string filePath = "", [CallerLineNumber] int lineNo = 0)
			{
				ValidateOwnership(filePath, lineNo);
				((ZDO)_zdo).Set(ZDOVars.s_tag, value);
			}

			public byte[]? GetData(byte[]? defaultValue = null)
			{
				return ((ZDO)_zdo).GetByteArray(ZDOVars.s_data, defaultValue);
			}

			public void SetData(byte[]? value, [CallerFilePath] string filePath = "", [CallerLineNumber] int lineNo = 0)
			{
				ValidateOwnership(filePath, lineNo);
				((ZDO)_zdo).Set(ZDOVars.s_data, value);
			}

			public float GetStamina(float defaultValue = 0f)
			{
				return ((ZDO)_zdo).GetFloat(ZDOVars.s_stamina, defaultValue);
			}

			public void SetStamina(float value, [CallerFilePath] string filePath = "", [CallerLineNumber] int lineNo = 0)
			{
				ValidateOwnership(filePath, lineNo);
				((ZDO)_zdo).Set(ZDOVars.s_stamina, value);
			}

			public long GetPlayerID(long defaultValue = 0L)
			{
				return ((ZDO)_zdo).GetLong(ZDOVars.s_playerID, defaultValue);
			}

			public void SetPlayerID(long value, [CallerFilePath] string filePath = "", [CallerLineNumber] int lineNo = 0)
			{
				ValidateOwnership(filePath, lineNo);
				((ZDO)_zdo).Set(ZDOVars.s_playerID, value);
			}

			public string GetPlayerName(string defaultValue = "")
			{
				return ((ZDO)_zdo).GetString(ZDOVars.s_playerName, defaultValue);
			}

			public void SetPlayerName(string value, [CallerFilePath] string filePath = "", [CallerLineNumber] int lineNo = 0)
			{
				ValidateOwnership(filePath, lineNo);
				((ZDO)_zdo).Set(ZDOVars.s_playerName, value);
			}

			public string GetFollow(string defaultValue = "")
			{
				return ((ZDO)_zdo).GetString(ZDOVars.s_follow, defaultValue);
			}

			public void SetFollow(string value, [CallerFilePath] string filePath = "", [CallerLineNumber] int lineNo = 0)
			{
				ValidateOwnership(filePath, lineNo);
				((ZDO)_zdo).Set(ZDOVars.s_follow, value);
			}

			public int GetRightItem(int defaultValue = 0)
			{
				return ((ZDO)_zdo).GetInt(ZDOVars.s_rightItem, defaultValue);
			}

			public void SetRightItem(int value, [CallerFilePath] string filePath = "", [CallerLineNumber] int lineNo = 0)
			{
				ValidateOwnership(filePath, lineNo);
				((ZDO)_zdo).Set(ZDOVars.s_rightItem, value, false);
			}

			public string GetText(string defaultValue = "")
			{
				return ((ZDO)_zdo).GetString(ZDOVars.s_text, defaultValue);
			}

			public void SetText(string value, [CallerFilePath] string filePath = "", [CallerLineNumber] int lineNo = 0)
			{
				ValidateOwnership(filePath, lineNo);
				((ZDO)_zdo).Set(ZDOVars.s_text, value);
			}

			public string GetItem(string defaultValue = "")
			{
				return ((ZDO)_zdo).GetString(ZDOVars.s_item, defaultValue);
			}

			public void SetItem(string value, [CallerFilePath] string filePath = "", [CallerLineNumber] int lineNo = 0)
			{
				ValidateOwnership(filePath, lineNo);
				((ZDO)_zdo).Set(ZDOVars.s_item, value);
			}

			public string GetItem(int idx, string defaultValue = "")
			{
				return ((ZDO)_zdo).GetString(FormattableString.Invariant($"item{idx}"), defaultValue);
			}

			public void SetItem(int idx, string value, [CallerFilePath] string filePath = "", [CallerLineNumber] int lineNo = 0)
			{
				ValidateOwnership(filePath, lineNo);
				((ZDO)_zdo).Set(FormattableString.Invariant($"item{idx}"), value);
			}

			public int GetQueued(int defaultValue = 0)
			{
				return ((ZDO)_zdo).GetInt(ZDOVars.s_queued, defaultValue);
			}

			public void SetQueued(int value, [CallerFilePath] string filePath = "", [CallerLineNumber] int lineNo = 0)
			{
				ValidateOwnership(filePath, lineNo);
				((ZDO)_zdo).Set(ZDOVars.s_queued, value, false);
			}

			public bool GetTamed(bool defaultValue = false)
			{
				return ((ZDO)_zdo).GetBool(ZDOVars.s_tamed, defaultValue);
			}

			public void SetTamed(bool value, [CallerFilePath] string filePath = "", [CallerLineNumber] int lineNo = 0)
			{
				ValidateOwnership(filePath, lineNo);
				((ZDO)_zdo).Set(ZDOVars.s_tamed, value);
			}

			public float GetTameTimeLeft(float defaultValue = 0f)
			{
				return ((ZDO)_zdo).GetFloat(ZDOVars.s_tameTimeLeft, defaultValue);
			}

			public void SetTameTimeLeft(float value, [CallerFilePath] string filePath = "", [CallerLineNumber] int lineNo = 0)
			{
				ValidateOwnership(filePath, lineNo);
				((ZDO)_zdo).Set(ZDOVars.s_tameTimeLeft, value);
			}

			public int GetAmmo(int defaultValue = 0)
			{
				return ((ZDO)_zdo).GetInt(ZDOVars.s_ammo, defaultValue);
			}

			public void SetAmmo(int value, [CallerFilePath] string filePath = "", [CallerLineNumber] int lineNo = 0)
			{
				ValidateOwnership(filePath, lineNo);
				((ZDO)_zdo).Set(ZDOVars.s_ammo, value, false);
			}

			public string GetAmmoType(string defaultValue = "")
			{
				return ((ZDO)_zdo).GetString(ZDOVars.s_ammoType, defaultValue);
			}

			public void SetAmmoType(string value, [CallerFilePath] string filePath = "", [CallerLineNumber] int lineNo = 0)
			{
				ValidateOwnership(filePath, lineNo);
				((ZDO)_zdo).Set(ZDOVars.s_ammoType, value);
			}

			public float GetGrowStart(float defaultValue = 0f)
			{
				return ((ZDO)_zdo).GetFloat(ZDOVars.s_growStart, defaultValue);
			}

			public void SetGrowStart(float value, [CallerFilePath] string filePath = "", [CallerLineNumber] int lineNo = 0)
			{
				ValidateOwnership(filePath, lineNo);
				((ZDO)_zdo).Set(ZDOVars.s_growStart, value);
			}

			public DateTime GetSpawnTime(DateTime defaultValue = default(DateTime))
			{
				return new DateTime(((ZDO)_zdo).GetLong(ZDOVars.s_spawnTime, defaultValue.Ticks));
			}

			public void SetSpawnTime(DateTime value, [CallerFilePath] string filePath = "", [CallerLineNumber] int lineNo = 0)
			{
				ValidateOwnership(filePath, lineNo);
				((ZDO)_zdo).Set(ZDOVars.s_spawnTime, value.Ticks);
			}

			public float GetHealth(float defaultValue = 0f)
			{
				return ((ZDO)_zdo).GetFloat(ZDOVars.s_health, defaultValue);
			}

			public void SetHealth(float value, [CallerFilePath] string filePath = "", [CallerLineNumber] int lineNo = 0)
			{
				ValidateOwnership(filePath, lineNo);
				((ZDO)_zdo).Set(ZDOVars.s_health, value);
			}

			public void RemoveHealth([CallerFilePath] string filePath = "", [CallerLineNumber] int lineNo = 0)
			{
				ValidateOwnership(filePath, lineNo);
				((ZDO)_zdo).RemoveFloat(ZDOVars.s_health);
			}

			public int GetPermitted(int defaultValue = 0)
			{
				return ((ZDO)_zdo).GetInt(ZDOVars.s_permitted, defaultValue);
			}

			public void SetPermitted(int value, [CallerFilePath] string filePath = "", [CallerLineNumber] int lineNo = 0)
			{
				ValidateOwnership(filePath, lineNo);
				((ZDO)_zdo).Set(ZDOVars.s_permitted, value, false);
			}

			public int GetLevel(int defaultValue = 1)
			{
				return ((ZDO)_zdo).GetInt(ZDOVars.s_level, defaultValue);
			}

			public void SetLevel(int value, [CallerFilePath] string filePath = "", [CallerLineNumber] int lineNo = 0)
			{
				ValidateOwnership(filePath, lineNo);
				((ZDO)_zdo).Set(ZDOVars.s_level, value, false);
			}

			public bool GetPatrol(bool defaultValue = false)
			{
				return ((ZDO)_zdo).GetBool(ZDOVars.s_patrol, defaultValue);
			}

			public void SetPatrol(bool value, [CallerFilePath] string filePath = "", [CallerLineNumber] int lineNo = 0)
			{
				ValidateOwnership(filePath, lineNo);
				((ZDO)_zdo).Set(ZDOVars.s_patrol, value);
			}

			public Vector3 GetPatrolPoint(Vector3 defaultValue = default(Vector3))
			{
				//IL_000b: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: Unknown result type (might be due to invalid IL or missing references)
				return ((ZDO)_zdo).GetVec3(ZDOVars.s_patrolPoint, defaultValue);
			}

			public void SetPatrolPoint(Vector3 value, [CallerFilePath] string filePath = "", [CallerLineNumber] int lineNo = 0)
			{
				//IL_0013: Unknown result type (might be due to invalid IL or missing references)
				ValidateOwnership(filePath, lineNo);
				((ZDO)_zdo).Set(ZDOVars.s_patrolPoint, value);
			}

			public Vector3 GetSpawnPoint(Vector3 defaultValue = default(Vector3))
			{
				//IL_000b: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: Unknown result type (might be due to invalid IL or missing references)
				return ((ZDO)_zdo).GetVec3(ZDOVars.s_spawnPoint, defaultValue);
			}

			public void SetSpawnPoint(Vector3 value, [CallerFilePath] string filePath = "", [CallerLineNumber] int lineNo = 0)
			{
				//IL_0013: Unknown result type (might be due to invalid IL or missing references)
				ValidateOwnership(filePath, lineNo);
				((ZDO)_zdo).Set(ZDOVars.s_spawnPoint, value);
			}

			public int GetEmoteID(int defaultValue = 0)
			{
				return ((ZDO)_zdo).GetInt(ZDOVars.s_emoteID, defaultValue);
			}

			public Emotes GetEmote(Emotes defaultValue = -1)
			{
				//IL_0021: Unknown result type (might be due to invalid IL or missing references)
				//IL_001f: Unknown result type (might be due to invalid IL or missing references)
				if (!Enum.TryParse<Emotes>(((ZDO)_zdo).GetString(ZDOVars.s_emote, ""), ignoreCase: true, out Emotes result))
				{
					return defaultValue;
				}
				return result;
			}

			public bool GetIsEncumbered(bool defaultValue = false)
			{
				return ((ZDO)_zdo).GetBool(PrivateAccessor.ZSyncAnimationZDOSalt + PrivateAccessor.CharacterAnimationHashEncumbered, defaultValue);
			}

			public DateTime GetTameLastFeeding(DateTime defaultValue = default(DateTime))
			{
				return new DateTime(((ZDO)_zdo).GetLong(ZDOVars.s_tameLastFeeding, defaultValue.Ticks));
			}

			public void SetTameLastFeeding(DateTime value, [CallerFilePath] string filePath = "", [CallerLineNumber] int lineNo = 0)
			{
				ValidateOwnership(filePath, lineNo);
				((ZDO)_zdo).Set(ZDOVars.s_tameLastFeeding, value.Ticks);
			}

			public int GetIntTag(int defaultValue = 0)
			{
				return ((ZDO)_zdo).GetInt(__intTag, defaultValue);
			}

			public void SetIntTag(int value, [CallerFilePath] string filePath = "", [CallerLineNumber] int lineNo = 0)
			{
				ValidateOwnership(filePath, lineNo);
				((ZDO)_zdo).Set(__intTag, value, false);
			}

			public void RemoveIntTag([CallerFilePath] string filePath = "", [CallerLineNumber] int lineNo = 0)
			{
				ValidateOwnership(filePath, lineNo);
				((ZDO)_zdo).RemoveInt(__intTag);
			}

			public DateTimeOffset GetLastSpawnedTime(DateTimeOffset defaultValue = default(DateTimeOffset))
			{
				return new DateTimeOffset(((ZDO)_zdo).GetLong(__lastSpawnedTime, defaultValue.Ticks), default(TimeSpan));
			}

			public void SetLastSpawnedTime(DateTimeOffset value, [CallerFilePath] string filePath = "", [CallerLineNumber] int lineNo = 0)
			{
				ValidateOwnership(filePath, lineNo);
				((ZDO)_zdo).Set(__lastSpawnedTime, value.Ticks - value.Offset.Ticks);
			}

			public bool GetSpawnedByTrophy(bool defaultValue = false)
			{
				return ((ZDO)_zdo).GetBool(__spawnedByTrophy, defaultValue);
			}

			public void SetSpawnedByTrophy(bool value, [CallerFilePath] string filePath = "", [CallerLineNumber] int lineNo = 0)
			{
				ValidateOwnership(filePath, lineNo);
				((ZDO)_zdo).Set(__spawnedByTrophy, value);
			}

			public int GetPortalHubId(int defaultValue = 0)
			{
				return ((ZDO)_zdo).GetInt(__portalHubId, defaultValue);
			}

			public void SetPortalHubId(int value, [CallerFilePath] string filePath = "", [CallerLineNumber] int lineNo = 0)
			{
				ValidateOwnership(filePath, lineNo);
				((ZDO)_zdo).Set(__portalHubId, value, false);
			}

			public bool GetReturnContentToCreator(bool defaultValue = false)
			{
				return ((ZDO)_zdo).GetBool(__returnContentToCreator, defaultValue);
			}

			public void SetReturnContentToCreator(bool value, [CallerFilePath] string filePath = "", [CallerLineNumber] int lineNo = 0)
			{
				ValidateOwnership(filePath, lineNo);
				((ZDO)_zdo).Set(__returnContentToCreator, value);
			}

			public bool GetSacrifiedMegingjord(long playerID, bool defaultValue = false)
			{
				return ((ZDO)_zdo).GetBool($"player{playerID}_SacrifiedMegingjord", defaultValue);
			}

			public void SetSacrifiedMegingjord(long playerID, bool value, [CallerFilePath] string filePath = "", [CallerLineNumber] int lineNo = 0)
			{
				ValidateOwnership(filePath, lineNo);
				((ZDO)_zdo).Set($"player{playerID}_SacrifiedMegingjord", value);
			}

			public bool GetSacrifiedCryptKey(long playerID, bool defaultValue = false)
			{
				return ((ZDO)_zdo).GetBool($"player{playerID}_SacrifiedCryptKey", defaultValue);
			}

			public void SetSacrifiedCryptKey(long playerID, bool value, [CallerFilePath] string filePath = "", [CallerLineNumber] int lineNo = 0)
			{
				ValidateOwnership(filePath, lineNo);
				((ZDO)_zdo).Set($"player{playerID}_SacrifiedCryptKey", value);
			}

			public bool GetSacrifiedWishbone(long playerID, bool defaultValue = false)
			{
				return ((ZDO)_zdo).GetBool($"player{playerID}_SacrifiedWishbone", defaultValue);
			}

			public void SetSacrifiedWishbone(long playerID, bool value, [CallerFilePath] string filePath = "", [CallerLineNumber] int lineNo = 0)
			{
				ValidateOwnership(filePath, lineNo);
				((ZDO)_zdo).Set($"player{playerID}_SacrifiedWishbone", value);
			}

			public bool GetSacrifiedTornSpirit(long playerID, bool defaultValue = false)
			{
				return ((ZDO)_zdo).GetBool($"player{playerID}_SacrifiedTornSpirit", defaultValue);
			}

			public void SetSacrifiedTornSpirit(long playerID, bool value, [CallerFilePath] string filePath = "", [CallerLineNumber] int lineNo = 0)
			{
				ValidateOwnership(filePath, lineNo);
				((ZDO)_zdo).Set($"player{playerID}_SacrifiedTornSpirit", value);
			}
		}

		private sealed class AdditionalData_
		{
			private static ConcurrentDictionary<int, IReadOnlyList<Processor>> _processors = new ConcurrentDictionary<int, IReadOnlyList<Processor>>();

			public IReadOnlyList<Processor> Processors { get; private set; } = Processor.DefaultProcessors;


			public PrefabInfo PrefabInfo { get; }

			public ConcurrentDictionary<Type, object>? ComponentFieldAccessors { get; set; }

			public Dictionary<Processor, (uint Data, uint Owner)>? ProcessorDataRevisions { get; set; }

			public ZDOInventory? Inventory { get; set; }

			public bool? HasFields { get; set; }

			public RecreateHandler? Recreated { get; set; }

			public Action<ExtendedZDO>? Destroyed { get; set; }

			public static AdditionalData_ Dummy { get; } = new AdditionalData_(Valheim.ServersideQoL.PrefabInfo.Dummy);


			public AdditionalData_(PrefabInfo prefabInfo)
			{
				PrefabInfo = prefabInfo;
				base..ctor();
			}

			public void Ungregister(IEnumerable<Processor> processors)
			{
				IEnumerable<Processor> processors2 = processors;
				int num = 0;
				foreach (Processor processor in Processors)
				{
					if (!processors2.Any((Processor x) => x == processor))
					{
						num = (num, processor.GetType()).GetHashCode();
					}
				}
				Processors = _processors.GetOrAdd(num, (int _) => Processors.Where((Processor x) => !processors2.Any((Processor y) => x == y)).ToList());
				foreach (Processor item in processors2)
				{
					ProcessorDataRevisions?.Remove(item);
				}
			}

			public void UnregisterAll()
			{
				Processors = Array.Empty<Processor>();
			}

			public void ReregisterAll()
			{
				Processors = Processor.DefaultProcessors;
			}
		}

		public sealed class ComponentFieldAccessor<TComponent>
		{
			private readonly ExtendedZDO _zdo;

			private readonly TComponent _component;

			private bool? _hasComponentFields;

			private static readonly int __hasComponentFieldsHash = StringExtensionMethods.GetStableHashCode(FormattableString.Invariant(FormattableStringFactory.Create("{0}{1}", "HasFields", typeof(TComponent).Name)));

			public bool HasFields
			{
				get
				{
					if (_zdo.HasFields)
					{
						bool valueOrDefault = _hasComponentFields.GetValueOrDefault();
						if (!_hasComponentFields.HasValue)
						{
							valueOrDefault = ((ZDO)_zdo).GetBool(__hasComponentFieldsHash, false);
							_hasComponentFields = valueOrDefault;
							return valueOrDefault;
						}
						return valueOrDefault;
					}
					return false;
				}
			}

			public ComponentFieldAccessor(ExtendedZDO zdo, TComponent component)
			{
				_zdo = zdo;
				_component = component;
				base..ctor();
			}

			private void SetHasFields(bool value)
			{
				if (value && !_zdo.HasFields)
				{
					_zdo.SetHasFields();
				}
				if (_hasComponentFields != value)
				{
					ExtendedZDO zdo = _zdo;
					int _hasComponentFieldsHash = __hasComponentFieldsHash;
					bool? flag = (_hasComponentFields = value);
					((ZDO)zdo).Set(_hasComponentFieldsHash, flag.Value);
				}
			}

			private static int GetHash<T>(Expression<Func<TComponent, T>> fieldExpression, out FieldInfo field)
			{
				MemberExpression memberExpression = (MemberExpression)fieldExpression.Body;
				field = (FieldInfo)memberExpression.Member;
				return StringExtensionMethods.GetStableHashCode(FormattableString.Invariant($"{typeof(TComponent).Name}.{field.Name}"));
			}

			private T Get<T>(Expression<Func<TComponent, T>> fieldExpression, Func<ZDO, int, T?, T> getter)
			{
				FieldInfo fieldInfo = (FieldInfo)((MemberExpression)fieldExpression.Body).Member;
				if (!HasFields)
				{
					return (T)fieldInfo.GetValue(_component);
				}
				int stableHashCode = StringExtensionMethods.GetStableHashCode(FormattableString.Invariant($"{typeof(TComponent).Name}.{fieldInfo.Name}"));
				return getter((ZDO)(object)_zdo, stableHashCode, (T)fieldInfo.GetValue(_component));
			}

			public bool GetBool(Expression<Func<TComponent, bool>> fieldExpression)
			{
				return Get(fieldExpression, (ZDO zdo, int hash, bool defaultValue) => zdo.GetBool(hash, defaultValue));
			}

			public float GetFloat(Expression<Func<TComponent, float>> fieldExpression)
			{
				return Get(fieldExpression, (ZDO zdo, int hash, float defaultValue) => zdo.GetFloat(hash, defaultValue));
			}

			public int GetInt(Expression<Func<TComponent, int>> fieldExpression)
			{
				return Get(fieldExpression, (ZDO zdo, int hash, int defaultValue) => zdo.GetInt(hash, defaultValue));
			}

			public string GetString(Expression<Func<TComponent, string>> fieldExpression)
			{
				return Get(fieldExpression, (ZDO zdo, int hash, string? defaultValue) => zdo.GetString(hash, defaultValue));
			}

			private ComponentFieldAccessor<TComponent> SetCore<TObj, T>(Expression<Func<TComponent, TObj>> fieldExpression, TObj valueObj, Action<ZDO, int>? remover, Action<ZDO, int, T> setter, Func<TObj, T> cast) where TObj : notnull where T : notnull
			{
				FieldInfo field;
				int hash = GetHash(fieldExpression, out field);
				T arg = cast(valueObj);
				if (remover != null)
				{
					ref T reference = ref arg;
					T val = default(T);
					if (val == null)
					{
						val = reference;
						reference = ref val;
					}
					if (reference.Equals(cast((TObj)field.GetValue(_component))))
					{
						remover((ZDO)(object)_zdo, hash);
						goto IL_008b;
					}
				}
				if (!HasFields)
				{
					SetHasFields(value: true);
				}
				setter((ZDO)(object)_zdo, hash, arg);
				goto IL_008b;
				IL_008b:
				return this;
			}

			private ComponentFieldAccessor<TComponent> SetCore<T>(Expression<Func<TComponent, T>> fieldExpression, T value, Action<ZDO, int>? remover, Action<ZDO, int, T> setter) where T : notnull
			{
				return SetCore(fieldExpression, value, remover, setter, (T x) => x);
			}

			public ComponentFieldAccessor<TComponent> Set(Expression<Func<TComponent, bool>> fieldExpression, bool value)
			{
				return SetCore(fieldExpression, value, delegate(ZDO zdo, int hash)
				{
					zdo.RemoveInt(hash);
				}, delegate(ZDO zdo, int hash, bool value)
				{
					zdo.Set(hash, value);
				});
			}

			public ComponentFieldAccessor<TComponent> Set(Expression<Func<TComponent, float>> fieldExpression, float value)
			{
				return SetCore(fieldExpression, value, delegate(ZDO zdo, int hash)
				{
					zdo.RemoveFloat(hash);
				}, delegate(ZDO zdo, int hash, float value)
				{
					zdo.Set(hash, value);
				});
			}

			public ComponentFieldAccessor<TComponent> Set(Expression<Func<TComponent, int>> fieldExpression, int value)
			{
				return SetCore(fieldExpression, value, delegate(ZDO zdo, int hash)
				{
					zdo.RemoveInt(hash);
				}, delegate(ZDO zdo, int hash, int value)
				{
					zdo.Set(hash, value, false);
				});
			}

			public ComponentFieldAccessor<TComponent> Set(Expression<Func<TComponent, Vector3>> fieldExpression, Vector3 value)
			{
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				return SetCore(fieldExpression, value, delegate(ZDO zdo, int hash)
				{
					zdo.RemoveVec3(hash);
				}, delegate(ZDO zdo, int hash, Vector3 value)
				{
					//IL_0002: Unknown result type (might be due to invalid IL or missing references)
					zdo.Set(hash, value);
				});
			}

			public ComponentFieldAccessor<TComponent> Set(Expression<Func<TComponent, string>> fieldExpression, string value)
			{
				return SetCore(fieldExpression, value, null, delegate(ZDO zdo, int hash, string value)
				{
					zdo.Set(hash, value);
				});
			}

			public ComponentFieldAccessor<TComponent> Set(Expression<Func<TComponent, GameObject>> fieldExpression, GameObject value)
			{
				return SetCore(fieldExpression, value, null, delegate(ZDO zdo, int hash, string value)
				{
					zdo.Set(hash, value);
				}, (GameObject x) => ((Object)x).name);
			}

			public ComponentFieldAccessor<TComponent> Set(Expression<Func<TComponent, ItemDrop>> fieldExpression, ItemDrop value)
			{
				return SetCore(fieldExpression, value, null, delegate(ZDO zdo, int hash, string value)
				{
					zdo.Set(hash, value);
				}, (ItemDrop x) => ((Object)x).name);
			}

			private bool SetIfChangedCore<TObj, T>(Expression<Func<TComponent, TObj>> fieldExpression, TObj valueObj, Action<ZDO, int>? remover, Action<ZDO, int, T> setter, Func<ZDO, int, T?, T> getter, Func<TObj, T> cast) where TObj : notnull where T : notnull
			{
				FieldInfo field;
				int hash = GetHash(fieldExpression, out field);
				T val = cast((TObj)field.GetValue(_component));
				T arg = cast(valueObj);
				ref T reference = ref arg;
				T val2 = default(T);
				if (val2 == null)
				{
					val2 = reference;
					reference = ref val2;
				}
				if (reference.Equals(getter((ZDO)(object)_zdo, hash, val)))
				{
					return false;
				}
				if (remover != null && arg.Equals(val))
				{
					remover((ZDO)(object)_zdo, hash);
				}
				else
				{
					if (!HasFields)
					{
						SetHasFields(value: true);
					}
					setter((ZDO)(object)_zdo, hash, arg);
				}
				return true;
			}

			private bool SetIfChangedCore<T>(Expression<Func<TComponent, T>> fieldExpression, T value, Action<ZDO, int>? remover, Action<ZDO, int, T> setter, Func<ZDO, int, T?, T> getter) where T : notnull
			{
				return SetIfChangedCore(fieldExpression, value, remover, setter, getter, (T x) => x);
			}

			public bool SetIfChanged(Expression<Func<TComponent, bool>> fieldExpression, bool value)
			{
				return SetIfChangedCore(fieldExpression, value, delegate(ZDO zdo, int hash)
				{
					zdo.RemoveInt(hash);
				}, delegate(ZDO zdo, int hash, bool value)
				{
					zdo.Set(hash, value);
				}, (ZDO zdo, int hash, bool defaultValue) => zdo.GetBool(hash, defaultValue));
			}

			public bool SetIfChanged(Expression<Func<TComponent, float>> fieldExpression, float value)
			{
				return SetIfChangedCore(fieldExpression, value, delegate(ZDO zdo, int hash)
				{
					zdo.RemoveFloat(hash);
				}, delegate(ZDO zdo, int hash, float value)
				{
					zdo.Set(hash, value);
				}, (ZDO zdo, int hash, float defaultValue) => zdo.GetFloat(hash, defaultValue));
			}

			public bool SetIfChanged(Expression<Func<TComponent, int>> fieldExpression, int value)
			{
				return SetIfChangedCore(fieldExpression, value, delegate(ZDO zdo, int hash)
				{
					zdo.RemoveInt(hash);
				}, delegate(ZDO zdo, int hash, int value)
				{
					zdo.Set(hash, value, false);
				}, (ZDO zdo, int hash, int defaultValue) => zdo.GetInt(hash, defaultValue));
			}

			public bool SetIfChanged(Expression<Func<TComponent, string>> fieldExpression, string value)
			{
				return SetIfChangedCore(fieldExpression, value, null, delegate(ZDO zdo, int hash, string value)
				{
					zdo.Set(hash, value);
				}, (ZDO zdo, int hash, string? defaultValue) => zdo.GetString(hash, defaultValue));
			}

			public bool SetIfChanged(Expression<Func<TComponent, GameObject>> fieldExpression, GameObject value)
			{
				return SetIfChangedCore(fieldExpression, value, null, delegate(ZDO zdo, int hash, string value)
				{
					zdo.Set(hash, value);
				}, (ZDO zdo, int hash, string? defaultValue) => zdo.GetString(hash, defaultValue), (GameObject x) => ((Object)x).name);
			}

			public bool SetIfChanged(Expression<Func<TComponent, ItemDrop>> fieldExpression, ItemDrop value)
			{
				return SetIfChangedCore(fieldExpression, value, null, delegate(ZDO zdo, int hash, string value)
				{
					zdo.Set(hash, value);
				}, (ZDO zdo, int hash, string? defaultValue) => zdo.GetString(hash, defaultValue), (ItemDrop x) => ((Object)x).name);
			}

			private ComponentFieldAccessor<TComponent> ResetCore<T>(Expression<Func<TComponent, T>> fieldExpression, Action<ZDO, int> remover)
			{
				FieldInfo field;
				int hash = GetHash(fieldExpression, out field);
				remover((ZDO)(object)_zdo, hash);
				return this;
			}

			private ComponentFieldAccessor<TComponent> ResetCore<TObj, T>(Expression<Func<TComponent, TObj>> fieldExpression, Action<ZDO, int, T> setter, Func<TObj, T> cast) where TObj : notnull where T : notnull
			{
				FieldInfo field;
				int hash = GetHash(fieldExpression, out field);
				T arg = cast((TObj)field.GetValue(_component));
				setter((ZDO)(object)_zdo, hash, arg);
				return this;
			}

			public ComponentFieldAccessor<TComponent> Reset(Expression<Func<TComponent, bool>> fieldExpression)
			{
				return ResetCore(fieldExpression, delegate(ZDO zdo, int hash)
				{
					zdo.RemoveInt(hash);
				});
			}

			public ComponentFieldAccessor<TComponent> Reset(Expression<Func<TComponent, float>> fieldExpression)
			{
				return ResetCore(fieldExpression, delegate(ZDO zdo, int hash)
				{
					zdo.RemoveFloat(hash);
				});
			}

			public ComponentFieldAccessor<TComponent> Reset(Expression<Func<TComponent, int>> fieldExpression)
			{
				return ResetCore(fieldExpression, delegate(ZDO zdo, int hash)
				{
					zdo.RemoveInt(hash);
				});
			}

			public ComponentFieldAccessor<TComponent> Reset(Expression<Func<TComponent, string>> fieldExpression)
			{
				return ResetCore(fieldExpression, delegate(ZDO zdo, int hash, string value)
				{
					zdo.Set(hash, value);
				}, (string x) => x);
			}

			public ComponentFieldAccessor<TComponent> Reset(Expression<Func<TComponent, GameObject>> fieldExpression)
			{
				return ResetCore(fieldExpression, delegate(ZDO zdo, int hash, string value)
				{
					zdo.Set(hash, value);
				}, (GameObject x) => ((Object)x).name);
			}

			public ComponentFieldAccessor<TComponent> Reset(Expression<Func<TComponent, ItemDrop>> fieldExpression)
			{
				return ResetCore(fieldExpression, delegate(ZDO zdo, int hash, string value)
				{
					zdo.Set(hash, value);
				}, (ItemDrop x) => ((Object)x).name);
			}

			private bool ResetIfChangedCore<T>(Expression<Func<TComponent, T>> fieldExpression, Func<ZDO, int, bool> remover)
			{
				FieldInfo field;
				int hash = GetHash(fieldExpression, out field);
				return remover((ZDO)(object)_zdo, hash);
			}

			private bool ResetIfChangedCore<TObj, T>(Expression<Func<TComponent, TObj>> fieldExpression, Action<ZDO, int, T> setter, Func<ZDO, int, T?, T> getter, Func<TObj, T> cast) where TObj : notnull where T : notnull
			{
				FieldInfo field;
				int hash = GetHash(fieldExpression, out field);
				T val = cast((TObj)field.GetValue(_component));
				if (getter((ZDO)(object)_zdo, hash, val).Equals(val))
				{
					return false;
				}
				setter((ZDO)(object)_zdo, hash, val);
				return true;
			}

			public bool ResetIfChanged(Expression<Func<TComponent, bool>> fieldExpression)
			{
				return ResetIfChangedCore(fieldExpression, (ZDO zdo, int hash) => zdo.RemoveInt(hash));
			}

			public bool ResetIfChanged(Expression<Func<TComponent, float>> fieldExpression)
			{
				return ResetIfChangedCore(fieldExpression, (ZDO zdo, int hash) => zdo.RemoveFloat(hash));
			}

			public bool ResetIfChanged(Expression<Func<TComponent, int>> fieldExpression)
			{
				return ResetIfChangedCore(fieldExpression, (ZDO zdo, int hash) => zdo.RemoveInt(hash));
			}

			public bool ResetIfChanged(Expression<Func<TComponent, string>> fieldExpression)
			{
				return ResetIfChangedCore(fieldExpression, delegate(ZDO zdo, int hash, string value)
				{
					zdo.Set(hash, value);
				}, (ZDO zdo, int hash, string? defaultValue) => zdo.GetString(hash, defaultValue), (string x) => x);
			}

			public bool ResetIfChanged(Expression<Func<TComponent, GameObject>> fieldExpression)
			{
				return ResetIfChangedCore(fieldExpression, delegate(ZDO zdo, int hash, string value)
				{
					zdo.Set(hash, value);
				}, (ZDO zdo, int hash, string? defaultValue) => zdo.GetString(hash, defaultValue), (GameObject x) => ((Object)x).name);
			}

			public bool ResetIfChanged(Expression<Func<TComponent, ItemDrop>> fieldExpression)
			{
				return ResetIfChangedCore(fieldExpression, delegate(ZDO zdo, int hash, string value)
				{
					zdo.Set(hash, value);
				}, (ZDO zdo, int hash, string? defaultValue) => zdo.GetString(hash, defaultValue), (ItemDrop x) => ((Object)x).name);
			}

			public bool SetOrReset(Expression<Func<TComponent, bool>> fieldExpression, bool set, bool setValue)
			{
				if (!set)
				{
					return ResetIfChanged(fieldExpression);
				}
				return SetIfChanged(fieldExpression, setValue);
			}

			public bool SetOrReset(Expression<Func<TComponent, float>> fieldExpression, bool set, float setValue)
			{
				if (!set)
				{
					return ResetIfChanged(fieldExpression);
				}
				return SetIfChanged(fieldExpression, setValue);
			}

			public bool SetOrReset(Expression<Func<TComponent, int>> fieldExpression, bool set, int setValue)
			{
				if (!set)
				{
					return ResetIfChanged(fieldExpression);
				}
				return SetIfChanged(fieldExpression, setValue);
			}

			public bool SetOrReset(Expression<Func<TComponent, string>> fieldExpression, bool set, string setValue)
			{
				if (!set)
				{
					return ResetIfChanged(fieldExpression);
				}
				return SetIfChanged(fieldExpression, setValue);
			}

			public bool SetOrReset(Expression<Func<TComponent, GameObject>> fieldExpression, bool set, GameObject setValue)
			{
				if (!set)
				{
					return ResetIfChanged(fieldExpression);
				}
				return SetIfChanged(fieldExpression, setValue);
			}

			public bool SetOrReset(Expression<Func<TComponent, ItemDrop>> fieldExpression, bool set, ItemDrop setValue)
			{
				if (!set)
				{
					return ResetIfChanged(fieldExpression);
				}
				return SetIfChanged(fieldExpression, setValue);
			}
		}

		private sealed class ZDOInventory : IZDOInventory, IZDOInventoryReadOnly
		{
			private List<ItemData>? _items;

			private uint _dataRevision;

			private string? _lastData;

			public Inventory Inventory { get; private set; }

			public ExtendedZDO ZDO { get; private set; }

			public int? PickupRange { get; set; }

			public int? FeedRange { get; set; }

			private List<ItemData> Items
			{
				get
				{
					if (_items == null)
					{
						_items = Inventory.GetAllItems();
					}
					else if (_items != Inventory.GetAllItems())
					{
						throw new Exception("Assumption violated");
					}
					return _items;
				}
			}

			IList<ItemData> IZDOInventory.Items => Items;

			IReadOnlyList<ItemData> IZDOInventoryReadOnly.Items => Items;

			public ZDOInventory(ExtendedZDO zdo)
			{
				ZDO = zdo;
				_dataRevision = uint.MaxValue;
				base..ctor();
			}

			public ZDOInventory Update()
			{
				//IL_0135: Unknown result type (might be due to invalid IL or missing references)
				//IL_013f: Expected O, but got Unknown
				//IL_015b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0165: Expected O, but got Unknown
				if (_dataRevision == ((ZDO)ZDO).DataRevision)
				{
					return this;
				}
				string items = ZDO.Vars.GetItems();
				if (_lastData == items)
				{
					return this;
				}
				ComponentFieldAccessor<Container> componentFieldAccessor = ZDO.Fields<Container>(getUnknownComponent: false);
				int @int = componentFieldAccessor.GetInt((Expression<Func<Container, int>>)((Container x) => x.m_width));
				int int2 = componentFieldAccessor.GetInt((Expression<Func<Container, int>>)((Container x) => x.m_height));
				if (Inventory == null || Inventory.GetWidth() != @int || Inventory.GetHeight() != int2)
				{
					Inventory = new Inventory(ZDO.PrefabInfo.Container.Value.Container.m_name, ZDO.PrefabInfo.Container.Value.Container.m_bkg, @int, int2);
				}
				if (string.IsNullOrEmpty(items))
				{
					Items.Clear();
				}
				else
				{
					Inventory.Load(new ZPackage(items));
				}
				_dataRevision = ((ZDO)ZDO).DataRevision;
				_lastData = items;
				return this;
			}

			public void UpdateZDO(ExtendedZDO zdo)
			{
				ZDO = zdo;
				_items = null;
				_dataRevision = 0u;
				_lastData = null;
				Update();
			}

			public void Save()
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				//IL_0006: Expected O, but got Unknown
				//IL_009f: Unknown result type (might be due to invalid IL or missing references)
				ZPackage val = new ZPackage();
				Inventory.Save(val);
				uint dataRevision = ((ZDO)ZDO).DataRevision;
				string @base = val.GetBase64();
				ZDO.Vars.SetItems(@base, "D:\\a\\ValheimServersideQoL\\ValheimServersideQoL\\ValheimServersideQoL\\ExtendedZDO.cs", 639);
				if (dataRevision != ((ZDO)ZDO).DataRevision)
				{
					(Container, Piece, PieceTable, PrefabInfo.Optional<Incinerator>, PrefabInfo.Optional<ZSyncTransform>)? container = ZDO.PrefabInfo.Container;
					if (container.HasValue)
					{
						PrefabInfo.Optional<ZSyncTransform> item = container.GetValueOrDefault().Item5;
						if (item.Value != null)
						{
							ExtendedZDO zDO = ZDO;
							((ZDO)zDO).DataRevision = ((ZDO)zDO).DataRevision + 120;
						}
					}
					ZDOMan.instance.ForceSendZDO(((ZDO)ZDO).m_uid);
				}
				_dataRevision = ((ZDO)ZDO).DataRevision;
				_lastData = @base;
			}
		}

		private ZDOID _lastId = ZDOID.None;

		private AdditionalData_? _addData;

		private static readonly int __hasFieldsHash = StringExtensionMethods.GetStableHashCode("HasFields");

		private static bool _onZdoDestroyedRegistered;

		private AdditionalData_ AddData
		{
			get
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				//IL_001d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0022: Unknown result type (might be due to invalid IL or missing references)
				//IL_0028: Unknown result type (might be due to invalid IL or missing references)
				//IL_002d: Unknown result type (might be due to invalid IL or missing references)
				if (_lastId != base.m_uid || _addData == null)
				{
					_lastId = base.m_uid;
					if (base.m_uid != ZDOID.None)
					{
						PrefabInfo prefabInfo = SharedProcessorState.GetPrefabInfo(((ZDO)this).GetPrefab());
						if ((object)prefabInfo != null)
						{
							_addData = new AdditionalData_(prefabInfo);
							goto IL_0061;
						}
					}
					_addData = AdditionalData_.Dummy;
				}
				goto IL_0061;
				IL_0061:
				return _addData;
			}
		}

		public PrefabInfo PrefabInfo => AddData.PrefabInfo;

		public IZDOInventory Inventory
		{
			get
			{
				AdditionalData_ addData = AddData;
				ZDOInventory zDOInventory = addData.Inventory;
				if (zDOInventory == null)
				{
					if (!PrefabInfo.Container.HasValue)
					{
						throw new InvalidOperationException();
					}
					ZDOInventory zDOInventory3 = (addData.Inventory = new ZDOInventory(this));
					zDOInventory = zDOInventory3;
				}
				return zDOInventory.Update();
			}
		}

		public IZDOInventoryReadOnly InventoryReadOnly
		{
			get
			{
				AdditionalData_ addData = AddData;
				ZDOInventory zDOInventory = addData.Inventory;
				if (zDOInventory == null)
				{
					if (!PrefabInfo.Container.HasValue)
					{
						throw new InvalidOperationException();
					}
					ZDOInventory zDOInventory3 = (addData.Inventory = new ZDOInventory(this));
					zDOInventory = zDOInventory3;
				}
				return zDOInventory;
			}
		}

		public bool HasFields
		{
			get
			{
				AdditionalData_ addData = AddData;
				bool? hasFields = addData.HasFields;
				bool valueOrDefault = hasFields.GetValueOrDefault();
				if (!hasFields.HasValue)
				{
					valueOrDefault = ((ZDO)this).GetBool(__hasFieldsHash, false);
					bool? hasFields2 = valueOrDefault;
					addData.HasFields = hasFields2;
					return valueOrDefault;
				}
				return valueOrDefault;
			}
		}

		public ZDOVars_ Vars => new ZDOVars_(this);

		public IReadOnlyList<Processor> Processors => AddData.Processors;

		public event RecreateHandler? Recreated
		{
			add
			{
				AdditionalData_ addData = AddData;
				addData.Recreated = (RecreateHandler)Delegate.Combine(addData.Recreated, value);
			}
			remove
			{
				AdditionalData_ addData = AddData;
				addData.Recreated = (RecreateHandler)Delegate.Remove(addData.Recreated, value);
			}
		}

		public event Action<ExtendedZDO>? Destroyed
		{
			add
			{
				if (!_onZdoDestroyedRegistered)
				{
					ZDOMan instance = ZDOMan.instance;
					instance.m_onZDODestroyed = (Action<ZDO>)Delegate.Combine(instance.m_onZDODestroyed, new Action<ZDO>(OnZdoDestroyed));
					_onZdoDestroyedRegistered = true;
				}
				AdditionalData_ addData = AddData;
				addData.Destroyed = (Action<ExtendedZDO>)Delegate.Combine(addData.Destroyed, value);
			}
			remove
			{
				AdditionalData_ addData = AddData;
				addData.Destroyed = (Action<ExtendedZDO>)Delegate.Remove(addData.Destroyed, value);
			}
		}

		public void SetModAsCreator(Processor.CreatorMarkers marker = Processor.CreatorMarkers.None)
		{
			Vars.SetCreator((long)Main.PluginGuidHash | (long)((ulong)marker << 32), "D:\\a\\ValheimServersideQoL\\ValheimServersideQoL\\ValheimServersideQoL\\ExtendedZDO.cs", 47);
		}

		public bool IsModCreator(out Processor.CreatorMarkers marker)
		{
			marker = Processor.CreatorMarkers.None;
			if ((int)Vars.GetCreator(0L) != Main.PluginGuidHash)
			{
				return false;
			}
			marker = (Processor.CreatorMarkers)((ulong)Vars.GetCreator(0L) >> 32);
			return true;
		}

		public bool IsModCreator()
		{
			Processor.CreatorMarkers marker;
			return IsModCreator(out marker);
		}

		private static void OnZdoDestroyed(ZDO zdo)
		{
			ExtendedZDO extendedZDO = (ExtendedZDO)(object)zdo;
			extendedZDO._addData?.Destroyed?.Invoke(extendedZDO);
			extendedZDO._addData = null;
		}

		private void SetHasFields()
		{
			if ((!AddData.HasFields) ?? true)
			{
				((ZDO)this).Set(__hasFieldsHash, true);
				AddData.HasFields = true;
			}
		}

		public void UnregisterProcessors(IEnumerable<Processor> processors)
		{
			AddData.Ungregister(processors);
		}

		public void UnregisterAllProcessors()
		{
			AddData.UnregisterAll();
		}

		public void ReregisterAllProcessors()
		{
			_addData?.ReregisterAll();
		}

		public void UpdateProcessorDataRevision(Processor processor)
		{
			AdditionalData_ addData = AddData;
			(addData.ProcessorDataRevisions ?? (addData.ProcessorDataRevisions = new Dictionary<Processor, (uint, uint)>()))[processor] = (((ZDO)this).DataRevision, ((ZDO)this).OwnerRevision);
		}

		public void ResetProcessorDataRevision(Processor processor)
		{
			AddData.ProcessorDataRevisions?.Remove(processor);
		}

		public bool CheckProcessorDataRevisionChanged(Processor processor)
		{
			if (AddData.ProcessorDataRevisions != null && AddData.ProcessorDataRevisions.TryGetValue(processor, out (uint, uint) value))
			{
				(uint, uint) tuple = value;
				uint dataRevision = ((ZDO)this).DataRevision;
				ushort ownerRevision = ((ZDO)this).OwnerRevision;
				if (tuple.Item1 == dataRevision && tuple.Item2 == ownerRevision)
				{
					return false;
				}
			}
			return true;
		}

		public void Destroy()
		{
			ClaimOwnershipInternal();
			ZDOMan.instance.DestroyZDO((ZDO)(object)this);
		}

		public ExtendedZDO CreateClone()
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Expected O, but got Unknown
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Expected O, but got Unknown
			int prefab = ((ZDO)this).GetPrefab();
			Vector3 position = ((ZDO)this).GetPosition();
			long owner = ((ZDO)this).GetOwner();
			ZPackage val = new ZPackage();
			((ZDO)this).Serialize(val);
			ExtendedZDO obj = (ExtendedZDO)(object)ZDOMan.instance.CreateNewZDO(position, prefab);
			((ZDO)obj).Deserialize(new ZPackage(val.GetArray()));
			((ZDO)obj).SetOwnerInternal(owner);
			return obj;
		}

		public ExtendedZDO Recreate()
		{
			ExtendedZDO extendedZDO = CreateClone();
			_addData?.Recreated?.Invoke(this, extendedZDO);
			Destroy();
			return extendedZDO;
		}

		public void ClaimOwnership()
		{
			((ZDO)this).SetOwner(ZDOMan.GetSessionID());
		}

		public void ClaimOwnershipInternal()
		{
			((ZDO)this).SetOwnerInternal(ZDOMan.GetSessionID());
		}

		public void ReleaseOwnership()
		{
			((ZDO)this).SetOwner(0L);
		}

		public void ReleaseOwnershipInternal()
		{
			((ZDO)this).SetOwnerInternal(0L);
		}

		public bool IsOwnerOrUnassigned()
		{
			if (((ZDO)this).HasOwner())
			{
				return ((ZDO)this).IsOwner();
			}
			return true;
		}

		public TimeSpan GetTimeSinceSpawned()
		{
			return ZNet.instance.GetTime() - Vars.GetSpawnTime();
		}

		public ComponentFieldAccessor<TComponent> Fields<TComponent>(bool getUnknownComponent = false) where TComponent : MonoBehaviour
		{
			if (AddData != AdditionalData_.Dummy)
			{
				AdditionalData_ addData = AddData;
				return (ComponentFieldAccessor<TComponent>)(addData.ComponentFieldAccessors ?? (addData.ComponentFieldAccessors = new ConcurrentDictionary<Type, object>())).GetOrAdd(typeof(TComponent), delegate(Type key)
				{
					if (!PrefabInfo.Components.TryGetValue(key, out MonoBehaviour value) && getUnknownComponent)
					{
						value = (MonoBehaviour)(object)PrefabInfo.Prefab.GetComponentInChildren<TComponent>();
					}
					if (value == null)
					{
						throw new KeyNotFoundException();
					}
					return new ComponentFieldAccessor<TComponent>(this, (TComponent)(object)value);
				});
			}
			if (getUnknownComponent)
			{
				GameObject prefab = ZNetScene.instance.GetPrefab(((ZDO)this).GetPrefab());
				TComponent val = ((prefab != null) ? prefab.GetComponentInChildren<TComponent>() : default(TComponent));
				if (val == null)
				{
					throw new KeyNotFoundException();
				}
				return new ComponentFieldAccessor<TComponent>(this, val);
			}
			throw new InvalidOperationException();
		}
	}
	internal static class ExtensionMethods
	{
		public static ExtendedZDO? GetExtendedZDO(this ZDOMan instance, ZDOID id)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			return (ExtendedZDO)(object)instance.GetZDO(id);
		}

		public static int GetActiveArea(this ZoneSystem instance)
		{
			return instance.m_activeArea - 1;
		}

		public static int GetLoadedArea(this ZoneSystem instance)
		{
			return instance.m_activeArea;
		}

		[Conditional("DEBUG")]
		public static void DevLog(this ManualLogSource logger, string text, LogLevel logLevel = 4)
		{
		}

		[Conditional("DEBUG")]
		public static void AssertIs<T>(this ExtendedZDO zdo) where T : MonoBehaviour
		{
		}
	}
	[BepInPlugin("argusmagnus.ServersideQoL", "ServersideQoL", "1.1.0")]
	public sealed class Main : BaseUnityPlugin
	{
		private record SectorInfo(List<Peer> Peers, List<ZDO> ZDOs)
		{
			public int InverseWeight { get; set; }
		}

		private sealed class PeersEnumerable : IEnumerable<Peer>, IEnumerable
		{
			[CompilerGenerated]
			private sealed class <GetEnumerator>d__6 : IEnumerator<Peer>, IEnumerator, IDisposable
			{
				private int <>1__state;

				private Peer <>2__current;

				public PeersEnumerable <>4__this;

				private IEnumerator<ZNetPeer> <>7__wrap1;

				Peer IEnumerator<Peer>.Current
				{
					[DebuggerHidden]
					get
					{
						return <>2__current;
					}
				}

				object IEnumerator.Current
				{
					[DebuggerHidden]
					get
					{
						return <>2__current;
					}
				}

				[DebuggerHidden]
				public <GetEnumerator>d__6(int <>1__state)
				{
					this.<>1__state = <>1__state;
				}

				[DebuggerHidden]
				void IDisposable.Dispose()
				{
					int num = <>1__state;
					if (num == -3 || num == 2)
					{
						try
						{
						}
						finally
						{
							<>m__Finally1();
						}
					}
					<>7__wrap1 = null;
					<>1__state = -2;
				}

				private bool MoveNext()
				{
					try
					{
						int num = <>1__state;
						PeersEnumerable peersEnumerable = <>4__this;
						switch (num)
						{
						default:
							return false;
						case 0:
							<>1__state = -1;
							if (peersEnumerable._localPeer != null)
							{
								<>2__current = new Peer(peersEnumerable._localPeer);
								<>1__state = 1;
								return true;
							}
							goto IL_0059;
						case 1:
							<>1__state = -1;
							goto IL_0059;
						case 2:
							{
								<>1__state = -3;
								break;
							}
							IL_0059:
							<>7__wrap1 = peersEnumerable._peers.GetEnumerator();
							<>1__state = -3;
							break;
						}
						if (<>7__wrap1.MoveNext())
						{
							ZNetPeer current = <>7__wrap1.Current;
							<>2__current = new Peer(current);
							<>1__state = 2;
							return true;
						}
						<>m__Finally1();
						<>7__wrap1 = null;
						return false;
					}
					catch
					{
						//try-fault
						((IDisposable)this).Dispose();
						throw;
					}
				}

				bool IEnumerator.MoveNext()
				{
					//ILSpy generated this explicit interface implementation from .override directive in MoveNext
					return this.MoveNext();
				}

				private void <>m__Finally1()
				{
					<>1__state = -1;
					if (<>7__wrap1 != null)
					{
						<>7__wrap1.Dispose();
					}
				}

				[DebuggerHidden]
				void IEnumerator.Reset()
				{
					throw new NotSupportedException();
				}
			}

			private readonly ZNetPeer? _localPeer;

			private IReadOnlyList<ZNetPeer> _peers;

			public int Count => _peers.Count + ((_localPeer != null) ? 1 : 0);

			public PeersEnumerable(ZNetPeer? localPeer)
			{
				_localPeer = localPeer;
				_peers = Array.Empty<ZNetPeer>();
				base..ctor();
			}

			public void Update()
			{
				//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)
				if (_localPeer != null)
				{
					_localPeer.m_refPos = ZNet.instance.GetReferencePosition();
				}
				_peers = ZNet.instance.GetPeers();
			}

			[IteratorStateMachine(typeof(<GetEnumerator>d__6))]
			public IEnumerator<Peer> GetEnumerator()
			{
				//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
				return new <GetEnumerator>d__6(0)
				{
					<>4__this = this
				};
			}

			IEnumerator IEnumerable.GetEnumerator()
			{
				return GetEnumerator();
			}
		}

		private sealed class MyTerminal : Terminal
		{
			private sealed class MyConsoleEventArgs : ConsoleEventArgs
			{
				public MyConsoleEventArgs(string command, params string[] args)
					: base("", (Terminal)null)
				{
					int num = 0;
					string[] array = new string[1 + args.Length];
					array[num] = command;
					num++;
					ReadOnlySpan<string> readOnlySpan = new ReadOnlySpan<string>(args);
					readOnlySpan.CopyTo(new Span<string>(array).Slice(num, readOnlySpan.Length));
					num += readOnlySpan.Length;
					base.Args = array;
				}
			}

			protected override Terminal m_terminalInstance
			{
				get
				{
					throw new NotImplementedException();
				}
			}

			public static void ExecuteCommand(string command, params string[] args)
			{
				ConsoleCommand command2 = Terminal.commands[command];
				ConsoleEvent action = command2.GetAction();
				if (action != null)
				{
					action.Invoke((ConsoleEventArgs)(object)new MyConsoleEventArgs(command, args));
					return;
				}
				ConsoleEventFailable actionFailable = command2.GetActionFailable();
				if (actionFailable != null)
				{
					object obj = actionFailable.Invoke((ConsoleEventArgs)(object)new MyConsoleEventArgs(command, args));
					if (obj is bool && (bool)obj)
					{
						return;
					}
					throw new Exception(obj.ToString());
				}
				throw new ArgumentException("command");
			}
		}

		private sealed class DummySocket : ISocket
		{
			public ISocket Accept()
			{
				throw new NotImplementedException();
			}

			public void Close()
			{
			}

			public void Dispose()
			{
			}

			public bool Flush()
			{
				throw new NotImplementedException();
			}

			public void GetAndResetStats(out int totalSent, out int totalRecv)
			{
				throw new NotImplementedException();
			}

			public void GetConnectionQuality(out float localQuality, out float remoteQuality, out int ping, out float outByteSec, out float inByteSec)
			{
				throw new NotImplementedException();
			}

			public int GetCurrentSendRate()
			{
				throw new NotImplementedException();
			}

			public string GetEndPointString()
			{
				throw new NotImplementedException();
			}

			public string GetHostName()
			{
				return "";
			}

			public int GetHostPort()
			{
				throw new NotImplementedException();
			}

			public int GetSendQueueSize()
			{
				throw new NotImplementedException();
			}

			public bool GotNewData()
			{
				throw new NotImplementedException();
			}

			public bool IsConnected()
			{
				return true;
			}

			public bool IsHost()
			{
				throw new NotImplementedException();
			}

			public ZPackage Recv()
			{
				throw new NotImplementedException();
			}

			public void Send(ZPackage pkg)
			{
				throw new NotImplementedException();
			}

			public void VersionMatch()
			{
				throw new NotImplementedException();
			}
		}

		[CompilerGenerated]
		private sealed class <<Start>g__CallExecute|35_0>d : IEnumerator<YieldInstruction>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private YieldInstruction <>2__current;

			public Main <>4__this;

			private PeersEnumerable <peers>5__2;

			YieldInstruction IEnumerator<YieldInstruction>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <<Start>g__CallExecute|35_0>d(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<peers>5__2 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0041: Unknown result type (might be due to invalid IL or missing references)
				//IL_004b: Expected O, but got Unknown
				//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b0: Expected O, but got Unknown
				//IL_0118: Unknown result type (might be due to invalid IL or missing references)
				//IL_0122: Expected O, but got Unknown
				//IL_013f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0144: Unknown result type (might be due to invalid IL or missing references)
				//IL_014f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0155: Unknown result type (might be due to invalid IL or missing references)
				//IL_015a: Unknown result type (might be due to invalid IL or missing references)
				//IL_015f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0167: Expected O, but got Unknown
				//IL_0084: Unknown result type (might be due to invalid IL or missing references)
				//IL_008e: Expected O, but got Unknown
				//IL_018f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0199: Expected O, but got Unknown
				//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ed: Expected O, but got Unknown
				int num = <>1__state;
				Main main = <>4__this;
				ZNetPeer localPeer;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					goto IL_005b;
				case 1:
					<>1__state = -1;
					goto IL_005b;
				case 2:
					<>1__state = -1;
					goto IL_005b;
				case 3:
					<>1__state = -1;
					goto IL_00c0;
				case 4:
					<>1__state = -1;
					goto IL_005b;
				case 5:
					<>1__state = -1;
					goto IL_0132;
				case 6:
					{
						<>1__state = -1;
						if (ZNet.instance != null)
						{
							try
							{
								main.Execute(<peers>5__2);
							}
							catch (OperationCanceledException)
							{
								return false;
							}
							catch (Exception ex2)
							{
								main.Logger.LogError((object)ex2);
								return false;
							}
							break;
						}
						<peers>5__2 = null;
						goto IL_005b;
					}
					IL_00c0:
					if (ZDOMan.instance == null || ZNetScene.instance == null || ZNet.World == null)
					{
						<>2__current = (YieldInstruction)new WaitForSeconds(0.2f);
						<>1__state = 3;
						return true;
					}
					if (!main.Initialize())
					{
						<>2__current = (YieldInstruction)new WaitForSeconds(5f);
						<>1__state = 4;
						return true;
					}
					localPeer = null;
					if (!ZNet.instance.IsDedicated())
					{
						goto IL_0132;
					}
					goto IL_0167;
					IL_0132:
					if (Player.m_localPlayer == null)
					{
						<>2__current = (YieldInstruction)new WaitForSeconds(0.2f);
						<>1__state = 5;
						return true;
					}
					localPeer = new ZNetPeer((ISocket)(object)new DummySocket(), true)
					{
						m_uid = ZDOMan.GetSessionID(),
						m_characterID = ((Character)Player.m_localPlayer).GetZDOID(),
						m_server = true
					};
					goto IL_0167;
					IL_005b:
					if (ZNet.instance == null)
					{
						<>2__current = (YieldInstruction)new WaitForSeconds(0.2f);
						<>1__state = 1;
						return true;
					}
					if (!ZNet.instance.IsServer())
					{
						main.Logger.LogWarning((object)"Mod should only be installed on the host");
						<>2__current = (YieldInstruction)new WaitForSeconds(5f);
						<>1__state = 2;
						return true;
					}
					goto IL_00c0;
					IL_0167:
					<peers>5__2 = new PeersEnumerable(localPeer);
					break;
				}
				<>2__current = (YieldInstruction)new WaitForSeconds(1f / main.Config.General.Frequency.Value);
				<>1__state = 6;
				return true;
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		internal const string PluginName = "ServersideQoL";

		internal const string PluginGuid = "argusmagnus.ServersideQoL";

		private ModConfig? _mainConfig;

		private ModConfig? _worldConfig;

		private readonly Stopwatch _watch = new Stopwatch();

		private ulong _executeCounter;

		private uint _unfinishedProcessingInRow;

		private readonly Stack<SectorInfo> _sectorInfoPool = new Stack<SectorInfo>();

		private Dictionary<Vector2i, SectorInfo> _playerSectors = new Dictionary<Vector2i, SectorInfo>();

		private Dictionary<Vector2i, SectorInfo> _playerSectorsOld = new Dictionary<Vector2i, SectorInfo>();

		private readonly List<Processor> _unregister = new List<Processor>();

		private bool _configChanged = true;

		private readonly GameVersion ExpectedGameVersion = GameVersion.ParseGameVersion("0.220.5");

		private const uint ExpectedNetworkVersion = 34u;

		private const uint ExpectedItemDataVersion = 106u;

		private const uint ExpectedWorldVersion = 35u;

		internal const string DummyConfigSection = "Z - Dummy";

		private const string PluginVersion = "1.1.0";

		internal const string PluginInformationalVersion = "1.1.0";

		internal static int PluginGuidHash { get; } = StringExtensionMethods.GetStableHashCode("argusmagnus.ServersideQoL");


		internal static Main Instance { get; private set; } = null;


		internal static Harmony HarmonyInstance { get; } = new Harmony("argusmagnus.ServersideQoL");


		internal ManualLogSource Logger { get; } = Logger.CreateLogSource("ServersideQoL");


		internal ModConfig Config => _worldConfig ?? _mainConfig ?? (_mainConfig = new ModConfig(((BaseUnityPlugin)this).Config));

		public Main()
		{
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			Instance = this;
		}

		private void Awake()
		{
			HarmonyInstance.PatchAll(Assembly.GetExecutingAssembly());
		}

		private void Start()
		{
			((MonoBehaviour)this).StartCoroutine((IEnumerator)CallExecute());
			[IteratorStateMachine(typeof(<<Start>g__CallExecute|35_0>d))]
			IEnumerator<YieldInstruction> CallExecute()
			{
				//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
				return new <<Start>g__CallExecute|35_0>d(0)
				{
					<>4__this = this
				};
			}
		}

		private bool Initialize()
		{
			//IL_0280: Unknown result type (might be due to invalid IL or missing references)
			//IL_0286: Unknown result type (might be due to invalid IL or missing references)
			//IL_0170: Unknown result type (might be due to invalid IL or missing references)
			//IL_017a: Expected O, but got Unknown
			//IL_0175: Unknown result type (might be due to invalid IL or missing references)
			//IL_017f: Expected O, but got Unknown
			//IL_02aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b8: Unknown result type (might be due to invalid IL or missing references)
			if ((object)_mainConfig != null)
			{
				_mainConfig.ConfigFile.SettingChanged -= OnConfigChanged;
			}
			if ((object)_worldConfig != null)
			{
				_worldConfig.ConfigFile.SettingChanged -= OnConfigChanged;
			}
			_worldConfig = null;
			_executeCounter = 0uL;
			if (Config.General.ConfigPerWorld.Value)
			{
				string rootPath = ZNet.World.GetRootPath((FileSource)1);
				rootPath += ".ServersideQoL.cfg";
				if (!File.Exists(rootPath) && File.Exists(((BaseUnityPlugin)this).Config.ConfigFilePath))
				{
					File.Copy(((BaseUnityPlugin)this).Config.ConfigFilePath, rootPath);
				}
				string path = Path.Combine(Path.GetDirectoryName(((BaseUnityPlugin)this).Config.ConfigFilePath), Path.GetFileNameWithoutExtension(((BaseUnityPlugin)this).Config.ConfigFilePath));
				if (Directory.Exists(path))
				{
					string text = Path.Combine(Path.GetDirectoryName(rootPath), Path.GetFileNameWithoutExtension(rootPath));
					Directory.CreateDirectory(text);
					foreach (string item in Directory.EnumerateFiles(path))
					{
						string text2 = Path.Combine(text, Path.GetFileName(item));
						if (!File.Exists(text2))
						{
							File.Copy(item, text2);
						}
					}
				}
				Logger.LogInfo((object)"Using world config file");
				_worldConfig = new ModConfig(new ConfigFile(rootPath, false, new BepInPlugin("argusmagnus.ServersideQoL", "ServersideQoL", "1.1.0")));
			}
			Logger.LogInfo((object)FormattableString.Invariant($"Enabled: {Config.General.Enabled.Value}, DiagnosticLogs: {Config.General.DiagnosticLogs.Value}"));
			if (!Config.General.Enabled.Value)
			{
				return false;
			}
			if (Config.General.DiagnosticLogs.Value)
			{
				ManualLogSource logger = Logger;
				string separator = Environment.NewLine + "  ";
				List<string> list = new List<string>();
				list.Add("Config:");
				list.AddRange(((IEnumerable<KeyValuePair<ConfigDefinition, ConfigEntryBase>>)Config.ConfigFile).Select((KeyValuePair<ConfigDefinition, ConfigEntryBase> x) => FormattableString.Invariant($"[{x.Key.Section}].[{x.Key.Key}] = {x.Value.BoxedValue}")));
				logger.LogInfo((object)string.Join(separator, list.ToArray()));
			}
			bool flag = false;
			bool flag2 = false;
			if (RuntimeInformation.Instance.GameVersion != ExpectedGameVersion)
			{
				Logger.LogWarning((object)FormattableString.Invariant($"Unsupported game version: {RuntimeInformation.Instance.GameVersion}, expected: {ExpectedGameVersion}"));
				flag = true;
				flag2 |= !Config.General.IgnoreGameVersionCheck.Value;
			}
			if (RuntimeInformation.Instance.NetworkVersion != 34)
			{
				Logger.LogWarning((object)FormattableString.Invariant($"Unsupported network version: {RuntimeInformation.Instance.NetworkVersion}, expected: {34u}"));
				flag = true;
				flag2 |= !Config.General.IgnoreNetworkVersionCheck.Value;
			}
			if ((long)RuntimeInformation.Instance.ItemDataVersion != 106)
			{
				Logger.LogWarning((object)FormattableString.Invariant($"Unsupported item data version: {RuntimeInformation.Instance.ItemDataVersion}, expected: {106u}"));
				flag = true;
				flag2 |= !Config.General.IgnoreItemDataVersionCheck.Value;
			}
			if ((long)RuntimeInformation.Instance.WorldVersion != 35)
			{
				Logger.LogWarning((object)FormattableString.Invariant($"Unsupported world version: {RuntimeInformation.Instance.WorldVersion}, expected: {35u}"));
				flag = true;
				flag2 |= !Config.General.IgnoreWorldVersionCheck.Value;
			}
			if (flag)
			{
				if (flag2)
				{
					Logger.LogError((object)"Version checks failed. Mod execution is stopped");
					return false;
				}
				Logger.LogError((object)"Version checks failed, but you chose to ignore the checks (config). Continuing...");
			}
			return true;
		}

		private void OnConfigChanged(object sender, SettingChangedEventArgs e)
		{
			_configChanged = true;
			if (Config.General.DiagnosticLogs.Value || e.ChangedSetting == Config.General.DiagnosticLogs)
			{
				Logger.LogInfo((object)$"Config changed: [{e.ChangedSetting.Definition.Section}].[{e.ChangedSetting.Definition.Key}] = {e.ChangedSetting.BoxedValue}");
			}
			if (e.ChangedSetting == Config.General.DiagnosticLogs && Config.General.DiagnosticLogs.Value)
			{
				ManualLogSource logger = Logger;
				string separator = Environment.NewLine + "  ";
				List<string> list = new List<string>();
				list.Add("Config:");
				list.AddRange(((IEnumerable<KeyValuePair<ConfigDefinition, ConfigEntryBase>>)Config.ConfigFile).Select((KeyValuePair<ConfigDefinition, ConfigEntryBase> x) => FormattableString.Invariant($"[{x.Key.Section}].[{x.Key.Key}] = {x.Value.BoxedValue}")));
				logger.LogInfo((object)string.Join(separator, list.ToArray()));
			}
		}

		private void Execute(PeersEnumerable peers)
		{
			//IL_0110: Unknown result type (might be due to invalid IL or missing references)
			//IL_0115: 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_011c: Unknown result type (might be due to invalid IL or missing references)
			//IL_020d: Unknown result type (might be due to invalid IL or missing references)
			//IL_020f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0138: Unknown result type (might be due to invalid IL or missing references)
			//IL_015a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0247: Unknown result type (might be due to invalid IL or missing references)
			//IL_0239: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_03bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0286: Unknown result type (might be due to invalid IL or missing references)
			//IL_04f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_041f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0463: Unknown result type (might be due to invalid IL or missing references)
			//IL_0430: Unknown result type (might be due to invalid IL or missing references)
			//IL_04bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_05d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_05d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_05dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_070f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0711: Unknown result type (might be due to invalid IL or missing references)
			//IL_061a: Unknown result type (might be due to invalid IL or missing references)
			//IL_061f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0626: Unknown result type (might be due to invalid IL or missing references)
			//IL_062d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0637: Unknown result type (might be due to invalid IL or missing references)
			//IL_063e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0762: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a90: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a98: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b11: Unknown result type (might be due to invalid IL or missing references)
			//IL_086b: Unknown result type (might be due to invalid IL or missing references)
			_executeCounter++;
			if (_configChanged)
			{
				_configChanged = false;
				if (Config.GlobalsKeys.SetGlobalKeysFromConfig.Value)
				{
					ZoneSystem.instance.ResetWorldKeys();
				}
				if (Config.WorldModifiers.SetPresetFromConfig.Value)
				{
					try
					{
						MyTerminal.ExecuteCommand("setworldpreset", FormattableString.Invariant($"{Config.WorldModifiers.Preset.Value}"));
					}
					catch (Exception ex)
					{
						Logger.LogError((object)ex);
					}
				}
				if (Config.WorldModifiers.SetModifiersFromConfig.Value)
				{
					foreach (var (val, val2) in Config.WorldModifiers.Modifiers.Select<KeyValuePair<WorldModifiers, ConfigEntry<WorldModifierOption>>, (WorldModifiers, WorldModifierOption)>((KeyValuePair<WorldModifiers, ConfigEntry<WorldModifierOption>> x) => (x.Key, x.Value.Value)))
					{
						try
						{
							MyTerminal.ExecuteCommand("setworldmodifier", FormattableString.Invariant($"{val}"), FormattableString.Invariant($"{val2}"));
						}
						catch (Exception ex2)
						{
							Logger.LogError((object)ex2);
						}
					}
				}
				if (Config.GlobalsKeys.SetGlobalKeysFromConfig.Value)
				{
					foreach (KeyValuePair<GlobalKeys, ConfigEntryBase> item3 in Config.GlobalsKeys.KeyConfigs.Where<KeyValuePair<GlobalKeys, ConfigEntryBase>>((KeyValuePair<GlobalKeys, ConfigEntryBase> x) => !object.Equals(x.Value.BoxedValue, x.Value.DefaultValue)))
					{
						item3.Deconstruct(out var key, out var value);
						GlobalKeys val3 = key;
						ConfigEntryBase val4 = value;
						object boxedValue = val4.BoxedValue;
						if (boxedValue is bool)
						{
							if ((bool)boxedValue)
							{
								ZoneSystem.instance.SetGlobalKey(val3);
							}
							else
							{
								ZoneSystem.instance.RemoveGlobalKey(val3);
							}
							continue;
						}
						float num;
						try
						{
							num = (float)Convert.ChangeType(val4.BoxedValue, typeof(float));
						}
						catch (Exception ex3)
						{
							Logger.LogError((object)ex3);
							continue;
						}
						ZoneSystem.instance.SetGlobalKey(val3, num);
					}
				}
				foreach (Processor defaultProcessor in Processor.DefaultProcessors)
				{
					defaultProcessor.Initialize(_executeCounter == 1);
				}
				if (_executeCounter == 1)
				{
					Config.ConfigFile.SettingChanged -= OnConfigChanged;
					Config.ConfigFile.SettingChanged += OnConfigChanged;
					return;
				}
				{
					foreach (ExtendedZDO item4 in ZDOMan.instance.GetObjectsByID().Values.Cast<ExtendedZDO>())
					{
						item4.ReregisterAllProcessors();
					}
					return;
				}
			}
			_watch.Restart();
			peers.Update();
			if (peers.Count == 0)
			{
				return;
			}
			Dictionary<Vector2i, SectorInfo> playerSectorsOld = _playerSectorsOld;
			Dictionary<Vector2i, SectorInfo> playerSectors = _playerSectors;
			_playerSectors = playerSectorsOld;
			_playerSectorsOld = playerSectors;
			Vector2i key2 = default(Vector2i);
			foreach (Peer peer in peers)
			{
				Vector2i zone = ZoneSystem.GetZone(peer.m_refPos);
				for (int i = zone.x - Config.General.ZonesAroundPlayers.Value; i <= zone.x + Config.General.ZonesAroundPlayers.Value; i++)
				{
					for (int j = zone.y - Config.General.ZonesAroundPlayers.Value; j <= zone.y + Config.General.ZonesAroundPlayers.Value; j++)
					{
						((Vector2i)(ref key2))..ctor(i, j);
						if (_playerSectorsOld.Remove(key2, out SectorInfo value2))
						{
							_playerSectors.Add(key2, value2);
							value2.InverseWeight = 0;
							value2.Peers.Clear();
							value2.Peers.Add(peer);
							continue;
						}
						if (_playerSectors.TryGetValue(key2, out value2))
						{
							value2.Peers.Add(peer);
							continue;
						}
						if (_sectorInfoPool.TryPop(out value2))
						{
							value2.Peers.Add(peer);
						}
						else
						{
							value2 = new SectorInfo(new List<Peer>(1) { peer }, new List<ZDO>());
						}
						_playerSectors.Add(key2, value2);
					}
				}
			}
			foreach (SectorInfo value3 in _playerSectorsOld.Values)
			{
				value3.InverseWeight = 0;
				value3.Peers.Clear();
				value3.ZDOs.Clear();
				_sectorInfoPool.Push(value3);
			}
			_playerSectorsOld.Clear();
			IEnumerable<KeyValuePair<Vector2i, SectorInfo>> enumerable = _playerSectors.AsEnumerable();
			if (_unfinishedProcessingInRow > 10)
			{
				foreach (Peer peer2 in peers)
				{
					Vector2i zone2 = ZoneSystem.GetZone(peer2.m_refPos);
					foreach (var item5 in _playerSectors.Select<KeyValuePair<Vector2i, SectorInfo>, (Vector2i, SectorInfo)>((KeyValuePair<Vector2i, SectorInfo> x) => (x.Key, x.Value)))
					{
						Vector2i item = item5.Item1;
						SectorInfo item2 = item5.Item2;
						int num2 = item.x - zone2.x;
						int num3 = item.y - zone2.y;
						item2.InverseWeight += num2 * num2 + num3 * num3;
					}
				}
				enumerable = enumerable.OrderBy((KeyValuePair<Vector2i, SectorInfo> x) => x.Value.InverseWeight);
			}
			foreach (Processor defaultProcessor2 in Processor.DefaultProcessors)
			{
				defaultProcessor2.PreProcess(peers);
			}
			int num4 = 0;
			int num5 = 0;
			int num6 = 0;
			foreach (var (val6, sectorInfo2) in enumerable)
			{
				if (_watch.ElapsedMilliseconds >= Config.General.MaxProcessingTime.Value)
				{
					break;
				}
				num4++;
				if ((object)sectorInfo2 != null)
				{
					List<ZDO> zDOs = sectorInfo2.ZDOs;
					if (zDOs != null && zDOs.Count == 0)
					{
						ZDOMan.instance.FindSectorObjects(val6, 0, 0, sectorInfo2.ZDOs, (List<ZDO>)null);
					}
				}
				num6 += sectorInfo2.ZDOs.Count;
				while ((object)sectorInfo2 != null)
				{
					List<ZDO> zDOs = sectorInfo2.ZDOs;
					if (zDOs == null || zDOs.Count <= 0 || _watch.ElapsedMilliseconds >= Config.General.MaxProcessingTime.Value)
					{
						break;
					}
					num5++;
					ExtendedZDO extendedZDO = (ExtendedZDO)(object)sectorInfo2.ZDOs[sectorInfo2.ZDOs.Count - 1];
					sectorInfo2.ZDOs.RemoveAt(sectorInfo2.ZDOs.Count - 1);
					if (!((ZDO)extendedZDO).IsValid() || (object)extendedZDO.PrefabInfo == PrefabInfo.Dummy)
					{
						continue;
					}
					if (extendedZDO.Processors.Count > 1)
					{
						Processor claimedExclusiveBy = null;
						foreach (Processor processor in extendedZDO.Processors)
						{
							if (processor.ClaimExclusive(extendedZDO))
							{
								if (claimedExclusiveBy == null)
								{
									claimedExclusiveBy = processor;
								}
								else if (Config.General.DiagnosticLogs.Value)
								{
									Logger.LogError((object)FormattableString.Invariant($"ZDO {((ZDO)extendedZDO).m_uid} claimed exclusive by {processor.GetType().Name} while already claimed by {claimedExclusiveBy.GetType().Name}"));
								}
							}
						}
						if (claimedExclusiveBy != null)
						{
							extendedZDO.UnregisterProcessors(extendedZDO.Processors.Where((Processor x) => x != claimedExclusiveBy));
						}
					}
					bool flag = false;
					bool flag2 = false;
					_unregister.Clear();
					foreach (Processor processor2 in extendedZDO.Processors)
					{
						processor2.Process(extendedZDO, sectorInfo2.Peers);
						if (processor2.UnregisterZdoProcessor)
						{
							_unregister.Add(processor2);
						}
						if (flag = processor2.DestroyZdo)
						{
							extendedZDO.Destroy();
							break;
						}
						flag2 = flag2 || processor2.RecreateZdo;
					}
					if (!flag && flag2)
					{
						extendedZDO.Recreate();
					}
					else if (!flag && _unregister.Count > 0)
					{
						extendedZDO.UnregisterProcessors(_unregister);
					}
				}
			}
			foreach (Processor defaultProcessor3 in Processor.DefaultProcessors)
			{
				defaultProcessor3.PostProcess();
			}
			if (num4 < _playerSectors.Count || num5 < num6)
			{
				_unfinishedProcessingInRow++;
			}
			else
			{
				_unfinishedProcessingInRow = 0u;
			}
			_watch.Stop();
			if (Config.General.DiagnosticLogs.Value)
			{
				LogLevel val7 = (LogLevel)((_unfinishedProcessingInRow == 0) ? 32 : 16);
				Logger.Log(val7, (object)FormattableString.Invariant(FormattableStringFactory.Create("{0} took {1} ms to process {2} of {3} ZDOs in {4} of {5} zones. Incomplete runs in row: {6}", "Execute", _watch.ElapsedMilliseconds, num5, num6, num4, _playerSectors.Count, _unfinishedProcessingInRow)));
				Logger.Log(val7, (object)FormattableString.Invariant(FormattableStringFactory.Create("Processing Time: {0}", string.Join(", ", from x in Processor.DefaultProcessors
					where x.ProcessingTime.Ticks > 0
					orderby x.ProcessingTime.Ticks descending
					select FormattableString.Invariant($"{x.GetType().Name}: {x.ProcessingTime.TotalMilliseconds}ms")))));
			}
		}
	}
	public enum MessageTypes
	{
		None,
		TopLeftNear,
		TopLeftFar,
		CenterNear,
		CenterFar,
		InWorld
	}
	internal sealed record ModConfig(ConfigFile ConfigFile)
	{
		public sealed class GeneralConfig
		{
			public ConfigEntry<bool> Enabled { get; } = cfg.Bind<bool>(section, "Enabled", true, "Enables/disables the entire mode");


			public ConfigEntry<bool> ConfigPerWorld { get; } = cfg.Bind<bool>(section, "ConfigPerWorld", false, "Use one config file per world. The file is saved next to the world file");


			public ConfigEntry<bool> InWorldConfigRoom { get; } = cfg.Bind<bool>(section, "InWorldConfigRoom", false, "True to generate an in-world room which admins can enter to configure this mod by editing signs. A portal is placed at the start location");


			public ConfigEntry<float> FarMessageRange { get; } = cfg.Bind<float>(section, "FarMessageRange", 64f, $"Max distance a player can have to a modified object to receive messages of type {MessageTypes.TopLeftFar} or {MessageTypes.CenterFar}");


			public ConfigEntry<bool> DiagnosticLogs { get; } = cfg.Bind<bool>(section, "DiagnosticLogs", false, "Enables/disables diagnostic logs");


			public ConfigEntry<float> Frequency { get; } = cfg.Bind<float>(section, "Frequency", 5f, new ConfigDescription("How many times per second the mod processes the world", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, float.PositiveInfinity), Array.Empty<object>()));


			public ConfigEntry<int> MaxProcessingTime { get; } = cfg.Bind<int>(section, "MaxProcessingTime", 20, "Max processing time (in ms) per update");


			public ConfigEntry<int> ZonesAroundPlayers { get; } = cfg.Bind<int>(section, "ZonesAroundPlayers", 1, "Zones to process around each player");


			public ConfigEntry<float> MinPlayerDistance { get; } = cfg.Bind<float>(section, "MinPlayerDistance", 4f, "Min distance all players must have to a ZDO for it to be modified");


			public ConfigEntry<bool> IgnoreGameVersionCheck { get; } = cfg.Bind<bool>(section, "IgnoreGameVersionCheck", true, "True to ignore the game version check. Turning this off may lead to the mod being run in an untested version and may lead to data loss/world corruption");


			public ConfigEntry<bool> IgnoreNetworkVersionCheck { get; } = cfg.Bind<bool>(section, "IgnoreNetworkVersionCheck", false, "True to ignore the network version check. Turning this off may lead to the mod being run in an untested version and may lead to data loss/world corruption");


			public ConfigEntry<bool> IgnoreItemDataVersionCheck { get; } = cfg.Bind<bool>(section, "IgnoreItemDataVersionCheck", false, "True to ignore the item data version check. Turning this off may lead to the mod being run in an untested version and may lead to data loss/world corruption");


			public ConfigEntry<bool> IgnoreWorldVersionCheck { get; } = cfg.Bind<bool>(section, "IgnoreWorldVersionCheck", false, "True to ignore the world version check. Turning this off may lead to the mod being run in an untested version and may lead to data loss/world corruption");


			public GeneralConfig(ConfigFile cfg, string section)
			{
			}//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Expected O, but got Unknown

		}

		public sealed class SignsConfig
		{
			public ConfigEntry<string> DefaultColor { get; } = cfg.Bind<string>(section, "DefaultColor", "", "Default color for signs. Can be a color name or hex code (e.g. #FF0000 for red)");


			public ConfigEntry<bool> TimeSigns { get; } = cfg.Bind<bool>(section, "TimeSigns", false, FormattableString.Invariant($"True to update sign texts which contain time emojis (any of {string.Concat(SignProcessor.ClockEmojis)}) with the in-game time"));


			public SignsConfig(ConfigFile cfg, string section)
			{
			}
		}

		public sealed class MapTableConfig
		{
			public ConfigEntry<bool> AutoUpdatePortals { get; } = cfg.Bind<bool>(section, "AutoUpdatePortals", false, "True to update map tables with portal pins");


			public ConfigEntry<string> AutoUpdatePortalsExclude { get; } = cfg.Bind<string>(section, "AutoUpdatePortalsExclude", "", "Portals with a tag that matches this filter are not added to map tables");


			public ConfigEntry<string> AutoUpdatePortalsInclude { get; } = cfg.Bind<string>(section, "AutoUpdatePortalsInclude", "*", "Only portals with a tag that matches this filter are added to map tables");


			public ConfigEntry<bool> AutoUpdateShips { get; } = cfg.Bind<bool>(section, "AutoUpdateShips", false, "True to update map tables with ship pins");


			public ConfigEntry<MessageTypes> UpdatedMessageType { get; } = cfg.Bind<MessageTypes>(section, "UpdatedMessageType", MessageTypes.None, new ConfigDescription("Type of message to show when a map table is updated", (AcceptableValueBase)(object)AcceptableEnum<MessageTypes>.Default, Array.Empty<object>()));


			public MapTableConfig(ConfigFile cfg, string section)
			{
			}//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Expected O, but got Unknown

		}

		public sealed class TamesConfig
		{
			public ConfigEntry<bool> MakeCommandable { get; } = cfg.Bind<bool>(section, "MakeCommandable", false, "True to make all tames commandable (like wolves)");


			public ConfigEntry<MessageTypes> TamingProgressMessageType { get; } = cfg.Bind<MessageTypes>(section, "TamingProgressMessageType", MessageTypes.None, new ConfigDescription("Type of taming progress messages to show", (AcceptableValueBase)(object)AcceptableEnum<MessageTypes>.Default, Array.Empty<object>()));


			public ConfigEntry<MessageTypes> GrowingProgressMessageType { get; } = cfg.Bind<MessageTypes>(section, "GrowingProgressMessageType", MessageTypes.None, new ConfigDescription("Type of growing progress messages to show", (AcceptableValueBase)(object)AcceptableEnum<MessageTypes>.Default, Array.Empty<object>()));


			public ConfigEntry<bool> AlwaysFed { get; } = cfg.Bind<bool>(section, "AlwaysFed", false, "True to make tames always fed (not hungry)");


			public ConfigEntry<bool> TeleportFollow { get; } = cfg.Bind<bool>(section, "TeleportFollow", false, "True to teleport following tames to the players location if the player gets too far away from them");


			public ConfigEntry<bool> TakeIntoDungeons { get; } = cfg.Bind<bool>(section, "TakeIntoDungeons", false, "True to take following tames into (and out of) dungeons with you");


			public TamesConfig(ConfigFile cfg, string section)
			{
			}//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Expected O, but got Unknown
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Expected O, but got Unknown

		}

		public sealed class CreaturesConfig
		{
			[Flags]
			public enum ShowHigherLevelAuraOptions
			{
				Never = 0,
				Wild = 1,
				Tamed = 2
			}

			public ConfigEntry<bool> ShowHigherLevelStars { get; } = cfg.Bind<bool>(section, "ShowHigherLevelStars", false, "True to show stars for higher level creatures (> 2 stars). The intended use is with other mods, which spawn higher level creatures");


			public ConfigEntry<ShowHigherLevelAuraOptions> ShowHigherLevelAura { get; } = cfg.Bind<ShowHigherLevelAuraOptions>(section, "ShowHigherLevelAura", ShowHigherLevelAuraOptions.Never, new ConfigDescription("Show an aura for higher level creatures (> 2 stars)", (AcceptableValueBase)(object)AcceptableEnum<ShowHigherLevelAuraOptions>.Default, Array.Empty<object>()));


			public CreaturesConfig(ConfigFile cfg, string section)
			{
			}//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Expected O, but got Unknown

		}

		public sealed class FireplacesConfig
		{
			public enum IgnoreRainOptions
			{
				Never,
				Always,
				InsideShield
			}

			public ConfigEntry<bool> MakeToggleable { get; } = cfg.Bind<bool>(section, "MakeToggleable", false, "True to make all fireplaces (including torches, braziers, etc.) toggleable");


			public ConfigEntry<bool> InfiniteFuel { get; } = cfg.Bind<bool>(section, "InfiniteFuel", false, "True to make all fireplaces have infinite fuel");


			public ConfigEntry<IgnoreRainOptions> IgnoreRain { get; } = cfg.Bind<IgnoreRainOptions>(section, "IgnoreRain", IgnoreRainOptions.Never, new ConfigDescription("Options to make all fireplaces ignore rain", (AcceptableValueBase)(object)AcceptableEnum<IgnoreRainOptions>.Default, Array.Empty<object>()));


			public FireplacesConfig(ConfigFile cfg, string section)
			{
			}//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Expected O, but got Unknown

		}

		public sealed class ContainersConfig
		{
			public enum ObliteratorItemTeleporterOptions
			{
				Disabled = 0,
				Enabled = 1,
				EnabledAllItems = 2,
				[Obsolete]
				False = 0,
				[Obsolete]
				True = 1
			}

			[Flags]
			public enum SignOptions
			{
				None = 0,
				Left = 1,
				Right = 2,
				Front = 4,
				Back = 8,
				TopLongitudinal = 0x10,
				TopLateral = 0x20
			}

			private const string ChestSignItemNamesFileName = "ChestSignItemNames.yml";

			private const string DefaultPlaceholderString = "•";

			public ConfigEntry<bool> AutoSort { get; }

			public ConfigEntry<MessageTypes> SortedMessageType { get; }

			public ConfigEntry<bool> AutoPickup { get; }

			public ConfigEntry<float> AutoPickupRange { get; }

			public ConfigEntry<int> AutoPickupMaxRange { get; }

			public ConfigEntry<float> AutoPickupMinPlayerDistance { get; }

			public ConfigEntry<bool> AutoPickupExcludeFodder { get; }

			public ConfigEntry<bool> AutoPickupRequestOwnership { get; }

			public ConfigEntry<MessageTypes> PickedUpMessageType { get; }

			public ConfigEntry<string> ChestSignsDefaultText { get; }

			public ConfigEntry<int> ChestSignsContentListMaxCount { get; }

			public ConfigEntry<string> ChestSignsContentListPlaceholder { get; }

			public ConfigEntry<string> ChestSignsContentListSeparator { get; }

			public ConfigEntry<string> ChestSignsContentListNameRest { get; }

			public ConfigEntry<string> ChestSignsContentListEntryFormat { get; }

			public ConfigEntry<SignOptions> WoodChestSigns { get; }

			public ConfigEntry<SignOptions> ReinforcedChestSigns { get; }

			public ConfigEntry<SignOptions> BlackmetalChestSigns { get; }

			public ConfigEntry<SignOptions> ObliteratorSigns { get; }

			public ConfigEntry<ObliteratorItemTeleporterOptions> ObliteratorItemTeleporter { get; }

			public ConfigEntry<MessageTypes> ObliteratorItemTeleporterMessageType { get; }

			public IReadOnlyDictionary<int, ConfigEntry<string>> ContainerSizes { get; }

			public IReadOnlyDictionary<string, string> ItemNames { get; }

			public ContainersConfig(ConfigFile cfg, string section)
			{
				//IL_0058: Unknown result type (might be due to invalid IL or missing references)
				//IL_0062: Expected O, but got Unknown
				//IL_015e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0168: Expected O, but got Unknown
				//IL_0264: Unknown result type (might be due to invalid IL or missing references)
				//IL_026e: Expected O, but got Unknown
				//IL_0295: Unknown result type (might be due to invalid IL or missing references)
				//IL_029f: Expected O, but got Unknown
				//IL_02c6: Unknown result type (might be due to invalid IL or missing references)
				//IL_02d0: Expected O, but got Unknown
				//IL_02f7: Unknown result type (might be due to invalid IL or missing references)
				//IL_0301: Expected O, but got Unknown
				//IL_032e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0338: Expected O, but got Unknown
				//IL_035f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0369: Expected O, but got Unknown
				//IL_0390: Unknown result type (might be due to invalid IL or missing references)
				//IL_039a: Expected O, but got Unknown
				ConfigFile cfg2 = cfg;
				string section2 = section;
				AutoSort = cfg2.Bind<bool>(section2, "AutoSort", false, "True to auto sort container inventories");
				SortedMessageType = cfg2.Bind<MessageTypes>(section2, "SortedMessageType", MessageTypes.None, new ConfigDescription("Type of message to show when a container was sorted", (AcceptableValueBase)(object)AcceptableEnum<MessageTypes>.Default, Array.Empty<object>()));
				AutoPickup = cfg2.Bind<bool>(section2, "AutoPickup", false, "True to automatically put dropped items into containers if they already contain said item");
				AutoPickupRange = cfg2.Bind<float>(section2, "AutoPickupRange", 64f, "Required proximity of a container to a dropped item to be considered as auto pickup target. Can be overriden per chest by putting '\ud83e\uddf2<Range>' on a chest sign");
				AutoPickupMaxRange = cfg2.Bind<int>(section2, "AutoPickupMaxRange", 64, "Max auto pickup range players can set per chest (by putting '\ud83e\uddf2<Range>' on a chest sign)");
				AutoPickupMinPlayerDistance = cfg2.Bind<float>(section2, "AutoPickupMinPlayerDistance", 4f, "Min distance all player must have to a dropped item for it to be picked up");
				AutoPickupExcludeFodder = cfg2.Bind<bool>(section2, "AutoPickupExcludeFodder", true, "True to exclude food items for tames when tames are within search range");
				AutoPickupRequestOwnership = cfg2.Bind<bool>(section2, "AutoPickupRequestOwnership", true, "True to make the server request (and receive) ownership of dropped items from the clients before they are picked up. This will reduce the risk of data conflicts (e.g. item duplication) but will drastically decrease performance");
				PickedUpMessageType = cfg2.Bind<MessageTypes>(section2, "PickedUpMessageType", MessageTypes.None, new ConfigDescription("Type of message to show when a dropped item is added to a container", (AcceptableValueBase)(object)AcceptableEnum<MessageTypes>.Default, Array.Empty<object>()));
				ChestSignsDefaultText = cfg2.Bind<string>(section2, "ChestSignsDefaultText", "•", "Default text for chest signs");
				ChestSignsContentListMaxCount = cfg2.Bind<int>(section2, "ChestSignsContentListMaxCount", 3, "Max number of entries to show in the content list on chest signs.");
				ChestSignsContentListPlaceholder = cfg2.Bind<string>(section2, "ChestSignsContentListPlaceholder", "•", "Bullet to use for content lists on chest signs");
				ChestSignsContentListSeparator = cfg2.Bind<string>(section2, "ChestSignsContentListSeparator", "<br>", "Separator to use for content lists on chest signs");
				ChestSignsContentListNameRest = cfg2.Bind<string>(section2, "ChestSignsContentListNameRest", "Other", "Text to show for the entry summarizing the rest of the items");
				ChestSignsContentListEntryFormat = cfg2.Bind<string>(section2, "ChestSignsContentListEntryFormat", "{0} {1}", new ConfigDescription("Format string for entries in the content list, the first argument is the name of the item, the second is the total number of per item. The item names can be configured further by editing ChestSignItemNames.yml", (AcceptableValueBase)(object)new AcceptableFormatString(new object[2] { "Test", 0 }), Array.Empty<object>()));
				WoodChestSigns = cfg2.Bind<SignOptions>(section2, "WoodChestSigns", SignOptions.None, new ConfigDescription("Options to automatically put signs on wood chests", (AcceptableValueBase)(object)AcceptableEnum<SignOptions>.Default, Array.Empty<object>()));
				ReinforcedChestSigns = cfg2.Bind<SignOptions>(section2, "ReinforcedChestSigns", SignOptions.None, new ConfigDescription("Options to automatically put signs on reinforced chests", (AcceptableValueBase)(object)AcceptableEnum<SignOptions>.Default, Array.Empty<object>()));
				BlackmetalChestSigns = cfg2.Bind<SignOptions>(section2, "BlackmetalChestSigns", SignOptions.None, new ConfigD