using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Linq.Expressions;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using BepInEx;
using BepInEx.Configuration;
using Microsoft.CodeAnalysis;
using ServersideQoL.Processors;
using ServersideQoL.Utilities;
using UnityEngine;

[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("ArgusMagnus")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyCopyright("ArgusMagnus")]
[assembly: AssemblyDescription("Configure some apsects around the player (e.g. infinite stamina for various activities, methods to permanently unlock item effects such as increased carry weight)")]
[assembly: AssemblyFileVersion("2.4.3.0")]
[assembly: AssemblyInformationalVersion("2.4.3+f0835f4ca84c6b51687177e6c1c8a8ebc98bae7c")]
[assembly: AssemblyProduct("ServersideQoL.Player")]
[assembly: AssemblyTitle("ServersideQoL.Player")]
[assembly: AssemblyMetadata("RepositoryUrl", "https://github.com/ArgusMagnus/ValheimServersideQoL")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("2.4.3.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
[CompilerGenerated]
internal sealed class <>z__ReadOnlyList<T> : IEnumerable, ICollection, IList, IEnumerable<T>, IReadOnlyCollection<T>, IReadOnlyList<T>, ICollection<T>, IList<T>
{
	int ICollection.Count => _items.Count;

	bool ICollection.IsSynchronized => false;

	object ICollection.SyncRoot => this;

	object IList.this[int index]
	{
		get
		{
			return _items[index];
		}
		set
		{
			throw new NotSupportedException();
		}
	}

	bool IList.IsFixedSize => true;

	bool IList.IsReadOnly => true;

	int IReadOnlyCollection<T>.Count => _items.Count;

	T IReadOnlyList<T>.this[int index] => _items[index];

	int ICollection<T>.Count => _items.Count;

	bool ICollection<T>.IsReadOnly => true;

	T IList<T>.this[int index]
	{
		get
		{
			return _items[index];
		}
		set
		{
			throw new NotSupportedException();
		}
	}

	public <>z__ReadOnlyList(List<T> items)
	{
		_items = items;
	}

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

	void ICollection.CopyTo(Array array, int index)
	{
		((ICollection)_items).CopyTo(array, index);
	}

	int IList.Add(object value)
	{
		throw new NotSupportedException();
	}

	void IList.Clear()
	{
		throw new NotSupportedException();
	}

	bool IList.Contains(object value)
	{
		return ((IList)_items).Contains(value);
	}

	int IList.IndexOf(object value)
	{
		return ((IList)_items).IndexOf(value);
	}

	void IList.Insert(int index, object value)
	{
		throw new NotSupportedException();
	}

	void IList.Remove(object value)
	{
		throw new NotSupportedException();
	}

	void IList.RemoveAt(int index)
	{
		throw new NotSupportedException();
	}

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

	void ICollection<T>.Add(T item)
	{
		throw new NotSupportedException();
	}

	void ICollection<T>.Clear()
	{
		throw new NotSupportedException();
	}

	bool ICollection<T>.Contains(T item)
	{
		return _items.Contains(item);
	}

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

	bool ICollection<T>.Remove(T item)
	{
		throw new NotSupportedException();
	}

	int IList<T>.IndexOf(T item)
	{
		return _items.IndexOf(item);
	}

	void IList<T>.Insert(int index, T item)
	{
		throw new NotSupportedException();
	}

	void IList<T>.RemoveAt(int index)
	{
		throw new NotSupportedException();
	}
}
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

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

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

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

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace ServersideQoL.Player
{
	public sealed class Config : ConfigBase<Config>
	{
		public sealed class LocalizationConfig
		{
			public string SacrificedMegingjord { get; init; } = "You were permanently granted increased carrying weight";

			public string SacrificedCryptKey { get; init; } = "You were permanently granted the ability to open sunken crypt doors";

			public string SacrificedWishbone { get; init; } = "You were permanently granted the ability to sense hidden objects";

			public string SacrificedTornSpirit { get; init; } = "You were permanently granted a wisp companion";
		}

		public override ConfigEntry<bool> Enabled { get; } = ConfigBase<Config>.BindEx<bool>(cfg, true, "Enables/disables the entire mod", (IAcceptableValueBase<bool>)null, (Deprecated<Config>)null, "Enabled");

		public ConfigEntry<bool> InfiniteBuildingStamina { get; } = ConfigBase<Config>.BindEx<bool>(cfg, false, GetInfiniteXDescription("building"), (IAcceptableValueBase<bool>)null, (Deprecated<Config>)null, "InfiniteBuildingStamina");

		public ConfigEntry<bool> InfiniteFarmingStamina { get; } = ConfigBase<Config>.BindEx<bool>(cfg, false, GetInfiniteXDescription("farming"), (IAcceptableValueBase<bool>)null, (Deprecated<Config>)null, "InfiniteFarmingStamina");

		public ConfigEntry<bool> InfiniteMiningStamina { get; } = ConfigBase<Config>.BindEx<bool>(cfg, false, GetInfiniteXDescription("mining"), (IAcceptableValueBase<bool>)null, (Deprecated<Config>)null, "InfiniteMiningStamina");

		public ConfigEntry<bool> InfiniteWoodCuttingStamina { get; } = ConfigBase<Config>.BindEx<bool>(cfg, false, GetInfiniteXDescription("cutting wood"), (IAcceptableValueBase<bool>)null, (Deprecated<Config>)null, "InfiniteWoodCuttingStamina");

		public ConfigEntry<bool> InfiniteEncumberedStamina { get; } = ConfigBase<Config>.BindEx<bool>(cfg, false, GetInfiniteXDescription("encumbered"), (IAcceptableValueBase<bool>)null, (Deprecated<Config>)null, "InfiniteEncumberedStamina");

		public ConfigEntry<bool> InfiniteSneakingStamina { get; } = ConfigBase<Config>.BindEx<bool>(cfg, false, GetInfiniteXDescription("sneaking"), (IAcceptableValueBase<bool>)null, (Deprecated<Config>)null, "InfiniteSneakingStamina");

		public ConfigEntry<bool> InfiniteSwimmingStamina { get; } = ConfigBase<Config>.BindEx<bool>(cfg, false, GetInfiniteXDescription("swimming"), (IAcceptableValueBase<bool>)null, (Deprecated<Config>)null, "InfiniteSwimmingStamina");

		public ConfigEntry<Emotes> OpenCartEmote { get; }

		public ConfigEntry<bool> CanSacrificeMegingjord { get; }

		public ConfigEntry<bool> CanSacrificeCryptKey { get; }

		public ConfigEntry<bool> CanSacrificeWishbone { get; }

		public ConfigEntry<bool> CanSacrificeTornSpirit { get; }

		public YamlConfigEntry<LocalizationConfig> Localization { get; }

		public Config(ConfigFile cfg, Logger logger)
		{
			string text = $"Emote to open the inventory of an attached cart.\r\n{(object)(Emotes)(-1)} to disable this feature, {(object)(Emotes)(-2)} to use any emote as trigger.\r\nYou can bind emotes to buttons with chat commands.\r\nFor example, on xbox you can bind the Y-Button to the wave-emote by entering \"/bind JoystickButton3 {(object)(Emotes)0}\" in the in-game chat.\r\nIf you use emotes exclusively for this feature, it is recommended to set the value to {(object)(Emotes)(-2)} as it is more reliably detected than specific emotes, especially on bad connection/with crossplay.";
			List<Emotes> list = new List<Emotes>();
			list.Add((Emotes)(-1));
			list.Add((Emotes)(-2));
			list.AddRange(Enum.GetValues(typeof(Emotes)).Cast<Emotes>());
			OpenCartEmote = ConfigBase<Config>.BindEx<Emotes>(cfg, (Emotes)(-1), text, (IAcceptableValueBase<Emotes>)(object)new AcceptableEnum<Emotes>((IEnumerable<Emotes>)new <>z__ReadOnlyList<Emotes>(list)), (Deprecated<Config>)null, "OpenCartEmote");
			CanSacrificeMegingjord = ConfigBase<Config>.BindEx<bool>(cfg, false, "If true, players can permanently unlock increased carrying weight by sacrificing a megingjord in an obliterator", (IAcceptableValueBase<bool>)null, (Deprecated<Config>)null, "CanSacrificeMegingjord");
			CanSacrificeCryptKey = ConfigBase<Config>.BindEx<bool>(cfg, false, "If true, players can permanently unlock the ability to open sunken crypt doors by sacrificing a crypt key in an obliterator", (IAcceptableValueBase<bool>)null, (Deprecated<Config>)null, "CanSacrificeCryptKey");
			CanSacrificeWishbone = ConfigBase<Config>.BindEx<bool>(cfg, false, "If true, players can permanently unlock the ability to sense hidden objects by sacrificing a wishbone in an obliterator", (IAcceptableValueBase<bool>)null, (Deprecated<Config>)null, "CanSacrificeWishbone");
			CanSacrificeTornSpirit = ConfigBase<Config>.BindEx<bool>(cfg, false, "If true, players can permanently unlock a wisp companion by sacrificing a torn spirit in an obliterator.\r\nWARNING: Wisp companion cannot be unsummoned and will stay as long as this setting is enabled.", (IAcceptableValueBase<bool>)null, (Deprecated<Config>)null, "CanSacrificeTornSpirit");
			Localization = ConfigBase<Config>.BindYaml<LocalizationConfig>(cfg, "Localization");
			base..ctor(cfg, logger);
		}

		private static string GetInfiniteXDescription(string action)
		{
			return FormattableString.Invariant(FormattableStringFactory.Create("True to give players infinite stamina when {0}.\r\nPlayer stamina will still be drained, but when nearly depleted, just enough stamina will be restored to continue indefinitely.\r\nIf you want infinite stamina in general, set the global key '{1}' to 0.", action, "StaminaRate"));
		}
	}
	[Processor("28b93edf-6ede-4dbe-92ed-99275be3915f")]
	public sealed class CryptDoorProcessor : Processor<CryptDoorProcessor.PrefabInfo>
	{
		public sealed record PrefabInfo(Door Door) : ProcessorPrefabInfo()
		{
			[CompilerGenerated]
			public override string ToString()
			{
				StringBuilder stringBuilder = new StringBuilder();
				stringBuilder.Append("PrefabInfo");
				stringBuilder.Append(" { ");
				if (((ProcessorPrefabInfo)this).PrintMembers(stringBuilder))
				{
					stringBuilder.Append(' ');
				}
				stringBuilder.Append('}');
				return stringBuilder.ToString();
			}

			[CompilerGenerated]
			protected override bool PrintMembers(StringBuilder builder)
			{
				if (((ProcessorPrefabInfo)this).PrintMembers(builder))
				{
					builder.Append(", ");
				}
				builder.Append("Door = ");
				builder.Append(Door);
				return true;
			}

			[CompilerGenerated]
			public override int GetHashCode()
			{
				return ((ProcessorPrefabInfo)this).GetHashCode() * -1521134295 + EqualityComparer<Door>.Default.GetHashCode(Door);
			}

			[CompilerGenerated]
			public sealed override bool Equals(ProcessorPrefabInfo? other)
			{
				return ((object)this).Equals((object?)other);
			}

			[CompilerGenerated]
			public bool Equals(PrefabInfo? other)
			{
				if ((object)this != other)
				{
					if (((ProcessorPrefabInfo)this).Equals((ProcessorPrefabInfo)(object)other))
					{
						return EqualityComparer<Door>.Default.Equals(Door, other.Door);
					}
					return false;
				}
				return true;
			}

			[CompilerGenerated]
			private PrefabInfo(PrefabInfo original)
				: base((ProcessorPrefabInfo)(object)original)
			{
				Door = original.Door;
			}
		}

		private readonly List<ServersideQoLZDO> _allowedPlayers = new List<ServersideQoLZDO>();

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

		protected override void Initialize()
		{
			_allowedPlayers.Clear();
			_keyItemWeightByHash.Clear();
		}

		protected override ProcessResult Process(ServersideQoLZDO zdo, IReadOnlyList<Peer> peers, PrefabInfo prefabInfo)
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_029a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0169: Unknown result type (might be due to invalid IL or missing references)
			//IL_016e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_018a: Unknown result type (might be due to invalid IL or missing references)
			//IL_018f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0192: Unknown result type (might be due to invalid IL or missing references)
			ItemDrop keyItem = prefabInfo.Door.m_keyItem;
			if (keyItem != null && ((Object)keyItem).name == "CryptKey")
			{
				ZDOVars vars = zdo.Vars;
				if (((ZDOVars)(ref vars)).GetState(0) == 0)
				{
					ComponentFieldAccessor<Door> val = zdo.Fields<Door>();
					if (!ConfigBase<Config>.Instance.CanSacrificeCryptKey.Value)
					{
						val.Reset((Func<Expression<Func<Door, ItemDrop>>>)(() => (Door x) => x.m_keyItem), "C:\\repos\\Valheim.ServersideQoL\\ServersideQoL.Player\\CryptDoorProcessor.cs", 30);
						return (ProcessResult)2;
					}
					_allowedPlayers.Clear();
					if (ZoneSystem.instance.GetGlobalKey((GlobalKeys)45))
					{
						foreach (Peer peer in peers)
						{
							if (!(Vector3.Distance(peer.RefPos, zdo.ZDO.GetPosition()) > 16f))
							{
								PlayerState playerState = peer.PlayerState;
								if (playerState != null && PlayerProcessor.GetSacrifiedCryptKey(playerState.PlayerID))
								{
									_allowedPlayers.Add(playerState.ZDO);
								}
							}
						}
					}
					if (_allowedPlayers.Count == 0)
					{
						if (val.UpdateResetValue((Func<Expression<Func<Door, ItemDrop>>>)(() => (Door x) => x.m_keyItem), "C:\\repos\\Valheim.ServersideQoL\\ServersideQoL.Player\\CryptDoorProcessor.cs", 48))
						{
							return (ProcessResult)8;
						}
					}
					else
					{
						int num = 0;
						int num2 = 0;
						_keyItemWeightByHash.Clear();
						foreach (EquipmemtSlots value2 in SQoLEnumUtils<EquipmemtSlots>.Values)
						{
							foreach (ServersideQoLZDO allowedPlayer in _allowedPlayers)
							{
								vars = allowedPlayer.Vars;
								int equippedItemHash = ((ZDOVars)(ref vars)).GetEquippedItemHash(value2, 0);
								if (equippedItemHash != 0)
								{
									int value = ((!_keyItemWeightByHash.TryGetValue(equippedItemHash, out value)) ? 1 : (value + 1));
									_keyItemWeightByHash[equippedItemHash] = value;
									if (value > num)
									{
										num = value;
										num2 = equippedItemHash;
									}
								}
							}
						}
						_keyItemWeightByHash.Clear();
						_allowedPlayers.Clear();
						if (num2 != 0)
						{
							GameObject itemPrefab = ObjectDB.instance.GetItemPrefab(num2);
							ItemDrop val2 = ((itemPrefab != null) ? itemPrefab.GetComponent<ItemDrop>() : null);
							if (val2 != null)
							{
								if (val.UpdateValue((Func<Expression<Func<Door, ItemDrop>>>)(() => (Door x) => x.m_keyItem), val2, "C:\\repos\\Valheim.ServersideQoL\\ServersideQoL.Player\\CryptDoorProcessor.cs", 80))
								{
									return (ProcessResult)8;
								}
								goto IL_0294;
							}
						}
						((Processor)this).Logger.LogWarning((object)$"Item {num2} was chosen as key, but it's not a valid ItemDrop");
					}
					goto IL_0294;
				}
			}
			return (ProcessResult)2;
			IL_0294:
			return ((Processor)this).ScheduleReprocessing(0.1f);
		}
	}
	[Processor("30cb1ca8-ae2d-4982-af60-f47e0207d603")]
	[RunAfter<ContainerRegistryProcessor>]
	[DependsOn<PlayerRegistryProcessor>]
	public sealed class IncineratorProcessor : Processor<IncineratorProcessor.PrefabInfo>
	{
		public sealed record PrefabInfo(Incinerator Incinerator, Container Container, Piece Piece, PieceTable PieceTable) : ProcessorPrefabInfo()
		{
			[CompilerGenerated]
			public override string ToString()
			{
				StringBuilder stringBuilder = new StringBuilder();
				stringBuilder.Append("PrefabInfo");
				stringBuilder.Append(" { ");
				if (((ProcessorPrefabInfo)this).PrintMembers(stringBuilder))
				{
					stringBuilder.Append(' ');
				}
				stringBuilder.Append('}');
				return stringBuilder.ToString();
			}

			[CompilerGenerated]
			protected override bool PrintMembers(StringBuilder builder)
			{
				if (((ProcessorPrefabInfo)this).PrintMembers(builder))
				{
					builder.Append(", ");
				}
				builder.Append("Incinerator = ");
				builder.Append(Incinerator);
				builder.Append(", Container = ");
				builder.Append(Container);
				builder.Append(", Piece = ");
				builder.Append(Piece);
				builder.Append(", PieceTable = ");
				builder.Append(PieceTable);
				return true;
			}

			[CompilerGenerated]
			public override int GetHashCode()
			{
				return (((((ProcessorPrefabInfo)this).GetHashCode() * -1521134295 + EqualityComparer<Incinerator>.Default.GetHashCode(Incinerator)) * -1521134295 + EqualityComparer<Container>.Default.GetHashCode(Container)) * -1521134295 + EqualityComparer<Piece>.Default.GetHashCode(Piece)) * -1521134295 + EqualityComparer<PieceTable>.Default.GetHashCode(PieceTable);
			}

			[CompilerGenerated]
			public sealed override bool Equals(ProcessorPrefabInfo? other)
			{
				return ((object)this).Equals((object?)other);
			}

			[CompilerGenerated]
			public bool Equals(PrefabInfo? other)
			{
				if ((object)this != other)
				{
					if (((ProcessorPrefabInfo)this).Equals((ProcessorPrefabInfo)(object)other) && EqualityComparer<Incinerator>.Default.Equals(Incinerator, other.Incinerator) && EqualityComparer<Container>.Default.Equals(Container, other.Container) && EqualityComparer<Piece>.Default.Equals(Piece, other.Piece))
					{
						return EqualityComparer<PieceTable>.Default.Equals(PieceTable, other.PieceTable);
					}
					return false;
				}
				return true;
			}

			[CompilerGenerated]
			private PrefabInfo(PrefabInfo original)
				: base((ProcessorPrefabInfo)(object)original)
			{
				Incinerator = original.Incinerator;
				Container = original.Container;
				Piece = original.Piece;
				PieceTable = original.PieceTable;
			}
		}

		private sealed record SacrificeInfo(Action<PlayerID> SetSacrificed, int? StatusEffect, string Message)
		{
			public string? ItemName { get; set; }
		}

		private sealed class State
		{
			public PlayerState? RequestingPlayer { get; set; }

			public required uint Revision { get; set; }

			public HashSet<SacrificeInfo> Sacrifices { get; } = new HashSet<SacrificeInfo>();

			public bool LeverPulled { get; set; }

			public bool LeverReturned { get; set; }

			public ServersideQoLZDO? Sign { get; set; }
		}

		public const string Id = "30cb1ca8-ae2d-4982-af60-f47e0207d603";

		private readonly Dictionary<string, SacrificeInfo> _sacrifices = new Dictionary<string, SacrificeInfo>();

		private readonly Dictionary<ServersideQoLZDO, State> _states = new Dictionary<ServersideQoLZDO, State>();

		private bool _enabled;

		protected override void Initialize()
		{
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: 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)
			_enabled = ConfigBase<Config>.Instance.CanSacrificeMegingjord.Value || ConfigBase<Config>.Instance.CanSacrificeCryptKey.Value || ConfigBase<Config>.Instance.CanSacrificeWishbone.Value || ConfigBase<Config>.Instance.CanSacrificeTornSpirit.Value;
			Intercept.UpdateInterception(Incinerator.RequestIncinerate, (Delegate)new Action<ServersideQoLZDO, RoutedRPCData, PlayerID>(RPC_RequestIncinerate), _enabled);
			Intercept.UpdateInterception(Incinerator.AnimateLever, (Delegate)new Action<ServersideQoLZDO>(RPC_AnimateLever), _enabled);
			Intercept.UpdateInterception(Incinerator.AnimateLeverReturn, (Delegate)new Action<ServersideQoLZDO>(RPC_AnimateLeverReturn), _enabled);
			_sacrifices.Clear();
			if (ConfigBase<Config>.Instance.CanSacrificeMegingjord.Value)
			{
				_sacrifices.Add("BeltStrength", new SacrificeInfo(delegate(PlayerID x)
				{
					//IL_0000: Unknown result type (might be due to invalid IL or missing references)
					PlayerProcessor.SetSacrifiedMegingjord(x, value: true);
				}, StatusEffects.Megingjord, ConfigBase<Config>.Instance.Localization.Value.SacrificedMegingjord));
			}
			if (ConfigBase<Config>.Instance.CanSacrificeCryptKey.Value)
			{
				_sacrifices.Add("CryptKey", new SacrificeInfo(delegate(PlayerID x)
				{
					//IL_0000: Unknown result type (might be due to invalid IL or missing references)
					PlayerProcessor.SetSacrifiedCryptKey(x, value: true);
				}, null, ConfigBase<Config>.Instance.Localization.Value.SacrificedCryptKey));
			}
			if (ConfigBase<Config>.Instance.CanSacrificeWishbone.Value)
			{
				_sacrifices.Add("Wishbone", new SacrificeInfo(delegate(PlayerID x)
				{
					//IL_0000: Unknown result type (might be due to invalid IL or missing references)
					PlayerProcessor.SetSacrifiedWishbone(x, value: true);
				}, StatusEffects.Wishbone, ConfigBase<Config>.Instance.Localization.Value.SacrificedWishbone));
			}
			if (ConfigBase<Config>.Instance.CanSacrificeTornSpirit.Value)
			{
				_sacrifices.Add("YagluthDrop", new SacrificeInfo(delegate(PlayerID x)
				{
					//IL_0000: Unknown result type (might be due to invalid IL or missing references)
					PlayerProcessor.SetSacrifiedTornSpirit(x, value: true);
				}, StatusEffects.Demister, ConfigBase<Config>.Instance.Localization.Value.SacrificedTornSpirit));
			}
		}

		protected override ProcessResult Process(ServersideQoLZDO zdo, IReadOnlyList<Peer> peers, PrefabInfo prefabInfo)
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d1: 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_023e: Unknown result type (might be due to invalid IL or missing references)
			//IL_036d: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_02da: Unknown result type (might be due to invalid IL or missing references)
			//IL_02de: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e3: Unknown result type (might be due to invalid IL or missing references)
			if (!_enabled)
			{
				return (ProcessResult)2;
			}
			ZDOVars vars;
			if (_states.TryGetValue(zdo, out State value) && !value.LeverReturned)
			{
				if (value.LeverPulled)
				{
					vars = zdo.Vars;
					if (!((ZDOVars)(ref vars)).GetInUse(false))
					{
						goto IL_0047;
					}
				}
				value.Sacrifices.Clear();
			}
			goto IL_0047;
			IL_0047:
			ContainerState state = Processor.Instance<ContainerRegistryProcessor>().GetState(zdo, prefabInfo.Container);
			IInventory inventory = state.GetInventory();
			bool flag = false;
			foreach (ItemData item in inventory.Items)
			{
				GameObject dropPrefab = item.m_dropPrefab;
				string text = ((dropPrefab != null) ? ((Object)dropPrefab).name : null);
				if (text == null || !_sacrifices.TryGetValue(text, out SacrificeInfo value2))
				{
					continue;
				}
				if (value == null)
				{
					Dictionary<ServersideQoLZDO, State> states = _states;
					State obj = new State
					{
						Revision = zdo.ZDO.DataRevision
					};
					value = obj;
					states.Add(zdo, obj);
					zdo.Destroyed += RemoveState;
				}
				else if (value.Revision != zdo.ZDO.DataRevision)
				{
					value.Revision = zdo.ZDO.DataRevision;
					value.Sacrifices.Clear();
				}
				State state2 = value;
				if (state2.RequestingPlayer == null)
				{
					PlayerState val = (state2.RequestingPlayer = Processor.Instance<PlayerRegistryProcessor>().GetStateForPeerID(zdo.ZDO.GetOwner()));
				}
				if (value.RequestingPlayer != null)
				{
					SacrificeInfo sacrificeInfo = value2;
					if (sacrificeInfo.ItemName == null)
					{
						string text2 = (sacrificeInfo.ItemName = Localization.instance.Localize(item.m_shared.m_name));
					}
					value.Sacrifices.Add(value2);
					flag = true;
				}
			}
			ProcessResult result = (ProcessResult)0;
			if (flag)
			{
				State state2 = value;
				if (state2.Sign == null)
				{
					ServersideQoLZDO val2 = (state2.Sign = ((Processor)this).PlacePiece(zdo.ZDO.GetPosition(), Prefabs.Sign, zdo.ZDO.GetRotation()));
				}
				string text4 = string.Join("<br>", value.Sacrifices.Select((SacrificeInfo x) => x.ItemName).Prepend<string>(value.RequestingPlayer.PlayerName + ":"));
				vars = value.Sign.Vars;
				((ZDOVars)(ref vars)).SetText("<mark=#000000><color=white>" + text4 + "<size=45><br><br>", "C:\\repos\\Valheim.ServersideQoL\\ServersideQoL.Player\\IncineratorProcessor.cs", 85);
			}
			else if (value != null && value.LeverReturned && value.RequestingPlayer != null)
			{
				foreach (SacrificeInfo sacrifice in value.Sacrifices)
				{
					sacrifice.SetSacrificed(value.RequestingPlayer.PlayerID);
					int? statusEffect = sacrifice.StatusEffect;
					if (statusEffect.HasValue)
					{
						int valueOrDefault = statusEffect.GetValueOrDefault();
						ZDORpc rPC = value.RequestingPlayer.ZDO.RPC;
						CharacterRpc character = ((ZDORpc)(ref rPC)).Character;
						((CharacterRpc)(ref character)).AddStatusEffect(valueOrDefault, false, 0, 0f, -1);
					}
					RPC.ShowMessage(value.RequestingPlayer.Owner, (MessageType)2, sacrifice.Message);
				}
				RemoveState(zdo);
			}
			else
			{
				int? statusEffect = value?.Sacrifices.Count;
				if (statusEffect.HasValue && statusEffect.GetValueOrDefault() == 0)
				{
					RemoveState(zdo);
				}
			}
			return result;
		}

		private void RemoveState(ServersideQoLZDO zdo)
		{
			zdo.Destroyed -= RemoveState;
			if (_states.Remove(zdo, out State value) && value.Sign != null)
			{
				((Processor)this).DestroyObject(value.Sign);
			}
		}

		private void RPC_RequestIncinerate(ServersideQoLZDO zdo, RoutedRPCData data, PlayerID playerID)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			PlayerState val = Processor.Instance<PlayerRegistryProcessor>().GetStateForPeerID(data.m_senderPeerID) ?? Processor.Instance<PlayerRegistryProcessor>().GetStateForPlayerID(playerID);
			State value;
			if (val == null)
			{
				((Processor)this).Logger.LogWarning((object)$"Player state for peerID={data.m_senderPeerID} or playerID={((PlayerID)(ref playerID)).Value} not found");
				RemoveState(zdo);
			}
			else if (_states.TryGetValue(zdo, out value))
			{
				value.RequestingPlayer = val;
			}
			else
			{
				_states.Add(zdo, new State
				{
					RequestingPlayer = val,
					Revision = 0u
				});
			}
		}

		private void RPC_AnimateLever(ServersideQoLZDO zdo)
		{
			if (_states.TryGetValue(zdo, out State value))
			{
				value.LeverPulled = true;
			}
		}

		private void RPC_AnimateLeverReturn(ServersideQoLZDO zdo)
		{
			if (_states.TryGetValue(zdo, out State value))
			{
				value.LeverReturned = true;
			}
		}
	}
	[BepInPlugin("ArgusMagnus.ServersideQoL.Player", "ServersideQoL.Player", "2.4.3")]
	public sealed class PlayerPlugin : ServersideQoLPluginBase<PlayerPlugin, Config>
	{
		public const string Author = "ArgusMagnus";

		public const string PluginName = "ServersideQoL.Player";

		public const string PluginGuid = "ArgusMagnus.ServersideQoL.Player";

		public const string PluginVersion = "2.4.3";

		public const string PluginInformationalVersion = "2.4.3";

		private DateTimeOffset BuildTimestamp { get; } = new DateTimeOffset(639284296389299142L, default(TimeSpan));

		protected override Config CreateConfigSingleton(ConfigFile configFile, Logger logger)
		{
			return new Config(configFile, logger);
		}

		protected override void RegisterProcessors(IProcessorCollection processors)
		{
			processors.Add<PlayerProcessor>().Add<CryptDoorProcessor>().Add<VagonProcessor>()
				.Add<IncineratorProcessor>();
		}

		private void Awake()
		{
		}
	}
	[Processor("7b156eea-3364-40ca-83ad-417a55fa6e4b")]
	[DependsOn<PlayerRegistryProcessor>]
	public sealed class PlayerProcessor : Processor<ProcessorPrefabInfo<Player>>
	{
		public const string Id = "7b156eea-3364-40ca-83ad-417a55fa6e4b";

		private readonly Dictionary<ServersideQoLZDO, ServersideQoLZDO> _attachedCartsByPlayer = new Dictionary<ServersideQoLZDO, ServersideQoLZDO>();

		public bool HasMegingjordEffect(PlayerID playerID)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			if (ConfigBase<Config>.Instance.CanSacrificeMegingjord.Value)
			{
				return GetSacrifiedMegingjord(playerID);
			}
			return false;
		}

		protected override void Initialize()
		{
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Expected O, but got Unknown
			//IL_0102: Unknown result type (might be due to invalid IL or missing references)
			//IL_0108: Invalid comparison between Unknown and I4
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Expected O, but got Unknown
			Processor.Instance<PlayerRegistryProcessor>().StaminaUpdated -= OnPlayerStaminaUpdated;
			if (ConfigBase<Config>.Instance.InfiniteEncumberedStamina.Value || ConfigBase<Config>.Instance.InfiniteSneakingStamina.Value || ConfigBase<Config>.Instance.InfiniteSwimmingStamina.Value)
			{
				Processor.Instance<PlayerRegistryProcessor>().StaminaUpdated += OnPlayerStaminaUpdated;
			}
			bool flag = false;
			if (Game.m_staminaRate > 0f)
			{
				flag = ConfigBase<Config>.Instance.InfiniteBuildingStamina.Value || ConfigBase<Config>.Instance.InfiniteFarmingStamina.Value || ConfigBase<Config>.Instance.InfiniteMiningStamina.Value || ConfigBase<Config>.Instance.InfiniteWoodCuttingStamina.Value;
			}
			Processor.Instance<PlayerRegistryProcessor>().ItemUsed -= new ItemUsedHandler(OnPlayerItemUsed);
			if (flag)
			{
				Processor.Instance<PlayerRegistryProcessor>().ItemUsed += new ItemUsedHandler(OnPlayerItemUsed);
			}
			Processor.Instance<PlayerRegistryProcessor>().EmoteDetected -= OnEmoteDetected;
			if ((int)ConfigBase<Config>.Instance.OpenCartEmote.Value != -1)
			{
				Processor.Instance<PlayerRegistryProcessor>().EmoteDetected += OnEmoteDetected;
			}
			_attachedCartsByPlayer.Clear();
		}

		protected override ProcessResult Process(ServersideQoLZDO zdo, IReadOnlyList<Peer> peers, ProcessorPrefabInfo<Player> prefabInfo)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			PlayerState state = Processor.Instance<PlayerRegistryProcessor>().GetState(zdo);
			if (state != null)
			{
				CharacterRpc character;
				if (ConfigBase<Config>.Instance.CanSacrificeMegingjord.Value && GetSacrifiedMegingjord(state.PlayerID))
				{
					ZDORpc rPC = zdo.RPC;
					character = ((ZDORpc)(ref rPC)).Character;
					((CharacterRpc)(ref character)).AddStatusEffect(StatusEffects.Megingjord, false, 0, 0f, -1);
				}
				if (ConfigBase<Config>.Instance.CanSacrificeWishbone.Value && GetSacrifiedWishbone(state.PlayerID))
				{
					ZDORpc rPC2 = zdo.RPC;
					character = ((ZDORpc)(ref rPC2)).Character;
					((CharacterRpc)(ref character)).AddStatusEffect(StatusEffects.Wishbone, false, 0, 0f, -1);
				}
				if (ConfigBase<Config>.Instance.CanSacrificeTornSpirit.Value && GetSacrifiedTornSpirit(state.PlayerID))
				{
					ZDORpc rPC3 = zdo.RPC;
					character = ((ZDORpc)(ref rPC3)).Character;
					((CharacterRpc)(ref character)).AddStatusEffect(StatusEffects.Demister, false, 0, 0f, -1);
				}
				return (ProcessResult)2;
			}
			return (ProcessResult)2;
		}

		private void OnPlayerStaminaUpdated(PlayerState state)
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: Unknown result type (might be due to invalid IL or missing references)
			//IL_010f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0120: Unknown result type (might be due to invalid IL or missing references)
			//IL_0125: Unknown result type (might be due to invalid IL or missing references)
			//IL_0129: Unknown result type (might be due to invalid IL or missing references)
			//IL_012e: Unknown result type (might be due to invalid IL or missing references)
			ZDOVars vars;
			PlayerRpc player;
			if ((float)state.Stamina < state.PrefabInfo.Component.m_encumberedStaminaDrain && ConfigBase<Config>.Instance.InfiniteEncumberedStamina.Value)
			{
				vars = state.ZDO.Vars;
				if (((ZDOVars)(ref vars)).GetAnimationIsEncumbered(false))
				{
					ZDORpc rPC = state.ZDO.RPC;
					player = ((ZDORpc)(ref rPC)).Player;
					((PlayerRpc)(ref player)).UseStamina(0f - state.PrefabInfo.Component.m_encumberedStaminaDrain);
					return;
				}
			}
			if ((float)state.Stamina < state.PrefabInfo.Component.m_sneakStaminaDrain && ConfigBase<Config>.Instance.InfiniteSneakingStamina.Value)
			{
				vars = state.ZDO.Vars;
				if (((ZDOVars)(ref vars)).GetAnimationIsCrouching(false))
				{
					ZDORpc rPC2 = state.ZDO.RPC;
					player = ((ZDORpc)(ref rPC2)).Player;
					((PlayerRpc)(ref player)).UseStamina(0f - state.PrefabInfo.Component.m_sneakStaminaDrain);
					return;
				}
			}
			if ((float)state.Stamina < state.PrefabInfo.Component.m_swimStaminaDrainMinSkill && ConfigBase<Config>.Instance.InfiniteSwimmingStamina.Value)
			{
				vars = state.ZDO.Vars;
				if (((ZDOVars)(ref vars)).GetAnimationInWater(false))
				{
					ZDORpc rPC3 = state.ZDO.RPC;
					player = ((ZDORpc)(ref rPC3)).Player;
					((PlayerRpc)(ref player)).UseStamina(0f - state.PrefabInfo.Component.m_swimStaminaDrainMinSkill);
				}
			}
		}

		private void OnPlayerItemUsed(PlayerState state, string animationTriggerName)
		{
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			if (state.LastUsedItem != null && CheckStamina(animationTriggerName))
			{
				float attackStamina = state.LastUsedItem.m_itemData.m_shared.m_attack.m_attackStamina;
				ZDOVars vars = state.ZDO.Vars;
				if (((ZDOVars)(ref vars)).GetStamina(0f) < 2f * attackStamina)
				{
					ZDORpc rPC = state.ZDO.RPC;
					PlayerRpc player = ((ZDORpc)(ref rPC)).Player;
					((PlayerRpc)(ref player)).UseStamina(0f - attackStamina);
				}
			}
			static bool CheckStamina(string triggerName)
			{
				switch (triggerName)
				{
				case "swing_pickaxe":
					return ConfigBase<Config>.Instance.InfiniteMiningStamina.Value;
				case "swing_hammer":
					return ConfigBase<Config>.Instance.InfiniteBuildingStamina.Value;
				case "swing_hoe":
				case "scything":
					return ConfigBase<Config>.Instance.InfiniteFarmingStamina.Value;
				case "dualaxes0":
				case "swing_axe0":
				case "battleaxe_attack0":
					return ConfigBase<Config>.Instance.InfiniteWoodCuttingStamina.Value;
				default:
					return false;
				}
			}
		}

		private void OnEmoteDetected(PlayerState state, Emotes emote)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Invalid comparison between Unknown and I4
			//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_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			if (((int)ConfigBase<Config>.Instance.OpenCartEmote.Value == -2 || ConfigBase<Config>.Instance.OpenCartEmote.Value == emote) && _attachedCartsByPlayer.TryGetValue(state.ZDO, out ServersideQoLZDO value) && value.ZDO.GetOwner() == state.Owner)
			{
				ZDOVars vars = value.Vars;
				if (((ZDOVars)(ref vars)).GetAttachJoint(false))
				{
					ZDORpc rPC = value.RPC;
					ContainerRpc container = ((ZDORpc)(ref rPC)).Container;
					((ContainerRpc)(ref container)).OpenResponse(true);
				}
			}
		}

		internal void UpdateAttachedCart(ServersideQoLZDO cart)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			PlayerState stateForPeerID = Processor.Instance<PlayerRegistryProcessor>().GetStateForPeerID(cart.ZDO.GetOwner());
			if (stateForPeerID != null)
			{
				ZDOVars vars = cart.Vars;
				if (!((ZDOVars)(ref vars)).GetAttachJoint(false))
				{
					_attachedCartsByPlayer.Remove(stateForPeerID.ZDO);
					return;
				}
				if (!_attachedCartsByPlayer.TryAdd(stateForPeerID.ZDO, cart))
				{
					_attachedCartsByPlayer[stateForPeerID.ZDO] = cart;
					return;
				}
				stateForPeerID.ZDO.Destroyed += OnPlayerDestroyed;
				cart.Destroyed += OnCartDestroyed;
			}
		}

		private void OnPlayerDestroyed(ServersideQoLZDO zdo)
		{
			if (_attachedCartsByPlayer.Remove(zdo, out ServersideQoLZDO value))
			{
				value.Destroyed -= OnCartDestroyed;
			}
		}

		private void OnCartDestroyed(ServersideQoLZDO zdo)
		{
			List<ServersideQoLZDO> list = null;
			foreach (var (item, val3) in _attachedCartsByPlayer)
			{
				if (val3 == zdo)
				{
					(list ?? (list = new List<ServersideQoLZDO>())).Add(item);
				}
			}
			if (list == null)
			{
				return;
			}
			foreach (ServersideQoLZDO item2 in list)
			{
				if (_attachedCartsByPlayer.Remove(item2, out ServersideQoLZDO _))
				{
					item2.Destroyed -= OnPlayerDestroyed;
				}
			}
		}

		private static bool GetSacrifiedMegingjord(PlayerID playerID, bool defaultValue = false)
		{
			return Processor.DataZDO.ZDO.GetBool($"player{((PlayerID)(ref playerID)).Value}_SacrifiedMegingjord", defaultValue);
		}

		internal static void SetSacrifiedMegingjord(PlayerID playerID, bool value)
		{
			Processor.DataZDO.ZDO.Set($"player{((PlayerID)(ref playerID)).Value}_SacrifiedMegingjord", value);
		}

		internal static bool GetSacrifiedCryptKey(PlayerID playerID, bool defaultValue = false)
		{
			return Processor.DataZDO.ZDO.GetBool($"player{((PlayerID)(ref playerID)).Value}_SacrifiedCryptKey", defaultValue);
		}

		internal static void SetSacrifiedCryptKey(PlayerID playerID, bool value)
		{
			Processor.DataZDO.ZDO.Set($"player{((PlayerID)(ref playerID)).Value}_SacrifiedCryptKey", value);
		}

		private static bool GetSacrifiedWishbone(PlayerID playerID, bool defaultValue = false)
		{
			return Processor.DataZDO.ZDO.GetBool($"player{((PlayerID)(ref playerID)).Value}_SacrifiedWishbone", defaultValue);
		}

		internal static void SetSacrifiedWishbone(PlayerID playerID, bool value)
		{
			Processor.DataZDO.ZDO.Set($"player{((PlayerID)(ref playerID)).Value}_SacrifiedWishbone", value);
		}

		private static bool GetSacrifiedTornSpirit(PlayerID playerID, bool defaultValue = false)
		{
			return Processor.DataZDO.ZDO.GetBool($"player{((PlayerID)(ref playerID)).Value}_SacrifiedTornSpirit", defaultValue);
		}

		internal static void SetSacrifiedTornSpirit(PlayerID playerID, bool value)
		{
			Processor.DataZDO.ZDO.Set($"player{((PlayerID)(ref playerID)).Value}_SacrifiedTornSpirit", value);
		}
	}
	[Processor("8a10c73e-67db-4dc2-8b0c-3242aac82e3b")]
	public sealed class VagonProcessor : Processor<VagonProcessor.PrefabInfo>
	{
		public sealed record PrefabInfo(Vagon Vagon, Piece Piece, Container Container) : ProcessorPrefabInfo()
		{
			[CompilerGenerated]
			public override string ToString()
			{
				StringBuilder stringBuilder = new StringBuilder();
				stringBuilder.Append("PrefabInfo");
				stringBuilder.Append(" { ");
				if (((ProcessorPrefabInfo)this).PrintMembers(stringBuilder))
				{
					stringBuilder.Append(' ');
				}
				stringBuilder.Append('}');
				return stringBuilder.ToString();
			}

			[CompilerGenerated]
			protected override bool PrintMembers(StringBuilder builder)
			{
				if (((ProcessorPrefabInfo)this).PrintMembers(builder))
				{
					builder.Append(", ");
				}
				builder.Append("Vagon = ");
				builder.Append(Vagon);
				builder.Append(", Piece = ");
				builder.Append(Piece);
				builder.Append(", Container = ");
				builder.Append(Container);
				return true;
			}

			[CompilerGenerated]
			public override int GetHashCode()
			{
				return ((((ProcessorPrefabInfo)this).GetHashCode() * -1521134295 + EqualityComparer<Vagon>.Default.GetHashCode(Vagon)) * -1521134295 + EqualityComparer<Piece>.Default.GetHashCode(Piece)) * -1521134295 + EqualityComparer<Container>.Default.GetHashCode(Container);
			}

			[CompilerGenerated]
			public sealed override bool Equals(ProcessorPrefabInfo? other)
			{
				return ((object)this).Equals((object?)other);
			}

			[CompilerGenerated]
			public bool Equals(PrefabInfo? other)
			{
				if ((object)this != other)
				{
					if (((ProcessorPrefabInfo)this).Equals((ProcessorPrefabInfo)(object)other) && EqualityComparer<Vagon>.Default.Equals(Vagon, other.Vagon) && EqualityComparer<Piece>.Default.Equals(Piece, other.Piece))
					{
						return EqualityComparer<Container>.Default.Equals(Container, other.Container);
					}
					return false;
				}
				return true;
			}

			[CompilerGenerated]
			private PrefabInfo(PrefabInfo original)
				: base((ProcessorPrefabInfo)(object)original)
			{
				Vagon = original.Vagon;
				Piece = original.Piece;
				Container = original.Container;
			}
		}

		protected override ProcessResult Process(ServersideQoLZDO zdo, IReadOnlyList<Peer> peers, PrefabInfo prefabInfo)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Invalid comparison between Unknown and I4
			if ((int)ConfigBase<Config>.Instance.OpenCartEmote.Value != -1)
			{
				Processor.Instance<PlayerProcessor>().UpdateAttachedCart(zdo);
				return (ProcessResult)0;
			}
			return (ProcessResult)2;
		}
	}
}