using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
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 BepInEx.Logging;
using ConditionalConfigSync;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using TMPro;
using UnityEngine;
using UnityEngine.Events;
using UnityEngine.UI;
using VSM.Core.Config;
using VSM.Core.Harmony;
using VSM.Core.Localization;
using VSM.Core.Reflection;
using VSM.Core.Runtime;
using VSM.Core.Ui;
using VSM.Slots.Core;
using VSM.Slots.Runtime;
using VSM.Slots.Transmog;
using VSM.Slots.Ui;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: <f38ba538-35fd-47fd-b707-af2183e34bfc>IgnoresAccessChecksTo("assembly_guiutils")]
[assembly: <f38ba538-35fd-47fd-b707-af2183e34bfc>IgnoresAccessChecksTo("assembly_utils")]
[assembly: <f38ba538-35fd-47fd-b707-af2183e34bfc>IgnoresAccessChecksTo("assembly_valheim")]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: AssemblyCompany("VSM.Slots")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("0.1.4.0")]
[assembly: AssemblyInformationalVersion("0.1.4+ff27bc889ccf218c61c45d3417d48ab708a5ba8f")]
[assembly: AssemblyProduct("VSM.Slots")]
[assembly: AssemblyTitle("VSM.Slots")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.1.4.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[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 VSM.Slots
{
	[BepInPlugin("vsm.slots", "MEL Slots", "0.1.4")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public sealed class SlotsPlugin : BaseUnityPlugin
	{
		[HarmonyPatch(typeof(Game), "Start")]
		internal static class NetPatch
		{
			private static ZRoutedRpc s_registeredFor;

			[HarmonyPostfix]
			private static void Postfix()
			{
				ZRoutedRpc instance = ZRoutedRpc.instance;
				if (instance != null && instance != s_registeredFor)
				{
					instance.Register<string, int, int>("VSM_Slots_RowsTrimmed", (Action<long, string, int, int>)RowCap.RPC_RowsTrimmed);
					s_registeredFor = instance;
					SlotState.Reset();
					Reconciler.Forget();
				}
			}
		}

		[HarmonyPatch(typeof(Terminal), "InitTerminal")]
		internal static class CommandsPatch
		{
			[HarmonyPostfix]
			private static void Postfix()
			{
				RegisterCommands();
			}
		}

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

			public static EventHandler <>9__23_0;

			public static EventHandler <>9__23_1;

			public static EventHandler <>9__23_2;

			public static EventHandler <>9__23_3;

			public static EventHandler <>9__23_4;

			public static EventHandler <>9__23_5;

			public static EventHandler <>9__23_6;

			public static EventHandler <>9__23_7;

			public static ConsoleEvent <>9__35_0;

			public static ConsoleEvent <>9__35_1;

			internal void <BindConfig>b__23_0(object s, EventArgs e)
			{
				SlotLayout.SetEnabled(EnabledSlots.Value);
				RefreshLooks();
			}

			internal void <BindConfig>b__23_1(object s, EventArgs e)
			{
				EnforceRows("config");
			}

			internal void <BindConfig>b__23_2(object s, EventArgs e)
			{
				EnforceRows("config");
			}

			internal void <BindConfig>b__23_3(object s, EventArgs e)
			{
				EnforceRows("config");
			}

			internal void <BindConfig>b__23_4(object s, EventArgs e)
			{
				EnforceRows("config");
			}

			internal void <BindConfig>b__23_5(object s, EventArgs e)
			{
				RefreshLooks();
			}

			internal void <BindConfig>b__23_6(object s, EventArgs e)
			{
				RefreshLooks();
			}

			internal void <BindConfig>b__23_7(object s, EventArgs e)
			{
				RefreshLooks();
			}

			internal void <RegisterCommands>b__35_0(ConsoleEventArgs args)
			{
				//IL_011a: Unknown result type (might be due to invalid IL or missing references)
				//IL_011f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0122: Unknown result type (might be due to invalid IL or missing references)
				//IL_0129: Unknown result type (might be due to invalid IL or missing references)
				//IL_02c1: Unknown result type (might be due to invalid IL or missing references)
				Player localPlayer = Player.m_localPlayer;
				if ((Object)(object)localPlayer == (Object)null)
				{
					args.Context.AddString("Sin jugador local.");
					return;
				}
				Inventory inventory = ((Humanoid)localPlayer).m_inventory;
				int num = SlotState.VisibleRows(localPlayer);
				args.Context.AddString("vsm.slots 0.1.4 | filas visibles=" + num + " (tope " + RowCap.MaxRows(localPlayer) + ", " + RowsCap.Value.ToString() + ") | altura=" + inventory.m_height + " | config lista=" + IsConfigReady + " | seguridad=" + s_safetyOk + " | funciones=" + s_featuresOk);
				SlotDefinition[] all = SlotLayout.All;
				foreach (SlotDefinition slotDefinition in all)
				{
					Vector2i val = SlotLayout.CellOf(slotDefinition, num);
					ItemData itemAt = inventory.GetItemAt(val.x, val.y);
					ItemData val2 = slotDefinition.Equipped((Humanoid)(object)localPlayer);
					Appearance look;
					string text = (TransmogRuntime.Get(localPlayer).TryGet(slotDefinition.Id, out look) ? (look.Hidden ? "oculto" : (look.Prefab + ((look.Variant > 0) ? (":" + look.Variant) : string.Empty))) : "-");
					args.Context.AddString("  " + slotDefinition.Id + (SlotLayout.IsEnabled(slotDefinition) ? string.Empty : " (desactivada)") + " @" + val.x + "," + val.y + ": " + ((itemAt != null) ? itemAt.m_shared.m_name : "-") + " | puesto: " + ((val2 != null) ? val2.m_shared.m_name : "-") + " | apariencia: " + text + ((itemAt != null && itemAt != val2) ? "  <-- en espera / incoherente" : string.Empty));
				}
				int num2 = 0;
				foreach (ItemData allItem in inventory.GetAllItems())
				{
					if (allItem.m_gridPos.y == num && SlotLayout.SlotAt(allItem.m_gridPos, num) == null)
					{
						num2++;
					}
				}
				args.Context.AddString("Objetos atascados en celdas reservadas: " + num2);
			}

			internal void <RegisterCommands>b__35_1(ConsoleEventArgs args)
			{
				Player localPlayer = Player.m_localPlayer;
				if ((Object)(object)localPlayer != (Object)null)
				{
					TransmogRuntime.ClearAll(localPlayer);
					args.Context.AddString("Apariencias quitadas.");
				}
			}
		}

		internal static ManualLogSource Log;

		private static ConfigSync s_sync;

		private Harmony _harmony;

		private static bool s_safetyOk;

		private static bool s_featuresOk;

		private static float s_lastMessage;

		private static readonly HashSet<string> s_loggedOnce = new HashSet<string>();

		public static ConfigEntry<string> EnabledSlots;

		public static ConfigEntry<RowsCapMode> RowsCap;

		public static ConfigEntry<int> RowsBase;

		public static ConfigEntry<string> RowsLegalKeys;

		public static ConfigEntry<int> RowsFixedMax;

		public static ConfigEntry<bool> TransmogEnabled;

		public static ConfigEntry<bool> TransmogRequireKnown;

		public static ConfigEntry<bool> TransmogAllowHide;

		public static ConfigEntry<bool> ServerLock;

		public static ConfigEntry<bool> ShowSlotLabels;

		public static ConfigEntry<float> PanelGapX;

		public static ConfigEntry<float> PanelOffsetY;

		public static ConfigEntry<float> PanelScale;

		public static ConfigEntry<bool> ShowMessages;

		private static readonly Dictionary<string, string> s_spanish = new Dictionary<string, string>
		{
			{ "vsm_slots_title", "Equipo" },
			{ "vsm_slots_helmet", "Casco" },
			{ "vsm_slots_chest", "Pecho" },
			{ "vsm_slots_legs", "Piernas" },
			{ "vsm_slots_shoulder", "Capa" },
			{ "vsm_slots_utility", "Cinturón" },
			{ "vsm_slots_trinket", "Trinket" },
			{ "vsm_slots_close", "Cerrar" },
			{ "vsm_slots_wrong_type", "Eso no va en la ranura de {0}" },
			{ "vsm_slots_swap_blocked", "No se puede cambiar: {0} no va en la ranura de {1}" },
			{ "vsm_slots_inventory_full", "Inventario lleno: no hay sitio para quitártelo" },
			{ "vsm_slots_stuck", "{0} está esperando sitio en tu inventario para salir de la fila de equipo" },
			{ "vsm_slots_rows_dropped", "No cabía todo: {0} objetos quedaron en el suelo junto a ti" },
			{ "vsm_slots_rows_trimmed", "El servidor permite {1} filas de inventario (tenías {0}). Lo que no cupo quedó en el suelo junto a ti." },
			{ "vsm_slots_transmog_button", "Transfigurar" },
			{ "vsm_slots_transmog_title", "Transfiguración" },
			{ "vsm_slots_transmog_wearing", "{0}: llevas {1}. Elige cómo se ve (las estadísticas no cambian)." },
			{ "vsm_slots_transmog_nothing", "{0}: no llevas nada. La apariencia elegida se verá cuando te pongas una pieza." },
			{ "vsm_slots_transmog_none_known", "Todavía no has tenido ninguna pieza de {0}. Cuando consigas una, aparecerá aquí." },
			{ "vsm_slots_transmog_original", "Original" },
			{ "vsm_slots_transmog_original_tip", "Se ve la pieza que llevas puesta" },
			{ "vsm_slots_transmog_hide", "Ocultar" },
			{ "vsm_slots_transmog_hide_tip", "No se ve nada en esta ranura (la pieza sigue protegiendo)" },
			{ "vsm_slots_transmog_reset_all", "Quitar todas" },
			{ "vsm_slots_transmog_saved_empty", "Guardado: se verá cuando lleves algo en la ranura de {0}" }
		};

		public static bool IsConfigReady => s_sync != null && (((ConditionalConfigSync)s_sync).IsSourceOfTruth || ((ConditionalConfigSync)s_sync).InitialSyncDone);

		private void Awake()
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Expected O, but got Unknown
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Expected O, but got Unknown
			Log = ((BaseUnityPlugin)this).Logger;
			s_sync = new ConfigSync("vsm.slots")
			{
				DisplayName = "MEL Slots",
				CurrentVersion = "0.1.4",
				MinimumRequiredVersion = "0.1.4",
				ModRequired = true
			};
			BindConfig();
			SlotLayout.SetEnabled(EnabledSlots.Value);
			((ConditionalConfigSync)s_sync).InitialSyncCompleted += OnServerConfig;
			Log.LogInfo((object)("vsm.slots 0.1.4 | Valheim " + GameConstants.GameVersionString + " | headless=" + Headless.IsHeadless));
			_harmony = new Harmony("vsm.slots");
			PatchUtil.PatchClassSafely(Log, _harmony, typeof(NetPatch));
			if (Headless.IsHeadless)
			{
				Log.LogInfo((object)"vsm.slots: servidor dedicado: configuración y registro de recortes, sin parches de inventario.");
				return;
			}
			VsmLocalization.Register(Log, Path.GetDirectoryName(((BaseUnityPlugin)this).Info.Location), s_spanish);
			s_safetyOk = true;
			Type[] classes = SafetyPatches.Classes;
			foreach (Type patchClass in classes)
			{
				s_safetyOk &= PatchUtil.PatchClassSafely(Log, _harmony, patchClass);
			}
			if (!s_safetyOk)
			{
				Log.LogError((object)"vsm.slots: faltan parches de seguridad (¿cambió el juego?). Las ranuras quedan en modo protegido: sin panel ni arrastres.");
				return;
			}
			bool flag = PatchUtil.PatchClassSafely(Log, _harmony, typeof(DragResolver));
			PatchUtil.PatchClassSafely(Log, _harmony, typeof(TransmogRuntime.ApplyPatch));
			PatchUtil.PatchClassSafely(Log, _harmony, typeof(GraveEasyFit));
			PatchUtil.PatchClassSafely(Log, _harmony, typeof(CommandsPatch));
			if (flag)
			{
				Type[] classes2 = UiPatches.Classes;
				foreach (Type patchClass2 in classes2)
				{
					PatchUtil.PatchClassSafely(Log, _harmony, patchClass2);
				}
			}
			else
			{
				Log.LogError((object)"vsm.slots: no se pudo enganchar el arrastre; el panel de equipo no se muestra (las ranuras siguen funcionando con clic derecho).");
			}
			s_featuresOk = true;
		}

		private void BindConfig()
		{
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Expected O, but got Unknown
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Expected O, but got Unknown
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: Expected O, but got Unknown
			//IL_0146: Unknown result type (might be due to invalid IL or missing references)
			//IL_0150: Expected O, but got Unknown
			//IL_018e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0198: Expected O, but got Unknown
			//IL_0213: Unknown result type (might be due to invalid IL or missing references)
			//IL_021d: Expected O, but got Unknown
			//IL_0254: Unknown result type (might be due to invalid IL or missing references)
			//IL_025e: 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_036d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0377: Expected O, but got Unknown
			EnabledSlots = ((BaseUnityPlugin)this).Config.Bind<string>("1. Ranuras", "EnabledSlots", "helmet,chest,legs,shoulder,utility,trinket", new ConfigDescription("Ranuras activas (ids separados por coma: helmet, chest, legs, shoulder, utility, trinket). Lo que haya en una ranura desactivada vuelve al inventario.", (AcceptableValueBase)null, new object[1]
			{
				new ConfigurationManagerAttributes
				{
					Order = 100
				}
			}));
			((ConditionalConfigSync)s_sync).AddConfigEntry<string>(EnabledSlots, (ConfigSyncMode)0);
			ServerLock = ((BaseUnityPlugin)this).Config.Bind<bool>("1. Ranuras", "ServerLock", true, "Bloquea la configuración sincronizada: solo los administradores del servidor pueden cambiarla.");
			((ConditionalConfigSync)s_sync).AddLockingConfigEntry<bool>(ServerLock);
			RowsCap = ((BaseUnityPlugin)this).Config.Bind<RowsCapMode>("2. Filas del inventario", "RowsCap", RowsCapMode.Legal, new ConfigDescription("Tope de filas del inventario. Legal = base + una por cada bolsillo comprado a Haldor (lo que se puede conseguir jugando; quien traiga más filas de un mundo con trucos se recorta al entrar). Fijo = el máximo de RowsFixedMax para todos. Libre = sin tope (hasta 9).", (AcceptableValueBase)null, new object[1]
			{
				new ConfigurationManagerAttributes
				{
					Order = 90
				}
			}));
			RowsBase = ((BaseUnityPlugin)this).Config.Bind<int>("2. Filas del inventario", "RowsBase", 4, new ConfigDescription("Filas con las que empieza todo personaje (vanilla: 4). Solo en modo Legal.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(1, 9), new object[1]
			{
				new ConfigurationManagerAttributes
				{
					Order = 89
				}
			}));
			RowsLegalKeys = ((BaseUnityPlugin)this).Config.Bind<string>("2. Filas del inventario", "RowsLegalKeys", "invslot1,invslot2", new ConfigDescription("Claves de compra que dan una fila cada una (vanilla: invslot1 = Bolsillos más amplios, invslot2 = Bolsillos más profundos). Solo en modo Legal.", (AcceptableValueBase)null, new object[1]
			{
				new ConfigurationManagerAttributes
				{
					Order = 88
				}
			}));
			RowsFixedMax = ((BaseUnityPlugin)this).Config.Bind<int>("2. Filas del inventario", "RowsFixedMax", 6, new ConfigDescription("Máximo de filas en modo Fijo.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(1, 9), new object[1]
			{
				new ConfigurationManagerAttributes
				{
					Order = 87
				}
			}));
			((ConditionalConfigSync)s_sync).AddConfigEntry<RowsCapMode>(RowsCap, (ConfigSyncMode)0);
			((ConditionalConfigSync)s_sync).AddConfigEntry<int>(RowsBase, (ConfigSyncMode)0);
			((ConditionalConfigSync)s_sync).AddConfigEntry<string>(RowsLegalKeys, (ConfigSyncMode)0);
			((ConditionalConfigSync)s_sync).AddConfigEntry<int>(RowsFixedMax, (ConfigSyncMode)0);
			TransmogEnabled = ((BaseUnityPlugin)this).Config.Bind<bool>("3. Transfiguración", "Enabled", true, new ConfigDescription("Permite cambiar la apariencia del equipo (las estadísticas siguen siendo las de la pieza real). Apagarlo desde el servidor quita todas las apariencias.", (AcceptableValueBase)null, new object[1]
			{
				new ConfigurationManagerAttributes
				{
					Order = 80
				}
			}));
			TransmogRequireKnown = ((BaseUnityPlugin)this).Config.Bind<bool>("3. Transfiguración", "RequireKnown", true, new ConfigDescription("Solo se pueden elegir apariencias de piezas que el jugador ya haya tenido alguna vez en el inventario.", (AcceptableValueBase)null, new object[1]
			{
				new ConfigurationManagerAttributes
				{
					Order = 79
				}
			}));
			TransmogAllowHide = ((BaseUnityPlugin)this).Config.Bind<bool>("3. Transfiguración", "AllowHide", true, new ConfigDescription("Permite ocultar una pieza (se ve el cuerpo o el pelo, pero la pieza sigue protegiendo).", (AcceptableValueBase)null, new object[1]
			{
				new ConfigurationManagerAttributes
				{
					Order = 78
				}
			}));
			((ConditionalConfigSync)s_sync).AddConfigEntry<bool>(TransmogEnabled, (ConfigSyncMode)0);
			((ConditionalConfigSync)s_sync).AddConfigEntry<bool>(TransmogRequireKnown, (ConfigSyncMode)0);
			((ConditionalConfigSync)s_sync).AddConfigEntry<bool>(TransmogAllowHide, (ConfigSyncMode)0);
			ShowSlotLabels = ((BaseUnityPlugin)this).Config.Bind<bool>("4. Interfaz", "ShowSlotLabels", true, "Nombre de cada ranura debajo de la celda.");
			PanelGapX = ((BaseUnityPlugin)this).Config.Bind<float>("4. Interfaz", "PanelGapX", 8f, "Separación horizontal (píxeles) entre las pestañas de armadura/peso y el panel de equipo.");
			PanelOffsetY = ((BaseUnityPlugin)this).Config.Bind<float>("4. Interfaz", "PanelOffsetY", 0f, "Desplazamiento vertical del panel de equipo (píxeles).");
			PanelScale = ((BaseUnityPlugin)this).Config.Bind<float>("4. Interfaz", "PanelScale", 1f, new ConfigDescription("Escala del panel de equipo (se encoge solo si no cabe).", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.5f, 2f), Array.Empty<object>()));
			ShowMessages = ((BaseUnityPlugin)this).Config.Bind<bool>("4. Interfaz", "ShowMessages", true, "Avisos en pantalla (objeto que no va en la ranura, inventario lleno, recortes).");
			EnabledSlots.SettingChanged += delegate
			{
				SlotLayout.SetEnabled(EnabledSlots.Value);
				RefreshLooks();
			};
			RowsCap.SettingChanged += delegate
			{
				EnforceRows("config");
			};
			RowsBase.SettingChanged += delegate
			{
				EnforceRows("config");
			};
			RowsLegalKeys.SettingChanged += delegate
			{
				EnforceRows("config");
			};
			RowsFixedMax.SettingChanged += delegate
			{
				EnforceRows("config");
			};
			TransmogEnabled.SettingChanged += delegate
			{
				RefreshLooks();
			};
			TransmogRequireKnown.SettingChanged += delegate
			{
				RefreshLooks();
			};
			TransmogAllowHide.SettingChanged += delegate
			{
				RefreshLooks();
			};
		}

		private static void OnServerConfig()
		{
			SlotLayout.SetEnabled(EnabledSlots.Value);
			EnforceRows("config del servidor");
			RefreshLooks();
		}

		private static void EnforceRows(string when)
		{
			if (!s_safetyOk || (Object)(object)Player.m_localPlayer == (Object)null)
			{
				return;
			}
			try
			{
				RowCap.Enforce(Player.m_localPlayer, when);
			}
			catch (Exception ex)
			{
				Log.LogError((object)("vsm.slots: tope de filas: " + ex));
			}
		}

		private static void RefreshLooks()
		{
			if (s_featuresOk && (Object)(object)Player.m_localPlayer != (Object)null)
			{
				TransmogRuntime.Refresh(Player.m_localPlayer);
			}
		}

		private void LateUpdate()
		{
			if (!s_featuresOk)
			{
				return;
			}
			try
			{
				Reconciler.Tick();
			}
			catch (Exception ex)
			{
				LogOnce("reconcile", "vsm.slots: reconciliación: " + ex);
			}
			try
			{
				EquipmentPanel.Tick();
			}
			catch (Exception ex2)
			{
				LogOnce("panel", "vsm.slots: panel: " + ex2);
			}
		}

		private void OnDestroy()
		{
			TransmogPanel.Destroy();
			EquipmentPanel.Destroy();
			if (_harmony != null)
			{
				_harmony.UnpatchSelf();
			}
		}

		internal static void Message(Player p, string token, params object[] args)
		{
			if ((Object)(object)p == (Object)null || !ShowMessages.Value || Time.unscaledTime - s_lastMessage < 1f)
			{
				return;
			}
			s_lastMessage = Time.unscaledTime;
			if (args != null)
			{
				for (int i = 0; i < args.Length; i++)
				{
					if (args[i] is string { Length: >1 } text && text[0] == '$')
					{
						args[i] = VsmLocalization.Localize(text);
					}
				}
			}
			((Character)p).Message((MessageType)2, VsmLocalization.Localize(token, args), 0, (Sprite)null, false);
		}

		internal static void LogOnce(string key, string message)
		{
			if (s_loggedOnce.Add(key))
			{
				Log.LogError((object)message);
			}
		}

		private static void RegisterCommands()
		{
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Expected O, but got Unknown
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Expected O, but got Unknown
			object obj = <>c.<>9__35_0;
			if (obj == null)
			{
				ConsoleEvent val = delegate(ConsoleEventArgs args)
				{
					//IL_011a: Unknown result type (might be due to invalid IL or missing references)
					//IL_011f: Unknown result type (might be due to invalid IL or missing references)
					//IL_0122: Unknown result type (might be due to invalid IL or missing references)
					//IL_0129: Unknown result type (might be due to invalid IL or missing references)
					//IL_02c1: Unknown result type (might be due to invalid IL or missing references)
					Player localPlayer = Player.m_localPlayer;
					if ((Object)(object)localPlayer == (Object)null)
					{
						args.Context.AddString("Sin jugador local.");
					}
					else
					{
						Inventory inventory = ((Humanoid)localPlayer).m_inventory;
						int num = SlotState.VisibleRows(localPlayer);
						args.Context.AddString("vsm.slots 0.1.4 | filas visibles=" + num + " (tope " + RowCap.MaxRows(localPlayer) + ", " + RowsCap.Value.ToString() + ") | altura=" + inventory.m_height + " | config lista=" + IsConfigReady + " | seguridad=" + s_safetyOk + " | funciones=" + s_featuresOk);
						SlotDefinition[] all = SlotLayout.All;
						foreach (SlotDefinition slotDefinition in all)
						{
							Vector2i val3 = SlotLayout.CellOf(slotDefinition, num);
							ItemData itemAt = inventory.GetItemAt(val3.x, val3.y);
							ItemData val4 = slotDefinition.Equipped((Humanoid)(object)localPlayer);
							Appearance look;
							string text = (TransmogRuntime.Get(localPlayer).TryGet(slotDefinition.Id, out look) ? (look.Hidden ? "oculto" : (look.Prefab + ((look.Variant > 0) ? (":" + look.Variant) : string.Empty))) : "-");
							args.Context.AddString("  " + slotDefinition.Id + (SlotLayout.IsEnabled(slotDefinition) ? string.Empty : " (desactivada)") + " @" + val3.x + "," + val3.y + ": " + ((itemAt != null) ? itemAt.m_shared.m_name : "-") + " | puesto: " + ((val4 != null) ? val4.m_shared.m_name : "-") + " | apariencia: " + text + ((itemAt != null && itemAt != val4) ? "  <-- en espera / incoherente" : string.Empty));
						}
						int num2 = 0;
						foreach (ItemData allItem in inventory.GetAllItems())
						{
							if (allItem.m_gridPos.y == num && SlotLayout.SlotAt(allItem.m_gridPos, num) == null)
							{
								num2++;
							}
						}
						args.Context.AddString("Objetos atascados en celdas reservadas: " + num2);
					}
				};
				<>c.<>9__35_0 = val;
				obj = (object)val;
			}
			new ConsoleCommand("vsm_slots_dump", "Estado de las ranuras de equipo (filas, altura, contenido, apariencias)", (ConsoleEvent)obj, false, false, false, false, false, false, (ConsoleOptionsFetcher)null, false, false, false);
			object obj2 = <>c.<>9__35_1;
			if (obj2 == null)
			{
				ConsoleEvent val2 = delegate(ConsoleEventArgs args)
				{
					Player localPlayer = Player.m_localPlayer;
					if ((Object)(object)localPlayer != (Object)null)
					{
						TransmogRuntime.ClearAll(localPlayer);
						args.Context.AddString("Apariencias quitadas.");
					}
				};
				<>c.<>9__35_1 = val2;
				obj2 = (object)val2;
			}
			new ConsoleCommand("vsm_slots_transmog_reset", "Quita todas tus apariencias de transfiguración", (ConsoleEvent)obj2, false, false, false, false, false, false, (ConsoleOptionsFetcher)null, false, false, false);
		}
	}
	public static class MyPluginInfo
	{
		public const string PLUGIN_GUID = "vsm.slots";

		public const string PLUGIN_NAME = "MEL Slots";

		public const string PLUGIN_VERSION = "0.1.4";
	}
}
namespace VSM.Slots.Ui
{
	internal static class EquipmentPanel
	{
		private const string PanelName = "vsm_slots_panel";

		private const float Pad = 12f;

		private const float TitleHeight = 28f;

		private const float LabelHeight = 14f;

		private const float ColumnGap = 10f;

		private const float ButtonHeight = 32f;

		private static RectTransform s_panel;

		private static Button s_transmogButton;

		private static TMP_Text s_title;

		private static readonly Dictionary<string, TMP_Text> s_labels = new Dictionary<string, TMP_Text>();

		private static readonly Color LabelColor = new Color(0.85f, 0.8f, 0.7f, 1f);

		private static readonly Color LabelTransmogColor = new Color(1f, 0.68f, 0.2f, 1f);

		private static readonly Vector3[] s_corners = (Vector3[])(object)new Vector3[4];

		public static bool Built => (Object)(object)s_panel != (Object)null;

		public static void Destroy()
		{
			if ((Object)(object)s_panel != (Object)null)
			{
				Object.Destroy((Object)(object)((Component)s_panel).gameObject);
			}
			s_panel = null;
			s_transmogButton = null;
			s_title = null;
			s_labels.Clear();
		}

		private static float Space(InventoryGrid grid)
		{
			return ((Object)(object)grid != (Object)null && grid.m_elementSpace > 1f) ? grid.m_elementSpace : 70f;
		}

		private static RectTransform Ensure(InventoryGui gui)
		{
			//IL_0101: 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_013f: Unknown result type (might be due to invalid IL or missing references)
			//IL_015e: Unknown result type (might be due to invalid IL or missing references)
			//IL_017d: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)s_panel != (Object)null)
			{
				return s_panel;
			}
			if ((Object)(object)gui == (Object)null || (Object)(object)gui.m_player == (Object)null)
			{
				return null;
			}
			Transform val = ((Transform)gui.m_player).Find("vsm_slots_panel");
			if ((Object)(object)val != (Object)null)
			{
				Object.Destroy((Object)(object)((Component)val).gameObject);
			}
			RectTransform val2 = UiKit.NewRect((Transform)(object)gui.m_player, "vsm_slots_panel");
			UiKit.VanillaBackground((Transform)(object)gui.m_player, val2);
			s_title = (TMP_Text)(object)UiKit.Text((Transform)(object)val2, "vsm_slots_title", VanillaStyle.TitleFont, 22f, (TextAlignmentOptions)514);
			s_title.text = VsmLocalization.Localize("$vsm_slots_title");
			s_title.rectTransform.anchorMin = new Vector2(0f, 1f);
			s_title.rectTransform.anchorMax = new Vector2(1f, 1f);
			s_title.rectTransform.pivot = new Vector2(0.5f, 1f);
			s_title.rectTransform.anchoredPosition = new Vector2(0f, -6f);
			s_title.rectTransform.sizeDelta = new Vector2(-24f, 28f);
			s_transmogButton = UiKit.MakeButton((Transform)(object)val2, VsmLocalization.Localize("$vsm_slots_transmog_button"), delegate
			{
				TransmogPanel.Toggle(gui);
			});
			s_panel = val2;
			return val2;
		}

		public static void Layout(InventoryGui gui, InventoryGrid grid)
		{
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0182: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0238: Unknown result type (might be due to invalid IL or missing references)
			//IL_0240: Unknown result type (might be due to invalid IL or missing references)
			//IL_0254: Unknown result type (might be due to invalid IL or missing references)
			//IL_0265: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a1: Unknown result type (might be due to invalid IL or missing references)
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)gui == (Object)null || (Object)(object)grid == (Object)null || (Object)(object)grid != (Object)(object)gui.m_playerGrid || (Object)(object)localPlayer == (Object)null || !SlotState.HiddenRowActive(((Humanoid)localPlayer).m_inventory, out var visibleRows))
			{
				return;
			}
			RectTransform val = Ensure(gui);
			if ((Object)(object)val == (Object)null)
			{
				return;
			}
			float num = Space(grid);
			float num2 = num + 14f;
			float num3 = 40f;
			float num4 = 3f * num2;
			float num5 = 24f + num * 2f + 10f;
			bool active = TransmogRuntime.Active;
			float num6 = num3 + num4 + (active ? 38f : 0f) + 12f;
			val.sizeDelta = new Vector2(num5, num6);
			Place(gui, val, num5);
			float num7 = 12f;
			float num8 = 12f + num + 10f;
			if ((Object)(object)s_transmogButton != (Object)null)
			{
				((Component)s_transmogButton).gameObject.SetActive(active);
				UiKit.TopLeft(((Component)s_transmogButton).GetComponent<RectTransform>(), 12f, 0f - (num3 + num4 + 2f), num5 - 24f, 32f);
			}
			TransmogData transmogData = (active ? TransmogRuntime.Get(localPlayer) : null);
			Vector2 val2 = default(Vector2);
			for (int i = 0; i < 8; i++)
			{
				InventoryElement element = grid.GetElement(i, visibleRows, 8);
				if ((Object)(object)element == (Object)null)
				{
					continue;
				}
				SlotDefinition slotDefinition = SlotLayout.SlotAt(new Vector2i(i, visibleRows), visibleRows);
				RectTransform elementRectTransform = element.GetElementRectTransform();
				if (slotDefinition == null)
				{
					((Component)element).gameObject.SetActive(false);
					HideLabel(i);
					continue;
				}
				((Component)element).gameObject.SetActive(true);
				if ((Object)(object)((Transform)elementRectTransform).parent != (Object)(object)val)
				{
					((Transform)elementRectTransform).SetParent((Transform)(object)val, false);
				}
				float num9 = ((slotDefinition.Column == 0) ? num7 : num8) + (num - elementRectTransform.sizeDelta.x) * 0.5f;
				float num10 = 0f - (num3 + (float)slotDefinition.Row * num2);
				((Vector2)(ref val2))..ctor(0f, 1f);
				elementRectTransform.anchorMax = val2;
				elementRectTransform.anchorMin = val2;
				elementRectTransform.pivot = new Vector2(0f, 1f);
				elementRectTransform.anchoredPosition = new Vector2(num9, num10);
				Appearance look;
				bool transmog = transmogData?.TryGet(slotDefinition.Id, out look) ?? false;
				PlaceLabel(element, slotDefinition, val, (slotDefinition.Column == 0) ? num7 : num8, num10 - elementRectTransform.sizeDelta.y - 1f, num, transmog);
			}
			grid.m_gridRoot.SetSizeWithCurrentAnchors((Axis)1, (float)visibleRows * num);
		}

		public static void Tick()
		{
			bool inventoryVisible = (Object)(object)s_panel != (Object)null && InventoryGui.IsVisible() && ((Component)s_panel).gameObject.activeInHierarchy;
			TransmogPanel.Tick(inventoryVisible);
		}

		private static void Place(InventoryGui gui, RectTransform panel, float width)
		{
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: 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)
			RectTransform player = gui.m_player;
			float num = Mathf.Abs(SlotsPlugin.PanelGapX.Value) + OverhangRight(gui);
			float num2 = Mathf.Clamp(SlotsPlugin.PanelScale.Value, 0.5f, 2f);
			float num3 = RightPanelsLeftEdge(gui);
			if (!float.IsInfinity(num3))
			{
				Rect rect = player.rect;
				float num4 = num3 - (((Rect)(ref rect)).xMax + num) - 8f;
				if (num4 > 0f && width * num2 > num4)
				{
					num2 = Mathf.Max(0.6f, num4 / width);
				}
			}
			Vector2 val = default(Vector2);
			((Vector2)(ref val))..ctor(1f, 1f);
			panel.anchorMax = val;
			panel.anchorMin = val;
			panel.pivot = new Vector2(0f, 1f);
			((Transform)panel).localScale = new Vector3(num2, num2, 1f);
			panel.anchoredPosition = new Vector2(num, SlotsPlugin.PanelOffsetY.Value);
		}

		private static float RightPanelsLeftEdge(InventoryGui gui)
		{
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			float num = float.PositiveInfinity;
			RectTransform[] array = (RectTransform[])(object)new RectTransform[2] { gui.m_info, gui.m_crafting };
			foreach (RectTransform val in array)
			{
				if (!((Object)(object)val == (Object)null) && ((Component)val).gameObject.activeInHierarchy)
				{
					val.GetWorldCorners(s_corners);
					for (int j = 0; j < 4; j++)
					{
						num = Mathf.Min(num, ((Transform)gui.m_player).InverseTransformPoint(s_corners[j]).x);
					}
				}
			}
			return num;
		}

		private static float OverhangRight(InventoryGui gui)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			RectTransform player = gui.m_player;
			Rect rect = player.rect;
			float xMax = ((Rect)(ref rect)).xMax;
			float num = 0f;
			TMP_Text[] array = (TMP_Text[])(object)new TMP_Text[2] { gui.m_armor, gui.m_weight };
			foreach (TMP_Text val in array)
			{
				if ((Object)(object)val == (Object)null)
				{
					continue;
				}
				Transform val2 = val.transform;
				int num2 = 0;
				while (num2 < 3 && (Object)(object)val2 != (Object)null && (Object)(object)val2 != (Object)(object)player)
				{
					RectTransform val3 = (RectTransform)(object)((val2 is RectTransform) ? val2 : null);
					if (!((Object)(object)val3 == (Object)null))
					{
						val3.GetWorldCorners(s_corners);
						for (int j = 0; j < 4; j++)
						{
							num = Mathf.Max(num, ((Transform)player).InverseTransformPoint(s_corners[j]).x - xMax);
						}
					}
					num2++;
					val2 = val2.parent;
				}
			}
			return Mathf.Clamp(num, 0f, 400f);
		}

		private static void PlaceLabel(InventoryElement element, SlotDefinition slot, RectTransform panel, float x, float y, float width, bool transmog)
		{
			//IL_00b9: 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)
			if (!s_labels.TryGetValue(slot.Id, out var value) || (Object)(object)value == (Object)null)
			{
				value = (TMP_Text)(object)UiKit.Text((Transform)(object)panel, "vsm_slots_label_" + slot.Id, VanillaStyle.BodyFont, 12f, (TextAlignmentOptions)514);
				s_labels[slot.Id] = value;
			}
			bool value2 = SlotsPlugin.ShowSlotLabels.Value;
			((Component)value).gameObject.SetActive(value2);
			if (value2)
			{
				UiKit.TopLeft(value.rectTransform, x, y, width, 14f);
				value.text = VsmLocalization.Localize(slot.NameToken);
				((Graphic)value).color = (transmog ? LabelTransmogColor : LabelColor);
			}
		}

		private static void HideLabel(int order)
		{
			SlotDefinition[] all = SlotLayout.All;
			foreach (SlotDefinition slotDefinition in all)
			{
				if (slotDefinition.Order == order && s_labels.TryGetValue(slotDefinition.Id, out var value) && (Object)(object)value != (Object)null)
				{
					((Component)value).gameObject.SetActive(false);
				}
			}
		}
	}
	internal static class TransmogPanel
	{
		private enum CellKind
		{
			Original,
			Hide,
			Look
		}

		private sealed class CellView
		{
			public InventoryElement Element;

			public CellKind Kind;

			public LookOption Option;
		}

		private const string PanelName = "vsm_slots_transmog";

		private const float Pad = 14f;

		private const float Cell = 64f;

		private const float CellGap = 6f;

		private static RectTransform s_panel;

		private static RectTransform s_content;

		private static TMP_Text s_info;

		private static TMP_Text s_empty;

		private static readonly Dictionary<string, Button> s_tabs = new Dictionary<string, Button>();

		private static readonly List<CellView> s_cells = new List<CellView>();

		private static SlotDefinition s_slot;

		private static string s_signature;

		public static bool IsOpen => (Object)(object)s_panel != (Object)null && ((Component)s_panel).gameObject.activeSelf;

		public static void Toggle(InventoryGui gui)
		{
			if (IsOpen)
			{
				Close();
			}
			else
			{
				Open(gui);
			}
		}

		public static void Close()
		{
			if ((Object)(object)s_panel != (Object)null)
			{
				((Component)s_panel).gameObject.SetActive(false);
			}
		}

		public static void Destroy()
		{
			if ((Object)(object)s_panel != (Object)null)
			{
				Object.Destroy((Object)(object)((Component)s_panel).gameObject);
			}
			s_panel = null;
			s_content = null;
			s_info = null;
			s_empty = null;
			s_tabs.Clear();
			s_cells.Clear();
			s_signature = null;
		}

		private static void Open(InventoryGui gui)
		{
			if (TransmogRuntime.Active && !((Object)(object)Player.m_localPlayer == (Object)null) && Ensure(gui))
			{
				if (s_slot == null || !SlotLayout.IsEnabled(s_slot))
				{
					s_slot = FirstEnabled();
				}
				((Component)s_panel).gameObject.SetActive(true);
				((Transform)s_panel).SetAsLastSibling();
				s_signature = null;
			}
		}

		public static void Tick(bool inventoryVisible)
		{
			if (!IsOpen)
			{
				return;
			}
			Player localPlayer = Player.m_localPlayer;
			if (!inventoryVisible || (Object)(object)localPlayer == (Object)null || !TransmogRuntime.Active)
			{
				Close();
				return;
			}
			if (s_slot == null || !SlotLayout.IsEnabled(s_slot))
			{
				s_slot = FirstEnabled();
				if (s_slot == null)
				{
					Close();
					return;
				}
			}
			ItemData val = s_slot.Equipped((Humanoid)(object)localPlayer);
			localPlayer.m_customData.TryGetValue("vsm.slots.transmog", out var value);
			string text = s_slot.Id + "|" + ((val != null && (Object)(object)val.m_dropPrefab != (Object)null) ? ((Object)val.m_dropPrefab).name : ((val != null) ? val.m_shared.m_name : "-")) + "|" + localPlayer.m_knownMaterial.Count + "|" + value + "|" + SlotsPlugin.TransmogAllowHide.Value + "|" + SlotsPlugin.TransmogRequireKnown.Value;
			if (text != s_signature)
			{
				s_signature = text;
				Rebuild(localPlayer, val);
			}
		}

		private static SlotDefinition FirstEnabled()
		{
			SlotDefinition[] all = SlotLayout.All;
			foreach (SlotDefinition slotDefinition in all)
			{
				if (SlotLayout.IsEnabled(slotDefinition))
				{
					return slotDefinition;
				}
			}
			return null;
		}

		private static bool Ensure(InventoryGui gui)
		{
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: 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_028c: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_02fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0315: Unknown result type (might be due to invalid IL or missing references)
			//IL_033d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0354: Unknown result type (might be due to invalid IL or missing references)
			//IL_0365: Unknown result type (might be due to invalid IL or missing references)
			//IL_036f: Expected O, but got Unknown
			//IL_0465: Unknown result type (might be due to invalid IL or missing references)
			//IL_0484: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)s_panel != (Object)null)
			{
				return true;
			}
			if ((Object)(object)gui == (Object)null || (Object)(object)gui.m_crafting == (Object)null)
			{
				return false;
			}
			Transform val = ((Transform)gui.m_crafting).Find("vsm_slots_transmog");
			if ((Object)(object)val != (Object)null)
			{
				Object.Destroy((Object)(object)((Component)val).gameObject);
			}
			RectTransform val2 = UiKit.NewRect((Transform)(object)gui.m_crafting, "vsm_slots_transmog");
			UiKit.Stretch(val2);
			UiKit.VanillaBackground((Transform)(object)gui.m_crafting, val2);
			Rect rect = gui.m_crafting.rect;
			float width = ((Rect)(ref rect)).width;
			rect = gui.m_crafting.rect;
			float height = ((Rect)(ref rect)).height;
			TMP_Text val3 = (TMP_Text)(object)UiKit.Text((Transform)(object)val2, "title", VanillaStyle.TitleFont, 26f, (TextAlignmentOptions)514);
			val3.text = VsmLocalization.Localize("$vsm_slots_transmog_title");
			UiKit.TopLeft(val3.rectTransform, 14f, -14f, width - 28f, 34f);
			float num = (width - 28f - 20f) / 6f;
			float num2 = 14f;
			SlotDefinition[] all = SlotLayout.All;
			foreach (SlotDefinition slotDefinition in all)
			{
				SlotDefinition captured = slotDefinition;
				Button val4 = UiKit.MakeButton((Transform)(object)val2, VsmLocalization.Localize(slotDefinition.NameToken), delegate
				{
					s_slot = captured;
					s_signature = null;
				});
				UiKit.TopLeft(((Component)val4).GetComponent<RectTransform>(), num2, -54f, num, 34f);
				s_tabs[slotDefinition.Id] = val4;
				num2 += num + 4f;
			}
			s_info = (TMP_Text)(object)UiKit.Text((Transform)(object)val2, "info", VanillaStyle.BodyFont, 16f, (TextAlignmentOptions)514);
			s_info.enableWordWrapping = true;
			UiKit.TopLeft(s_info.rectTransform, 14f, -94f, width - 28f, 44f);
			float num3 = 144f;
			float num4 = 50f;
			RectTransform val5 = UiKit.NewRect((Transform)(object)val2, "viewport");
			UiKit.TopLeft(val5, 14f, 0f - num3, width - 28f, height - num3 - num4 - 14f);
			((Component)val5).gameObject.AddComponent<RectMask2D>();
			Image val6 = ((Component)val5).gameObject.AddComponent<Image>();
			((Graphic)val6).color = new Color(0f, 0f, 0f, 0.25f);
			s_content = UiKit.NewRect((Transform)(object)val5, "content");
			s_content.anchorMin = new Vector2(0f, 1f);
			s_content.anchorMax = new Vector2(1f, 1f);
			s_content.pivot = new Vector2(0.5f, 1f);
			s_content.anchoredPosition = Vector2.zero;
			s_content.sizeDelta = new Vector2(0f, 0f);
			GridLayoutGroup val7 = ((Component)s_content).gameObject.AddComponent<GridLayoutGroup>();
			val7.cellSize = new Vector2(64f, 64f);
			val7.spacing = new Vector2(6f, 6f);
			((LayoutGroup)val7).padding = new RectOffset(8, 8, 8, 8);
			((LayoutGroup)val7).childAlignment = (TextAnchor)1;
			val7.constraint = (Constraint)1;
			val7.constraintCount = Mathf.Max(1, Mathf.FloorToInt((width - 28f - 16f + 6f) / 70f));
			ContentSizeFitter val8 = ((Component)s_content).gameObject.AddComponent<ContentSizeFitter>();
			val8.verticalFit = (FitMode)2;
			ScrollRect val9 = ((Component)val5).gameObject.AddComponent<ScrollRect>();
			val9.content = s_content;
			val9.viewport = val5;
			val9.horizontal = false;
			val9.vertical = true;
			val9.movementType = (MovementType)2;
			val9.scrollSensitivity = 40f;
			s_empty = (TMP_Text)(object)UiKit.Text((Transform)(object)val5, "empty", VanillaStyle.BodyFont, 16f, (TextAlignmentOptions)514);
			s_empty.enableWordWrapping = true;
			UiKit.Stretch(s_empty.rectTransform);
			s_empty.rectTransform.offsetMin = new Vector2(20f, 20f);
			s_empty.rectTransform.offsetMax = new Vector2(-20f, -20f);
			float num5 = (width - 28f - 8f) / 2f;
			Button val10 = UiKit.MakeButton((Transform)(object)val2, VsmLocalization.Localize("$vsm_slots_transmog_reset_all"), delegate
			{
				Player localPlayer = Player.m_localPlayer;
				if ((Object)(object)localPlayer != (Object)null)
				{
					TransmogRuntime.ClearAll(localPlayer);
				}
			});
			UiKit.TopLeft(((Component)val10).GetComponent<RectTransform>(), 14f, 0f - (height - num4), num5, 38f);
			Button val11 = UiKit.MakeButton((Transform)(object)val2, VsmLocalization.Localize("$vsm_slots_close"), Close);
			UiKit.TopLeft(((Component)val11).GetComponent<RectTransform>(), 14f + num5 + 8f, 0f - (height - num4), num5, 38f);
			s_panel = val2;
			((Component)val2).gameObject.SetActive(false);
			return true;
		}

		private static void Rebuild(Player p, ItemData real)
		{
			//IL_0166: Unknown result type (might be due to invalid IL or missing references)
			foreach (KeyValuePair<string, Button> s_tab in s_tabs)
			{
				SlotDefinition slotDefinition = SlotLayout.ById(s_tab.Key);
				((Component)s_tab.Value).gameObject.SetActive(slotDefinition != null && SlotLayout.IsEnabled(slotDefinition));
				((Selectable)s_tab.Value).interactable = slotDefinition != s_slot;
			}
			foreach (CellView s_cell in s_cells)
			{
				if ((Object)(object)s_cell.Element != (Object)null)
				{
					Object.Destroy((Object)(object)((Component)s_cell.Element).gameObject);
				}
			}
			s_cells.Clear();
			string text = VsmLocalization.Localize(s_slot.NameToken);
			s_info.text = ((real != null) ? VsmLocalization.Localize("$vsm_slots_transmog_wearing", text, VsmLocalization.Localize(real.m_shared.m_name)) : VsmLocalization.Localize("$vsm_slots_transmog_nothing", text));
			TransmogData transmogData = TransmogRuntime.Get(p);
			Appearance look;
			bool flag = transmogData.TryGet(s_slot.Id, out look);
			List<LookOption> list = TransmogCatalog.For(s_slot.Type, SlotsPlugin.TransmogRequireKnown.Value ? p : null);
			((Component)s_empty).gameObject.SetActive(list.Count == 0);
			s_empty.text = VsmLocalization.Localize("$vsm_slots_transmog_none_known", text);
			if (list.Count == 0 && !flag)
			{
				return;
			}
			AddCell(CellKind.Original, null, (real != null) ? real.GetIcon() : null, !flag, VsmLocalization.Localize("$vsm_slots_transmog_original"), VsmLocalization.Localize("$vsm_slots_transmog_original_tip"));
			if (SlotsPlugin.TransmogAllowHide.Value)
			{
				AddCell(CellKind.Hide, null, null, flag && look.Hidden, VsmLocalization.Localize("$vsm_slots_transmog_hide"), VsmLocalization.Localize("$vsm_slots_transmog_hide_tip"));
			}
			foreach (LookOption item in list)
			{
				bool selected = flag && !look.Hidden && look.Prefab == item.Prefab && look.Variant == item.Variant;
				string text2 = VsmLocalization.Localize(item.Shared.m_name);
				if (item.Shared.m_variants > 1)
				{
					text2 = text2 + " (" + (item.Variant + 1) + ")";
				}
				AddCell(CellKind.Look, item, item.Icon, selected, null, text2);
			}
		}

		private static void AddCell(CellKind kind, LookOption option, Sprite icon, bool selected, string caption, string tooltip)
		{
			//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_023f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0249: Expected O, but got Unknown
			//IL_0258: Unknown result type (might be due to invalid IL or missing references)
			//IL_0262: Expected O, but got Unknown
			//IL_0217: Unknown result type (might be due to invalid IL or missing references)
			//IL_021d: Unknown result type (might be due to invalid IL or missing references)
			InventoryGui instance = InventoryGui.instance;
			GameObject val = (((Object)(object)instance != (Object)null && (Object)(object)instance.m_playerGrid != (Object)null) ? instance.m_playerGrid.m_elementPrefab : null);
			if ((Object)(object)val == (Object)null)
			{
				return;
			}
			GameObject val2 = Object.Instantiate<GameObject>(val, (Transform)(object)s_content, false);
			((Object)val2).name = "vsm_look";
			InventoryElement component = val2.GetComponent<InventoryElement>();
			if ((Object)(object)component == (Object)null)
			{
				Object.Destroy((Object)(object)val2);
				return;
			}
			component.Initialize(-1, -1);
			((Behaviour)component.m_icon).enabled = (Object)(object)icon != (Object)null;
			component.m_icon.sprite = icon;
			((Graphic)component.m_icon).color = (Color)((kind == CellKind.Original) ? new Color(1f, 1f, 1f, 0.55f) : Color.white);
			((Behaviour)component.m_amount).enabled = false;
			((Behaviour)component.m_quality).enabled = false;
			((Behaviour)component.m_queued).enabled = false;
			((Behaviour)component.m_noteleport).enabled = false;
			((Behaviour)component.m_food).enabled = false;
			((Component)component.m_durability).gameObject.SetActive(false);
			component.m_selected.SetActive(false);
			((Behaviour)component.m_equiped).enabled = selected;
			Transform val3 = val2.transform.Find("binding");
			if ((Object)(object)val3 != (Object)null)
			{
				((Component)val3).gameObject.SetActive(false);
			}
			if (!string.IsNullOrEmpty(caption))
			{
				TMP_Text val4 = (TMP_Text)(object)UiKit.Text(val2.transform, "caption", VanillaStyle.BodyFont, 13f, (TextAlignmentOptions)514);
				UiKit.Stretch(val4.rectTransform);
				val4.enableWordWrapping = true;
				val4.text = caption;
			}
			if ((Object)(object)component.m_tooltip != (Object)null)
			{
				component.m_tooltip.Set(tooltip ?? string.Empty, string.Empty, (RectTransform)null, default(Vector2));
			}
			Button component2 = val2.GetComponent<Button>();
			if ((Object)(object)component2 != (Object)null)
			{
				component2.onClick = new ButtonClickedEvent();
				((UnityEvent)component2.onClick).AddListener((UnityAction)delegate
				{
					OnCellClicked(kind, option);
				});
			}
			s_cells.Add(new CellView
			{
				Element = component,
				Kind = kind,
				Option = option
			});
		}

		private static void OnCellClicked(CellKind kind, LookOption option)
		{
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null || s_slot == null)
			{
				return;
			}
			switch (kind)
			{
			case CellKind.Original:
				TransmogRuntime.Clear(localPlayer, s_slot);
				break;
			case CellKind.Hide:
				TransmogRuntime.Set(localPlayer, s_slot, Appearance.HiddenLook);
				break;
			default:
				if (option != null)
				{
					TransmogRuntime.Set(localPlayer, s_slot, new Appearance
					{
						Prefab = option.Prefab,
						Variant = option.Variant
					});
				}
				break;
			}
			if (s_slot.Equipped((Humanoid)(object)localPlayer) == null)
			{
				SlotsPlugin.Message(localPlayer, "$vsm_slots_transmog_saved_empty", s_slot.NameToken);
			}
			s_signature = null;
		}
	}
	internal static class UiKit
	{
		public static RectTransform CloneChild(Transform vanillaPanel, string childName, RectTransform parent)
		{
			Transform val = (((Object)(object)vanillaPanel != (Object)null) ? vanillaPanel.Find(childName) : null);
			if ((Object)(object)val == (Object)null)
			{
				return null;
			}
			GameObject val2 = Object.Instantiate<GameObject>(((Component)val).gameObject, (Transform)(object)parent, false);
			((Object)val2).name = "vsm_" + childName;
			for (int num = val2.transform.childCount - 1; num >= 0; num--)
			{
				Object.Destroy((Object)(object)((Component)val2.transform.GetChild(num)).gameObject);
			}
			MonoBehaviour[] components = val2.GetComponents<MonoBehaviour>();
			foreach (MonoBehaviour val3 in components)
			{
				if (!(val3 is Graphic))
				{
					Object.Destroy((Object)(object)val3);
				}
			}
			val2.SetActive(true);
			Transform transform = val2.transform;
			return (RectTransform)(object)((transform is RectTransform) ? transform : null);
		}

		public static void VanillaBackground(Transform vanillaPanel, RectTransform panel)
		{
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			RectTransform val = CloneChild(vanillaPanel, "Darken", panel);
			RectTransform val2 = CloneChild(vanillaPanel, "Bkg", panel);
			if ((Object)(object)val2 != (Object)null)
			{
				((Transform)val2).SetAsFirstSibling();
				Image component = ((Component)val2).GetComponent<Image>();
				if ((Object)(object)component != (Object)null)
				{
					((Graphic)component).raycastTarget = true;
				}
			}
			else
			{
				Image val3 = ((Component)panel).gameObject.AddComponent<Image>();
				((Graphic)val3).color = new Color(0.1f, 0.08f, 0.06f, 0.92f);
			}
			if ((Object)(object)val != (Object)null)
			{
				((Transform)val).SetAsFirstSibling();
				Image component2 = ((Component)val).GetComponent<Image>();
				if ((Object)(object)component2 != (Object)null)
				{
					((Graphic)component2).raycastTarget = false;
				}
			}
		}

		public static Button MakeButton(Transform parent, string label, Action onClick)
		{
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Expected O, but got Unknown
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_010e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0118: Expected O, but got Unknown
			//IL_0126: Unknown result type (might be due to invalid IL or missing references)
			//IL_0130: Expected O, but got Unknown
			Button val = (((Object)(object)InventoryGui.instance != (Object)null) ? InventoryGui.instance.m_craftButton : null);
			GameObject val2;
			if ((Object)(object)val != (Object)null)
			{
				val2 = Object.Instantiate<GameObject>(((Component)val).gameObject, parent, false);
				UIGamePad[] componentsInChildren = val2.GetComponentsInChildren<UIGamePad>(true);
				foreach (UIGamePad val3 in componentsInChildren)
				{
					if ((Object)(object)val3.m_hint != (Object)null)
					{
						Object.Destroy((Object)(object)val3.m_hint);
					}
					Object.Destroy((Object)(object)val3);
				}
			}
			else
			{
				val2 = new GameObject("button", new Type[1] { typeof(RectTransform) });
				val2.transform.SetParent(parent, false);
				((Graphic)val2.AddComponent<Image>()).color = new Color(0.2f, 0.15f, 0.1f, 0.9f);
				val2.AddComponent<Button>();
			}
			((Object)val2).name = "vsm_slots_btn";
			val2.SetActive(true);
			Button component = val2.GetComponent<Button>();
			component.onClick = new ButtonClickedEvent();
			((UnityEvent)component.onClick).AddListener((UnityAction)delegate
			{
				onClick();
			});
			((Selectable)component).interactable = true;
			TMP_Text val4 = val2.GetComponentInChildren<TMP_Text>(true);
			if ((Object)(object)val4 == (Object)null)
			{
				val4 = (TMP_Text)(object)VanillaStyle.NewText(val2.transform, "label", VanillaStyle.BodyFont, 16f, (TextAlignmentOptions)514);
				Stretch(val4.rectTransform);
			}
			val4.text = label;
			val4.enableAutoSizing = true;
			val4.fontSizeMin = 10f;
			val4.fontSizeMax = 18f;
			((Component)val4).gameObject.SetActive(true);
			return component;
		}

		public static void SetLabel(Button b, string label)
		{
			TMP_Text val = (((Object)(object)b != (Object)null) ? ((Component)b).GetComponentInChildren<TMP_Text>(true) : null);
			if ((Object)(object)val != (Object)null)
			{
				val.text = label;
			}
		}

		public static TextMeshProUGUI Text(Transform parent, string name, TMP_Text style, float size, TextAlignmentOptions align)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			TextMeshProUGUI val = VanillaStyle.NewText(parent, name, style, size, align);
			((TMP_Text)val).enableAutoSizing = true;
			((TMP_Text)val).fontSizeMin = Mathf.Max(8f, size - 6f);
			((TMP_Text)val).fontSizeMax = size;
			((TMP_Text)val).overflowMode = (TextOverflowModes)1;
			return val;
		}

		public static RectTransform NewRect(Transform parent, string name)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Expected O, but got Unknown
			GameObject val = new GameObject(name, new Type[1] { typeof(RectTransform) });
			val.transform.SetParent(parent, false);
			return val.GetComponent<RectTransform>();
		}

		public static void TopLeft(RectTransform rt, float x, float y, float w, float h)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			Vector2 val = default(Vector2);
			((Vector2)(ref val))..ctor(0f, 1f);
			rt.anchorMax = val;
			rt.anchorMin = val;
			rt.pivot = new Vector2(0f, 1f);
			rt.anchoredPosition = new Vector2(x, y);
			rt.sizeDelta = new Vector2(w, h);
		}

		public static void Stretch(RectTransform rt)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			rt.anchorMin = Vector2.zero;
			rt.anchorMax = Vector2.one;
			Vector2 offsetMin = (rt.offsetMax = Vector2.zero);
			rt.offsetMin = offsetMin;
		}
	}
	internal static class UiPatches
	{
		[HarmonyPatch(typeof(InventoryGrid), "UpdateGui")]
		internal static class GridLayoutPatch
		{
			[HarmonyPostfix]
			private static void Postfix(InventoryGrid __instance)
			{
				InventoryGui instance = InventoryGui.instance;
				if ((Object)(object)instance == (Object)null || (Object)(object)__instance != (Object)(object)instance.m_playerGrid)
				{
					return;
				}
				try
				{
					EquipmentPanel.Layout(instance, __instance);
				}
				catch (Exception ex)
				{
					SlotsPlugin.LogOnce("layout", "vsm.slots: panel de equipo: " + ex);
				}
			}
		}

		[HarmonyPatch(typeof(InventoryGui), "Hide")]
		internal static class HidePatch
		{
			[HarmonyPostfix]
			private static void Postfix()
			{
				TransmogPanel.Close();
			}
		}

		[HarmonyPatch(typeof(InventoryGui), "OnDestroy")]
		internal static class DestroyPatch
		{
			[HarmonyPrefix]
			private static void Prefix()
			{
				TransmogPanel.Destroy();
				EquipmentPanel.Destroy();
			}
		}

		public static readonly Type[] Classes = new Type[3]
		{
			typeof(GridLayoutPatch),
			typeof(HidePatch),
			typeof(DestroyPatch)
		};
	}
}
namespace VSM.Slots.Transmog
{
	internal sealed class LookOption
	{
		public string Prefab;

		public int Variant;

		public SharedData Shared;

		public Sprite Icon
		{
			get
			{
				Sprite[] icons = Shared.m_icons;
				if (icons == null || icons.Length == 0)
				{
					return null;
				}
				return icons[Mathf.Clamp(Variant, 0, icons.Length - 1)];
			}
		}
	}
	internal static class TransmogCatalog
	{
		private static ObjectDB s_builtFor;

		private static int s_builtCount = -1;

		private static readonly Dictionary<ItemType, List<LookOption>> s_byType = new Dictionary<ItemType, List<LookOption>>();

		private static readonly Dictionary<string, ItemDrop> s_byPrefab = new Dictionary<string, ItemDrop>(StringComparer.Ordinal);

		private static readonly string[] ExcludedPrefixes = new string[3] { "FW_", "SP_", "CapeTest" };

		public static List<LookOption> For(ItemType type, Player knownBy)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			Ensure();
			List<LookOption> list = new List<LookOption>();
			if (!s_byType.TryGetValue(type, out var value))
			{
				return list;
			}
			foreach (LookOption item in value)
			{
				if ((Object)(object)knownBy == (Object)null || knownBy.IsMaterialKnown(item.Shared.m_name))
				{
					list.Add(item);
				}
			}
			return list;
		}

		public static ItemDrop Lookup(string prefab, ItemType type)
		{
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			Ensure();
			if (string.IsNullOrEmpty(prefab) || !s_byPrefab.TryGetValue(prefab, out var value) || (Object)(object)value == (Object)null)
			{
				return null;
			}
			return (value.m_itemData.m_shared.m_itemType == type) ? value : null;
		}

		public static void Invalidate()
		{
			s_builtFor = null;
			s_builtCount = -1;
		}

		private static void Ensure()
		{
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0139: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_021d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0224: Invalid comparison between Unknown and I4
			//IL_020d: Unknown result type (might be due to invalid IL or missing references)
			ObjectDB instance = ObjectDB.instance;
			if ((Object)(object)instance == (Object)null)
			{
				s_byType.Clear();
				s_byPrefab.Clear();
			}
			else
			{
				if ((Object)(object)instance == (Object)(object)s_builtFor && instance.m_items.Count == s_builtCount)
				{
					return;
				}
				s_byType.Clear();
				s_byPrefab.Clear();
				HashSet<string> hashSet = new HashSet<string>(StringComparer.Ordinal);
				foreach (GameObject item in instance.m_items)
				{
					if ((Object)(object)item == (Object)null)
					{
						continue;
					}
					ItemDrop component = item.GetComponent<ItemDrop>();
					if ((Object)(object)component == (Object)null || component.m_itemData == null || component.m_itemData.m_shared == null)
					{
						continue;
					}
					SharedData shared = component.m_itemData.m_shared;
					if (SlotLayout.ForType(shared.m_itemType) != null && !IsExcluded(((Object)item).name) && shared.m_icons != null && shared.m_icons.Length != 0 && HasBodyVisual(item.transform, shared.m_itemType) && (string.IsNullOrEmpty(shared.m_dlc) || (!((Object)(object)DLCMan.instance == (Object)null) && DLCMan.instance.IsDLCInstalled(shared.m_dlc))) && hashSet.Add(((object)Unsafe.As<ItemType, ItemType>(ref shared.m_itemType)/*cast due to .constrained prefix*/).ToString() + "|" + shared.m_name))
					{
						s_byPrefab[((Object)item).name] = component;
						if (!s_byType.TryGetValue(shared.m_itemType, out var value))
						{
							value = new List<LookOption>();
							s_byType[shared.m_itemType] = value;
						}
						int num = (((int)shared.m_itemType != 17) ? 1 : Mathf.Max(1, Mathf.Min(shared.m_variants, shared.m_icons.Length)));
						for (int i = 0; i < num; i++)
						{
							value.Add(new LookOption
							{
								Prefab = ((Object)item).name,
								Variant = i,
								Shared = shared
							});
						}
					}
				}
				foreach (List<LookOption> value2 in s_byType.Values)
				{
					value2.Sort(Compare);
				}
				s_builtFor = instance;
				s_builtCount = instance.m_items.Count;
			}
		}

		private static int Compare(LookOption a, LookOption b)
		{
			int num = string.Compare(Localized(a.Shared.m_name), Localized(b.Shared.m_name), StringComparison.CurrentCultureIgnoreCase);
			return (num != 0) ? num : a.Variant.CompareTo(b.Variant);
		}

		private static string Localized(string token)
		{
			return (Localization.instance != null) ? Localization.instance.Localize(token) : token;
		}

		private static bool IsExcluded(string prefab)
		{
			string[] excludedPrefixes = ExcludedPrefixes;
			foreach (string value in excludedPrefixes)
			{
				if (prefab.StartsWith(value, StringComparison.Ordinal))
				{
					return true;
				}
			}
			return false;
		}

		private static bool HasBodyVisual(Transform root, ItemType type)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Invalid comparison between Unknown and I4
			for (int i = 0; i < root.childCount; i++)
			{
				string name = ((Object)root.GetChild(i)).name;
				if (name.StartsWith("attach_", StringComparison.Ordinal) || ((int)type == 6 && name == "attach"))
				{
					return true;
				}
			}
			return false;
		}
	}
	public struct Appearance
	{
		public string Prefab;

		public int Variant;

		public bool Hidden;

		public static Appearance HiddenLook => new Appearance
		{
			Hidden = true
		};

		public bool IsSet => Hidden || !string.IsNullOrEmpty(Prefab);
	}
	public sealed class TransmogData
	{
		public const string Key = "vsm.slots.transmog";

		private const int MaxNameLength = 80;

		private readonly Dictionary<string, Appearance> _slots = new Dictionary<string, Appearance>(StringComparer.OrdinalIgnoreCase);

		public int Count => _slots.Count;

		public bool TryGet(string slotId, out Appearance look)
		{
			return _slots.TryGetValue(slotId ?? string.Empty, out look);
		}

		public void Set(string slotId, Appearance look)
		{
			if (!string.IsNullOrEmpty(slotId))
			{
				if (!look.IsSet)
				{
					_slots.Remove(slotId);
				}
				else if (look.Hidden || IsSafeName(look.Prefab))
				{
					look.Variant = Math.Max(0, Math.Min(31, look.Variant));
					_slots[slotId] = look;
				}
			}
		}

		public void Clear(string slotId)
		{
			_slots.Remove(slotId ?? string.Empty);
		}

		public void ClearAll()
		{
			_slots.Clear();
		}

		public static bool IsSafeName(string name)
		{
			if (string.IsNullOrEmpty(name) || name.Length > 80)
			{
				return false;
			}
			foreach (char c in name)
			{
				if (!char.IsLetterOrDigit(c) && c != '_' && c != '-' && c != '(' && c != ')' && c != '.')
				{
					return false;
				}
			}
			return name != "-";
		}

		public string Serialize()
		{
			StringBuilder stringBuilder = new StringBuilder();
			List<string> list = new List<string>(_slots.Keys);
			list.Sort(StringComparer.OrdinalIgnoreCase);
			foreach (string item in list)
			{
				Appearance appearance = _slots[item];
				if (stringBuilder.Length > 0)
				{
					stringBuilder.Append(';');
				}
				stringBuilder.Append(item.ToLowerInvariant()).Append('=');
				if (appearance.Hidden)
				{
					stringBuilder.Append('-');
					continue;
				}
				stringBuilder.Append(appearance.Prefab);
				if (appearance.Variant > 0)
				{
					stringBuilder.Append(':').Append(appearance.Variant);
				}
			}
			return stringBuilder.ToString();
		}

		public static TransmogData Parse(string text, ICollection<string> knownSlots)
		{
			TransmogData transmogData = new TransmogData();
			if (string.IsNullOrEmpty(text))
			{
				return transmogData;
			}
			string[] array = text.Split(new char[1] { ';' });
			foreach (string text2 in array)
			{
				int num = text2.IndexOf('=');
				if (num <= 0)
				{
					continue;
				}
				string text3 = text2.Substring(0, num).Trim();
				string text4 = text2.Substring(num + 1).Trim();
				if (knownSlots != null && !Contains(knownSlots, text3))
				{
					continue;
				}
				if (text4 == "-")
				{
					transmogData.Set(text3, Appearance.HiddenLook);
					continue;
				}
				int result = 0;
				int num2 = text4.LastIndexOf(':');
				if (num2 > 0)
				{
					int.TryParse(text4.Substring(num2 + 1), out result);
					text4 = text4.Substring(0, num2);
				}
				transmogData.Set(text3, new Appearance
				{
					Prefab = text4,
					Variant = result
				});
			}
			return transmogData;
		}

		private static bool Contains(ICollection<string> set, string key)
		{
			foreach (string item in set)
			{
				if (string.Equals(item, key, StringComparison.OrdinalIgnoreCase))
				{
					return true;
				}
			}
			return false;
		}
	}
	internal static class TransmogRuntime
	{
		[HarmonyPatch(typeof(Humanoid), "SetupVisEquipment", new Type[]
		{
			typeof(VisEquipment),
			typeof(bool)
		})]
		internal static class ApplyPatch
		{
			[HarmonyPostfix]
			private static void Postfix(Humanoid __instance, VisEquipment visEq, bool isRagdoll)
			{
				Player val = (Player)(object)((__instance is Player) ? __instance : null);
				if ((Object)(object)val == (Object)null || (Object)(object)val != (Object)(object)Player.m_localPlayer || (Object)(object)visEq == (Object)null || val.m_isLoading || !Active)
				{
					return;
				}
				try
				{
					Apply(val, visEq);
				}
				catch (Exception ex)
				{
					SlotsPlugin.Log.LogError((object)("vsm.slots: transfiguración: " + ex.Message));
				}
			}
		}

		private static Player s_cachedFor;

		private static string s_cachedRaw;

		private static TransmogData s_cached;

		private static readonly List<string> s_slotIds = new List<string>();

		public static bool Active => SlotsPlugin.TransmogEnabled != null && SlotsPlugin.TransmogEnabled.Value && SlotsPlugin.IsConfigReady;

		private static ICollection<string> SlotIds
		{
			get
			{
				if (s_slotIds.Count == 0)
				{
					SlotDefinition[] all = SlotLayout.All;
					foreach (SlotDefinition slotDefinition in all)
					{
						s_slotIds.Add(slotDefinition.Id);
					}
				}
				return s_slotIds;
			}
		}

		public static TransmogData Get(Player p)
		{
			p.m_customData.TryGetValue("vsm.slots.transmog", out var value);
			if ((Object)(object)p != (Object)(object)s_cachedFor || !string.Equals(value, s_cachedRaw, StringComparison.Ordinal) || s_cached == null)
			{
				s_cached = TransmogData.Parse(value, SlotIds);
				s_cachedRaw = value;
				s_cachedFor = p;
			}
			return s_cached;
		}

		public static void Set(Player p, SlotDefinition slot, Appearance look)
		{
			TransmogData transmogData = Get(p);
			transmogData.Set(slot.Id, look);
			Store(p, transmogData);
		}

		public static void Clear(Player p, SlotDefinition slot)
		{
			TransmogData transmogData = Get(p);
			transmogData.Clear(slot.Id);
			Store(p, transmogData);
		}

		public static void ClearAll(Player p)
		{
			TransmogData transmogData = Get(p);
			transmogData.ClearAll();
			Store(p, transmogData);
		}

		private static void Store(Player p, TransmogData data)
		{
			string text = data.Serialize();
			if (text.Length == 0)
			{
				p.m_customData.Remove("vsm.slots.transmog");
			}
			else
			{
				p.m_customData["vsm.slots.transmog"] = text;
			}
			s_cachedFor = null;
			Refresh(p);
		}

		public static void Refresh(Player p)
		{
			if ((Object)(object)p != (Object)null && (Object)(object)((Humanoid)p).m_visEquipment != (Object)null && !p.m_isLoading)
			{
				((Humanoid)p).SetupVisEquipment(((Humanoid)p).m_visEquipment, false);
			}
		}

		public static bool TryResolve(Player p, SlotDefinition slot, out Appearance look, out ItemDrop drop)
		{
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			look = default(Appearance);
			drop = null;
			if (!Active || !SlotLayout.IsEnabled(slot) || slot.Equipped((Humanoid)(object)p) == null || !Get(p).TryGet(slot.Id, out look))
			{
				return false;
			}
			if (look.Hidden)
			{
				return SlotsPlugin.TransmogAllowHide.Value;
			}
			drop = TransmogCatalog.Lookup(look.Prefab, slot.Type);
			if ((Object)(object)drop == (Object)null)
			{
				return false;
			}
			if (SlotsPlugin.TransmogRequireKnown.Value && !p.IsMaterialKnown(drop.m_itemData.m_shared.m_name))
			{
				return false;
			}
			return true;
		}

		private static void Apply(Player p, VisEquipment visEq)
		{
			//IL_004d: 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_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Invalid comparison between Unknown and I4
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Invalid comparison between Unknown and I4
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Invalid comparison between Unknown and I4
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Invalid comparison between Unknown and I4
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Invalid comparison between Unknown and I4
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Invalid comparison between Unknown and I4
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Invalid comparison between Unknown and I4
			SlotDefinition[] all = SlotLayout.All;
			foreach (SlotDefinition slotDefinition in all)
			{
				if (!TryResolve(p, slotDefinition, out var look, out var drop))
				{
					continue;
				}
				int num = ((!look.Hidden) ? StringExtensionMethods.GetStableHashCode(((Object)((Component)drop).gameObject).name) : 0);
				ItemType type = slotDefinition.Type;
				ItemType val = type;
				if ((int)val <= 11)
				{
					if ((int)val != 6)
					{
						if ((int)val != 7)
						{
							if ((int)val == 11)
							{
								visEq.SetLegItem(num);
							}
						}
						else
						{
							visEq.SetChestItem(num);
						}
					}
					else
					{
						visEq.SetHelmetItem(num);
					}
				}
				else if ((int)val != 17)
				{
					if ((int)val != 18)
					{
						if ((int)val == 24)
						{
							visEq.SetTrinketItem(look.Hidden ? string.Empty : ((Object)((Component)drop).gameObject).name);
						}
					}
					else
					{
						visEq.SetUtilityItem(num);
					}
				}
				else
				{
					int num2 = (look.Hidden ? 1 : Math.Max(1, drop.m_itemData.m_shared.m_variants));
					int num3 = ((!look.Hidden) ? Math.Max(0, Math.Min(num2 - 1, look.Variant)) : 0);
					visEq.SetShoulderItem(num, num3, (((Humanoid)p).m_shoulderItem != null) ? ((Humanoid)p).m_shoulderItem.m_quality : 0);
				}
			}
		}
	}
}
namespace VSM.Slots.Runtime
{
	[HarmonyPatch(typeof(InventoryGui), "OnSelectedItem")]
	internal static class DragResolver
	{
		[HarmonyPrefix]
		[HarmonyPriority(600)]
		private static bool Prefix(InventoryGui __instance, InventoryGrid grid, Vector2i pos)
		{
			//IL_018c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0191: Unknown result type (might be due to invalid IL or missing references)
			//IL_019f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: 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_0117: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)__instance.m_dragGo == (Object)null || (Object)(object)grid == (Object)null)
			{
				return true;
			}
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null || ((Character)localPlayer).IsTeleporting())
			{
				return true;
			}
			Inventory inventory = ((Humanoid)localPlayer).m_inventory;
			if (!SlotState.HiddenRowActive(inventory, out var visibleRows))
			{
				return true;
			}
			ItemData dragItem = __instance.m_dragItem;
			Inventory dragInventory = __instance.m_dragInventory;
			if (dragItem == null || dragInventory == null)
			{
				return true;
			}
			Inventory inventory2 = grid.GetInventory();
			bool flag = inventory2 == inventory && pos.y == visibleRows;
			bool flag2 = dragInventory == inventory && dragItem.m_gridPos.y == visibleRows;
			if (!flag && !flag2)
			{
				return true;
			}
			if (!dragInventory.ContainsItem(dragItem))
			{
				__instance.SetupDragItem((ItemData)null, (Inventory)null, 1);
				return false;
			}
			bool flag3;
			try
			{
				flag3 = (flag ? IntoSlot(localPlayer, inventory, visibleRows, dragInventory, dragItem, pos) : OutOfSlot(localPlayer, inventory, visibleRows, inventory2, dragItem, pos));
			}
			catch (Exception ex)
			{
				SlotsPlugin.Log.LogError((object)("vsm.slots: error al mover " + dragItem.m_shared.m_name + ": " + ex));
				flag3 = false;
			}
			finally
			{
				SlotState.Internal = false;
			}
			if (flag3)
			{
				__instance.m_moveItemEffects.Create(((Component)__instance).transform.position, Quaternion.identity, (Transform)null, 1f, -1, default(ZDOID));
				__instance.SetupDragItem((ItemData)null, (Inventory)null, 1);
				__instance.UpdateCraftingPanel(false);
			}
			return false;
		}

		private static bool IntoSlot(Player p, Inventory pinv, int v, Inventory from, ItemData drag, Vector2i pos)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_0170: Unknown result type (might be due to invalid IL or missing references)
			//IL_0174: 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_0127: Unknown result type (might be due to invalid IL or missing references)
			//IL_014d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0154: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			SlotDefinition slotDefinition = SlotLayout.SlotAt(pos, v);
			if (from == pinv && drag.m_gridPos.x == pos.x && drag.m_gridPos.y == pos.y)
			{
				return true;
			}
			if (slotDefinition == null)
			{
				return false;
			}
			if (!slotDefinition.Accepts(drag))
			{
				SlotsPlugin.Message(p, "$vsm_slots_wrong_type", slotDefinition.NameToken);
				return false;
			}
			ItemData itemAt = pinv.GetItemAt(pos.x, pos.y);
			if (from == pinv)
			{
				if (drag.m_gridPos.y == v)
				{
					return false;
				}
				if (itemAt == null)
				{
					Placement.Move(pinv, drag, pos);
				}
				else
				{
					((Humanoid)p).RemoveEquipAction(itemAt);
					Placement.Swap(pinv, drag, itemAt);
				}
				Equip(p, drag);
				return true;
			}
			if (itemAt == null)
			{
				SlotState.Internal = true;
				bool flag = pinv.MoveItemToThis(from, drag, drag.m_stack, pos.x, pos.y);
				SlotState.Internal = false;
				if (!flag)
				{
					return false;
				}
				Equip(p, pinv.GetItemAt(pos.x, pos.y));
				return true;
			}
			return CrossSwap(p, pinv, from, itemAt, drag, pos, drag.m_gridPos);
		}

		private static bool OutOfSlot(Player p, Inventory pinv, int v, Inventory to, ItemData drag, Vector2i pos)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_0183: Unknown result type (might be due to invalid IL or missing references)
			//IL_0188: Unknown result type (might be due to invalid IL or missing references)
			//IL_0145: Unknown result type (might be due to invalid IL or missing references)
			//IL_014c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			SlotDefinition slotDefinition = SlotLayout.SlotAt(drag.m_gridPos, v);
			ItemData itemAt = to.GetItemAt(pos.x, pos.y);
			if (itemAt != null && (slotDefinition == null || !slotDefinition.Accepts(itemAt)))
			{
				SlotsPlugin.Message(p, "$vsm_slots_swap_blocked", itemAt.m_shared.m_name, (slotDefinition != null) ? slotDefinition.NameToken : "?");
				return false;
			}
			if (to == pinv)
			{
				if (pos.y >= v || pos.x < 0 || pos.x >= pinv.m_width)
				{
					return false;
				}
				if (itemAt == null)
				{
					((Humanoid)p).RemoveEquipAction(drag);
					((Humanoid)p).UnequipItem(drag, false);
					Placement.Move(pinv, drag, pos);
				}
				else
				{
					((Humanoid)p).RemoveEquipAction(drag);
					((Humanoid)p).RemoveEquipAction(itemAt);
					Placement.Swap(pinv, drag, itemAt);
					Equip(p, itemAt);
				}
				return true;
			}
			if (itemAt == null)
			{
				bool equipped = drag.m_equipped;
				((Humanoid)p).RemoveEquipAction(drag);
				((Humanoid)p).UnequipItem(drag, false);
				if (to.MoveItemToThis(pinv, drag, drag.m_stack, pos.x, pos.y))
				{
					return true;
				}
				if (equipped)
				{
					((Humanoid)p).EquipItem(drag, false);
				}
				return false;
			}
			return CrossSwap(p, pinv, to, drag, itemAt, drag.m_gridPos, pos);
		}

		private static bool CrossSwap(Player p, Inventory pinv, Inventory chest, ItemData leaving, ItemData entering, Vector2i slotPos, Vector2i chestPos)
		{
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			bool equipped = leaving.m_equipped;
			((Humanoid)p).RemoveEquipAction(leaving);
			((Humanoid)p).UnequipItem(leaving, false);
			if (!chest.RemoveItem(entering))
			{
				Restore(p, leaving, equipped);
				return false;
			}
			if (!chest.MoveItemToThis(pinv, leaving, leaving.m_stack, chestPos.x, chestPos.y))
			{
				PutBack(p, chest, entering, chestPos);
				Restore(p, leaving, equipped);
				return false;
			}
			SlotState.Internal = true;
			bool flag = pinv.AddItem(entering, entering.m_stack, slotPos.x, slotPos.y, false);
			SlotState.Internal = false;
			if (!flag)
			{
				SlotsPlugin.Log.LogWarning((object)("vsm.slots: no se pudo poner " + entering.m_shared.m_name + " en la ranura; se devuelve."));
				PutBack(p, chest, entering, new Vector2i(-1, -1));
				return true;
			}
			Equip(p, pinv.GetItemAt(slotPos.x, slotPos.y));
			return true;
		}

		private static void Restore(Player p, ItemData item, bool wasEquipped)
		{
			if (wasEquipped && ((Humanoid)p).m_inventory.ContainsItem(item))
			{
				((Humanoid)p).EquipItem(item, false);
			}
		}

		private static void PutBack(Player p, Inventory chest, ItemData item, Vector2i cell)
		{
			//IL_0017: 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_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: 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_00bd: Unknown result type (might be due to invalid IL or missing references)
			if (item.m_stack > 0 && (cell.x < 0 || !chest.AddItem(item, item.m_stack, cell.x, cell.y, false)) && !chest.AddItem(item) && !((Humanoid)p).m_inventory.AddItem(item))
			{
				SlotsPlugin.Log.LogWarning((object)("vsm.slots: " + item.m_shared.m_name + " no cabía en ningún sitio; se deja en el suelo."));
				ItemDrop.DropItem(item, item.m_stack, ((Component)p).transform.position + ((Component)p).transform.forward + Vector3.up, ((Component)p).transform.rotation);
			}
		}

		internal static void Equip(Player p, ItemData item)
		{
			if (item != null && !((Humanoid)p).IsItemEquiped(item))
			{
				if (item.m_shared.m_equipDuration <= 0f)
				{
					((Humanoid)p).EquipItem(item, true);
				}
				else if (!p.IsEquipActionQueued(item))
				{
					p.QueueEquipAction(item);
				}
			}
		}
	}
	[HarmonyPatch(typeof(TombStone), "EasyFitInInventory")]
	internal static class GraveEasyFit
	{
		[HarmonyPostfix]
		private static void Postfix(TombStone __instance, Player player, ref bool __result)
		{
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			if (__result || (Object)(object)player == (Object)null || !SlotState.IsLocal((Humanoid)(object)player) || (Object)(object)__instance.m_container == (Object)null || !SlotState.HiddenRowActive(((Humanoid)player).m_inventory, out var visibleRows))
			{
				return;
			}
			Inventory inventory = ((Humanoid)player).m_inventory;
			Inventory inventory2 = __instance.m_container.GetInventory();
			string text = player.GetPlayerID().ToString();
			int num = 0;
			int num2 = 0;
			int num3 = 0;
			foreach (ItemData allItem in inventory2.GetAllItems())
			{
				SlotDefinition slotDefinition = SlotLayout.SlotAt(allItem.m_gridPos, visibleRows);
				if (slotDefinition != null && slotDefinition.Accepts(allItem) && inventory.GetItemAt(allItem.m_gridPos.x, allItem.m_gridPos.y) == null && allItem.m_customData != null && allItem.m_customData.TryGetValue("vsm.slots.grave", out var value) && value == text)
				{
					num++;
					continue;
				}
				num2++;
				if (inventory.FindFreeStackSpace(allItem.m_shared.m_name, (float)allItem.m_worldLevel) >= allItem.m_stack)
				{
					num3++;
				}
			}
			if (num != 0)
			{
				int num4 = inventory.GetEmptySlots() - num2;
				if (num4 >= 0 || num4 + num3 >= 0)
				{
					__result = inventory.GetTotalWeight() + inventory2.GetTotalWeight() <= player.GetMaxCarryWeight();
				}
			}
		}
	}
	internal static class Placement
	{
		public static void EnsureFullHeight(Player p)
		{
			if (!((Object)(object)p == (Object)null) && ((Humanoid)p).m_inventory != null)
			{
				int num = SlotLayout.FullHeight(SlotState.VisibleRows(p));
				if (((Humanoid)p).m_inventory.m_height != num)
				{
					((Humanoid)p).m_inventory.m_height = num;
					((Humanoid)p).m_inventory.Changed(false, false);
				}
			}
		}

		public static int Rebase(Player p, int oldRows, int newRows)
		{
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_024d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0252: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			Inventory inventory = ((Humanoid)p).m_inventory;
			List<ItemData> inventory2 = inventory.m_inventory;
			List<RebaseEntry> list = new List<RebaseEntry>(inventory2.Count);
			for (int i = 0; i < 2; i++)
			{
				for (int j = 0; j < inventory2.Count; j++)
				{
					ItemData val = inventory2[j];
					if (val.m_equipped == (i == 0))
					{
						Vector2i gridPos = val.m_gridPos;
						SlotDefinition slotDefinition = SlotLayout.ForType(val.m_shared.m_itemType);
						bool flag = slotDefinition != null && SlotLayout.IsEnabled(slotDefinition) && slotDefinition.Accepts(val) && (val.m_equipped || (gridPos.y == oldRows && gridPos.x == slotDefinition.Order));
						list.Add(new RebaseEntry
						{
							Id = j,
							X = gridPos.x,
							Y = gridPos.y,
							SlotOrder = (flag ? slotDefinition.Order : (-1)),
							WasHidden = (gridPos.y == oldRows)
						});
					}
				}
			}
			List<RebaseMove> list2 = RebasePlanner.Plan(list, inventory.m_width, newRows);
			if (list2.Count == 0)
			{
				return 0;
			}
			int num = 0;
			foreach (RebaseMove item in list2)
			{
				ItemData val2 = inventory2[item.Id];
				if (item.Drop)
				{
					val2.m_gridPos = new Vector2i(val2.m_gridPos.x, SlotLayout.FullHeight(newRows) + 1);
					num++;
					SlotsPlugin.Log.LogWarning((object)("vsm.slots: sin sitio para " + val2.m_shared.m_name + " x" + val2.m_stack + " al pasar de " + oldRows + " a " + newRows + " filas; cae al suelo."));
				}
				else
				{
					val2.m_gridPos = new Vector2i(item.X, item.Y);
				}
			}
			inventory.Changed(false, false);
			return num;
		}

		public static Vector2i FreeVisibleCell(Inventory inv, int visibleRows, ItemData forItem)
		{
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			if (forItem != null && inv.TopFirst(forItem))
			{
				for (int i = 0; i < visibleRows; i++)
				{
					for (int j = 0; j < inv.m_width; j++)
					{
						if (inv.GetItemAt(j, i) == null)
						{
							return new Vector2i(j, i);
						}
					}
				}
			}
			else
			{
				for (int num = visibleRows - 1; num >= 0; num--)
				{
					for (int k = 0; k < inv.m_width; k++)
					{
						if (inv.GetItemAt(k, num) == null)
						{
							return new Vector2i(k, num);
						}
					}
				}
			}
			return new Vector2i(-1, -1);
		}

		public static void Move(Inventory inv, ItemData item, Vector2i to)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			item.m_gridPos = to;
			inv.Changed(false, false);
		}

		public static void Swap(Inventory inv, ItemData a, ItemData b)
		{
			//IL_0002: 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_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			Vector2i gridPos = a.m_gridPos;
			a.m_gridPos = b.m_gridPos;
			b.m_gridPos = gridPos;
			inv.Changed(false, false);
		}
	}
	internal static class Reconciler
	{
		private static readonly Dictionary<ItemData, float> s_cooldown = new Dictionary<ItemData, float>();

		private static float s_nextStuckWarning;

		public static void Tick()
		{
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null || SlotState.Suspended || ((Character)localPlayer).IsDead() || localPlayer.m_isLoading || !SlotsPlugin.IsConfigReady)
			{
				return;
			}
			Inventory inventory = ((Humanoid)localPlayer).m_inventory;
			if (!SlotState.HiddenRowActive(inventory, out var visibleRows))
			{
				Placement.EnsureFullHeight(localPlayer);
				if (!SlotState.HiddenRowActive(inventory, out visibleRows))
				{
					return;
				}
			}
			for (int i = 0; i < 3; i++)
			{
				if (!Pass(localPlayer, inventory, visibleRows))
				{
					break;
				}
			}
		}

		public static void Forget()
		{
			s_cooldown.Clear();
		}

		private static bool Pass(Player p, Inventory inv, int v)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			bool flag = false;
			SlotDefinition[] all = SlotLayout.All;
			foreach (SlotDefinition slotDefinition in all)
			{
				Vector2i val = SlotLayout.CellOf(slotDefinition, v);
				ItemData itemAt = inv.GetItemAt(val.x, val.y);
				if (!SlotLayout.IsEnabled(slotDefinition))
				{
					flag |= itemAt != null && Evict(p, inv, v, itemAt, reequipIfFull: false);
					continue;
				}
				ItemData val2 = slotDefinition.Equipped((Humanoid)(object)p);
				if (itemAt != null && val2 == itemAt)
				{
					ClearSeal(itemAt);
				}
				else
				{
					if (itemAt != null && p.IsEquipActionQueued(itemAt))
					{
						continue;
					}
					if (val2 != null && inv.ContainsItem(val2) && val2.m_gridPos.y < v)
					{
						if (itemAt == null)
						{
							Placement.Move(inv, val2, val);
						}
						else
						{
							Placement.Swap(inv, val2, itemAt);
						}
						flag = true;
					}
					else
					{
						if (itemAt == null || OnCooldown(itemAt))
						{
							continue;
						}
						if (!slotDefinition.Accepts(itemAt))
						{
							flag |= Evict(p, inv, v, itemAt, reequipIfFull: false);
						}
						else if (IsOwnGraveSeal(p, itemAt))
						{
							if (((Humanoid)p).EquipItem(itemAt, false))
							{
								ClearSeal(itemAt);
								flag = true;
							}
							else if (NeverEquipable(itemAt))
							{
								ClearSeal(itemAt);
								flag = true;
							}
							else
							{
								Cooldown(itemAt);
							}
						}
						else
						{
							flag |= Evict(p, inv, v, itemAt, reequipIfFull: true);
						}
					}
				}
			}
			for (int j = 0; j < inv.m_width; j++)
			{
				if (SlotLayout.IsReservedCell(new Vector2i(j, v), v))
				{
					ItemData itemAt2 = inv.GetItemAt(j, v);
					if (itemAt2 != null && !OnCooldown(itemAt2))
					{
						flag |= Evict(p, inv, v, itemAt2, reequipIfFull: false);
					}
				}
			}
			return flag;
		}

		private static bool Evict(Player p, Inventory inv, int v, ItemData item, bool reequipIfFull)
		{
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: 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)
			Vector2i val = Placement.FreeVisibleCell(inv, v, item);
			if (val.x >= 0)
			{
				Placement.Move(inv, item, val);
				return true;
			}
			Cooldown(item);
			if (reequipIfFull && !item.m_equipped && ((Humanoid)p).EquipItem(item, false))
			{
				SlotsPlugin.Message(p, "$vsm_slots_inventory_full");
				return true;
			}
			if (Time.unscaledTime >= s_nextStuckWarning)
			{
				s_nextStuckWarning = Time.unscaledTime + 30f;
				SlotsPlugin.Message(p, "$vsm_slots_stuck", item.m_shared.m_name);
			}
			return false;
		}

		private static bool NeverEquipable(ItemData item)
		{
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Invalid comparison between Unknown and I4
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Invalid comparison between Unknown and I4
			SharedData shared = item.m_shared;
			if (shared.m_useDurability && item.m_durability <= 0f)
			{
				return true;
			}
			if (!string.IsNullOrEmpty(shared.m_dlc) && ((Object)(object)DLCMan.instance == (Object)null || !DLCMan.instance.IsDLCInstalled(shared.m_dlc)))
			{
				return true;
			}
			return Game.m_worldLevel > 0 && item.m_worldLevel < Game.m_worldLevel && ((int)shared.m_itemType == 18 || (int)shared.m_itemType == 24);
		}

		private static bool IsOwnGraveSeal(Player p, ItemData item)
		{
			string value;
			return item.m_customData != null && item.m_customData.TryGetValue("vsm.slots.grave", out value) && value == p.GetPlayerID().ToString();
		}

		private static void ClearSeal(ItemData item)
		{
			if (item.m_customData != null)
			{
				item.m_customData.Remove("vsm.slots.grave");
			}
		}

		private static bool OnCooldown(ItemData item)
		{
			if (!s_cooldown.TryGetValue(item, out var value))
			{
				return false;
			}
			if (Time.unscaledTime < value)
			{
				return true;
			}
			s_cooldown.Remove(item);
			return false;
		}

		private static void Cooldown(ItemData item)
		{
			if (s_cooldown.Count > 64)
			{
				s_cooldown.Clear();
			}
			s_cooldown[item] = Time.unscaledTime + 3f;
		}
	}
	public enum RowsCapMode
	{
		Legal,
		Fijo,
		Libre
	}
	internal static class RowCap
	{
		public const string TrimmedRpc = "VSM_Slots_RowsTrimmed";

		public static int MaxRows(Player p)
		{
			if (!SlotsPlugin.IsConfigReady || (Object)(object)p == (Object)null)
			{
				return 9;
			}
			switch (SlotsPlugin.RowsCap.Value)
			{
			case RowsCapMode.Legal:
			{
				int num = 0;
				string[] array = (SlotsPlugin.RowsLegalKeys.Value ?? string.Empty).Split(new char[1] { ',' });
				foreach (string text in array)
				{
					string text2 = text.Trim();
					if (text2.Length > 0 && ((Humanoid)p).HaveUniqueKey(text2))
					{
						num++;
					}
				}
				return SlotMath.LegalRows(SlotsPlugin.RowsBase.Value, num);
			}
			case RowsCapMode.Fijo:
				return SlotLayout.ClampRows(SlotsPlugin.RowsFixedMax.Value);
			default:
				return 9;
			}
		}

		public static void Enforce(Player p, string when)
		{
			if (!((Object)(object)p == (Object)null) && SlotState.IsLocal((Humanoid)(object)p) && SlotsPlugin.IsConfigReady)
			{
				int num = MaxRows(p);
				int num2 = SlotState.VisibleRows(p);
				if (num2 > num)
				{
					SlotsPlugin.Log.LogInfo((object)("vsm.slots: aplicando el tope de filas (" + when + ")."));
					OnTrimmed(p, num2, num);
					p.SetInventorySize(num);
				}
			}
		}

		public static void OnTrimmed(Player p, int requested, int cap)
		{
			SlotsPlugin.Log.LogWarning((object)("vsm.slots: " + p.GetPlayerName() + " pidió " + requested + " filas y el servidor permite " + cap + ": se recorta."));
			try
			{
				if (ZRoutedRpc.instance != null && (Object)(object)ZNet.instance != (Object)null && !ZNet.instance.IsServer())
				{
					ZRoutedRpc.instance.InvokeRoutedRPC(ZRoutedRpc.instance.GetServerPeerID(), "VSM_Slots_RowsTrimmed", new object[3]
					{
						p.GetPlayerName(),
						requested,
						cap
					});
				}
			}
			catch (Exception ex)
			{
				SlotsPlugin.Log.LogWarning((object)("vsm.slots: no se pudo avisar al servidor del recorte: " + ex.Message));
			}
			SlotsPlugin.Message(p, "$vsm_slots_rows_trimmed", requested, cap);
		}

		public static void RPC_RowsTrimmed(long sender, string playerName, int from, int to)
		{
			if (!((Object)(object)ZNet.instance == (Object)null) && ZNet.instance.IsServer())
			{
				ZNetPeer peer = ZNet.instance.GetPeer(sender);
				string text = ((peer != null && peer.m_socket != null) ? peer.m_socket.GetHostName() : "?");
				SlotsPlugin.Log.LogWarning((object)("vsm.slots: [inventario] " + playerName + " (" + text + ") tenía o pidió " + from + " filas; recortado a " + to + "."));
			}
		}
	}
	internal static class SafetyPatches
	{
		[HarmonyPatch(typeof(Player), "SetInventorySize", new Type[] { typeof(int) })]
		internal static class SetInventorySizePatch
		{
			[HarmonyPrefix]
			[HarmonyPriority(800)]
			private static void Prefix(Player __instance, ref int rows)
			{
				if (SlotState.IsLocal((Humanoid)(object)__instance))
				{
					int num = RowCap.MaxRows(__instance);
					if (rows > num)
					{
						RowCap.OnTrimmed(__instance, rows, num);
						rows = num;
					}
					SlotState.PendingOldRows = SlotState.VisibleRows(__instance);
					SlotState.PendingNewRows = SlotLayout.ClampRows(rows);
				}
			}

			[HarmonyFinalizer]
			private static void Finalizer(Player __instance)
			{
				if (SlotState.IsLocal((Humanoid)(object)__instance))
				{
					SlotState.PendingOldRows = (SlotState.PendingNewRows = -1);
					SlotState.InvalidateRows();
					Placement.EnsureFullHeight(__instance);
				}
			}
		}

		[HarmonyPatch(typeof(Humanoid), "DropInvalidItems")]
		internal static class DropInvalidItemsPatch
		{
			[HarmonyPrefix]
			[HarmonyPriority(800)]
			private static void Prefix(Humanoid __instance)
			{
				Player val = (Player)(object)((__instance is Player) ? __instance : null);
				if (!((Object)(object)val == (Object)null) && SlotState.IsLocal((Humanoid)(object)val))
				{
					int num = ((SlotState.PendingNewRows >= 0) ? SlotState.PendingNewRows : SlotState.VisibleRows(val));
					int oldRows = ((SlotState.PendingOldRows >= 0) ? SlotState.PendingOldRows : num);
					int num2 = Placement.Rebase(val, oldRows, num);
					((Humanoid)val).m_inventory.m_height = num + 1;
					if (num2 > 0)
					{
						SlotsPlugin.Message(val, "$vsm_slots_rows_dropped", num2);
					}
				}
			}
		}

		[HarmonyPatch(typeof(Player), "OnSpawned", new Type[] { typeof(bool) })]
		internal static class OnSpawnedPatch
		{
			[HarmonyPostfix]
			private static void Postfix(Player __instance)
			{
				if (SlotState.IsLocal((Humanoid)(object)__instance))
				{
					SlotState.InvalidateRows();
					SlotState.Suspended = false;
					RowCap.Enforce(__instance, "aparición");
					Placement.EnsureFullHeight(__instance);
				}
			}
		}

		[HarmonyPatch(typeof(Player), "Load", new Type[] { typeof(ZPackage) })]
		internal static class LoadPatch
		{
			[HarmonyPrefix]
			private static void Prefix(Player __instance)
			{
				if (SlotState.IsLocal((Humanoid)(object)__instance))
				{
					SlotState.Suspended = true;
					SlotState.InvalidateRows();
				}
			}

			[HarmonyFinalizer]
			private static void Finalizer(Player __instance)
			{
				if (SlotState.IsLocal((Humanoid)(object)__instance))
				{
					SlotState.InvalidateRows();
					Placement.EnsureFullHeight(__instance);
					__instance.m_customData.Remove("vsm.slots.backup");
				}
			}
		}

		[HarmonyPatch(typeof(Player), "CreateTombStone")]
		internal static class TombStonePatch
		{
			[HarmonyPrefix]
			private static void Prefix(Player __instance)
			{
				if (!SlotState.IsLocal((Humanoid)(object)__instance))
				{
					return;
				}
				SlotState.Suspended = true;
				string value = __instance.GetPlayerID().ToString();
				SlotDefinition[] all = SlotLayout.All;
				foreach (SlotDefinition slotDefinition in all)
				{
					ItemData val = slotDefinition.Equipped((Humanoid)(object)__instance);
					if (val != null && val.m_customData != null)
					{
						val.m_customData["vsm.slots.grave"] = value;
					}
				}
			}

			[HarmonyFinalizer]
			private static void Finalizer(Player __instance)
			{
				if (SlotState.IsLocal((Humanoid)(object)__instance))
				{
					SlotState.Suspended = false;
				}
			}
		}

		[HarmonyPatch(typeof(Inventory), "FindEmptySlot", new Type[] { typeof(bool) })]
		internal static class FindEmptySlotPatch
		{
			[HarmonyPrefix]
			private static void Prefix(Inventory __instance, out int __state)
			{
				__state = -1;
				if (SlotState.IsPlayerInventory(__instance) && SlotState.HiddenRowActive(__instance, out var visibleRows))
				{
					__state = __instance.m_height;
					__instance.m_height = visibleRows;
				}
			}

			[HarmonyPostfix]
			private static void Postfix(Inventory __instance, int __state, ref Vector2i __result)
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_0014: Unknown result type (might be due to invalid IL or missing references)
				//IL_003b: Unknown result type (might be due to invalid IL or missing references)
				//IL_003c: Unknown result type (might be due to invalid IL or missing references)
				//IL_001e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0024: Unknown result type (might be due to invalid IL or missing references)
				Vector2i upgradeCell = SlotState.UpgradeCell;
				if (__state >= 0 && __result.x < 0 && upgradeCell.x >= 0 && __instance.GetItemAt(upgradeCell.x, upgradeCell.y) == null)
				{
					__result = upgradeCell;
				}
			}

			[HarmonyFinalizer]
			private static void Finalizer(Inventory __instance, int __state)
			{
				if (__state >= 0)
				{
					__instance.m_height = __state;
				}
			}
		}

		[HarmonyPatch(typeof(InventoryGui), "DoCrafting")]
		internal static class UpgradeInHiddenRow
		{
			[HarmonyPrefix]
			private static void Prefix(InventoryGui __instance, Player player, out bool __state)
			{
				//IL_0053: Unknown result type (might be due to invalid IL or missing references)
				//IL_0058: Unknown result type (might be due to invalid IL or missing references)
				__state = false;
				ItemData craftUpgradeItem = __instance.m_craftUpgradeItem;
				if (craftUpgradeItem != null && SlotState.IsLocal((Humanoid)(object)player) && SlotState.HiddenRowActive(((Humanoid)player).m_inventory, out var visibleRows) && craftUpgradeItem.m_gridPos.y == visibleRows && ((Humanoid)player).m_inventory.ContainsItem(craftUpgradeItem))
				{
					SlotState.UpgradeCell = craftUpgradeItem.m_gridPos;
					__state = craftUpgradeItem.m_equipped;
				}
			}

			[HarmonyFinalizer]
			private static void Finalizer(Player player, bool __state)
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_0009: Unknown result type (might be due to invalid IL or missing references)
				//IL_000e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0013: Unknown result type (might be due to invalid IL or missing references)
				//IL_0035: Unknown result type (might be due to invalid IL or missing references)
				//IL_003b: Unknown result type (might be due to invalid IL or missing references)
				Vector2i upgradeCell = SlotState.UpgradeCell;
				SlotState.UpgradeCell = new Vector2i(-1, -1);
				if (upgradeCell.x >= 0 && SlotState.IsLocal((Humanoid)(object)player))
				{
					ItemData itemAt = ((Humanoid)player).m_inventory.GetItemAt(upgradeCell.x, upgradeCell.y);
					if (itemAt != null && __state && !itemAt.m_equipped)
					{
						((Humanoid)player).EquipItem(itemAt, false);
					}
				}
			}
		}

		[HarmonyPatch(typeof(InventoryGrid), "DropItem")]
		internal static class GridDropGuard
		{
			[HarmonyPrefix]
			[HarmonyPriority(800)]
			private static bool Prefix(InventoryGrid __instance, Inventory fromInventory, ItemData item, Vector2i pos, ref bool __result)
			{
				//IL_0047: Unknown result type (might be due to invalid IL or missing references)
				Player localPlayer = Player.m_localPlayer;
				if ((Object)(object)localPlayer == (Object)null || SlotState.Internal || item == null || !SlotState.HiddenRowActive(((Humanoid)localPlayer).m_inventory, out var visibleRows))
				{
					return true;
				}
				bool flag = __instance.GetInventory() == ((Humanoid)localPlayer).m_inventory && pos.y == visibleRows;
				bool flag2 = fromInventory == ((Humanoid)localPlayer).m_inventory && item.m_gridPos.y == visibleRows;
				if (!flag && !flag2)
				{
					return true;
				}
				__result = false;
				return false;
			}
		}

		[HarmonyPatch(typeof(Inventory), "GetEmptySlots")]
		internal static class GetEmptySlotsPatch
		{
			[HarmonyPrefix]
			private static bool Prefix(Inventory __instance, ref int __result)
			{
				if (!SlotState.IsPlayerInventory(__instance) || !SlotState.HiddenRowActive(__instance, out var visibleRows))
				{
					return true;
				}
				__result = SlotMath.EmptyVisible(__instance.m_width, visibleRows, VisibleCount(__instance, visibleRows));
				return false;
			}
		}

		[HarmonyPatch(typeof(Inventory), "HaveEmptySlot")]
		internal static class HaveEmptySlotPatch
		{
			[HarmonyPrefix]
			private static bool Prefix(Inventory __instance, ref bool __result)
			{
				if (!SlotState.IsPlayerInventory(__instance) || !SlotState.HiddenRowActive(__instance, out var visibleRows))
				{
					return true;
				}
				__result = SlotMath.EmptyVisible(__instance.m_width, visibleRows, VisibleCount(__instance, visibleRows)) > 0;
				return false;
			}
		}

		[HarmonyPatch(typeof(Inventory), "CanAddItem", new Type[]
		{
			typeof(ItemData),
			typeof(int)
		})]
		internal static class CanAddItemPatch
		{
			[HarmonyPrefix]
			private static bool Prefix(Inventory __instance, ItemData item, int stack, ref bool __result)
			{
				if (item == null || !SlotState.IsPlayerInventory(__instance) || !SlotState.HiddenRowActive(__instance, out var visibleRows))
				{
					return true;
				}
				if (stack <= 0)
				{
					stack = item.m_stack;
				}
				int emptyVisibleCells = SlotMath.EmptyVisible(__instance.m_width, visibleRows, VisibleCount(__instance, visibleRows));
				__result = SlotMath.CanAdd(__instance.FindFreeStackSpace(item.m_shared.m_name, (float)item.m_worldLevel), emptyVisibleCells, item.m_shared.m_maxStackSize, stack);
				return false;
			}
		}

		[HarmonyPatch(typeof(Inventory), "AddItem", new Type[]
		{
			typeof(ItemData),
			typeof(int),
			typeof(int),
			typeof(int),
			typeof(bool)
		})]
		internal static class AddItemAtPatch
		{
			[HarmonyPrefix]
			private static bool Prefix(Inventory __instance, ItemData item, int x, int y, bool skipValidPositionCheck, ref bool __result)
			{
				if (item == null || AllowHiddenRow(__instance, item, x, y, skipValidPositionCheck))
				{
					return true;
				}
				__result = false;
				return false;
			}
		}

		[HarmonyPatch(typeof(Inventory), "AddItem", new Type[]
		{
			typeof(ItemData),
			typeof(Vector2i)
		})]
		internal static class AddItemPosPatch
		{
			[HarmonyPrefix]
			private static bool Prefix(Inventory __instance, ItemData item, Vector2i pos, ref bool __result)
			{
				//IL_0006: 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)
				if (item == null || AllowHiddenRow(__instance, item, pos.x, pos.y, skip: false))
				{
					return true;
				}
				__result = false;
				return false;
			}
		}

		public static readonly Type[] Classes = new Type[13]
		{
			typeof(SetInventorySizePatch),
			typeof(DropInvalidItemsPatch),
			typeof(OnSpawnedPatch),
			typeof(LoadPatch),
			typeof(TombStonePatch),
			typeof(FindEmptySlotPatch),
			typeof(GetEmptySlotsPatch),
			typeof(HaveEmptySlotPatch),
			typeof(CanAddItemPatch),
			typeof(AddItemAtPatch),
			typeof(AddItemPosPatch),
			typeof(GridDropGuard),
			typeof(UpgradeInHiddenRow)
		};

		private static int VisibleCount(Inventory inv, int visibleRows)
		{
			int num = 0;
			List<ItemData> inventory = inv.m_inventory;
			for (int i = 0; i < inventory.Count; i++)
			{
				if (inventory[i].m_gridPos.y < visibleRows)
				{
					num++;
				}
			}
			return num;
		}

		internal static bool AllowHiddenRow(Inventory inv, ItemData item, int x, int y, bool skip)
		{
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			if (!SlotState.IsPlayerInventory(inv) || !SlotState.HiddenRowActive(inv, out var visibleRows) || y != visibleRows)
			{
				return true;
			}
			if (skip || SlotState.Internal)
			{
				return true;
			}
			if (inv.GetItemAt(x, y) != null)
			{
				return false;
			}
			if (SlotState.UpgradeCell.x == x && SlotState.UpgradeCell.y == y)
			{
				return true;
			}
			SlotDefinition slotDefinition = SlotLayout.SlotAt(new Vector2i(x, y), visibleRows);
			if (slotDefinition == null || !slotDefinition.Accepts(item))
			{
				return false;
			}
			Player localPlayer = Player.m_localPlayer;
			string value;
			return item.m_customData != null && item.m_customData.TryGetValue("vsm.slots.grave", out value) && (Object)(object)localPlayer != (Object)null && value == localPlayer.GetPlayerID().ToString();
		}
	}
	internal static class SlotState
	{
		public const string GraveSealKey = "vsm.slots.grave";

		private const string RowsKey = "invrows";

		private static Player s_rowsFor;

		private static int s_rows = -1;

		public static bool Suspended;

		public static bool Internal;

		public static Vector2i UpgradeCell = new Vector2i(-1, -1);

		public static int PendingOldRows = -1;

		public static int PendingNewRows = -1;

		public static Player Local => Player.m_localPlayer;

		public static bool IsLocal(Humanoid h)
		{
			Player localPlayer = Player.m_localPlayer;
			return (Object)(object)localPlayer != (Object)null && (Object)(object)h == (Object)(object)localPlayer;
		}

		public static bool IsPlayerInventory(Inventory inv)
		{
			Player localPlayer = Player.m_localPlayer;
			return inv != null && (Object)(object)localPlayer != (Object)null && inv == ((Humanoid)localPlayer).m_inventory;
		}

		public static int VisibleRows(Player p)
		{
			if ((Object)(object)p == (Object)null)
			{
				return 4;
			}
			if ((Object)(object)p == (Object)(object)s_rowsFor && s_rows >= 0)
			{
				return s_rows;
			}
			int result = 4;
			string s = default(string);
			if (p.TryGetUniqueKeyValue("invrows", ref s) && int.TryParse(s, out var result2))
			{
				result = SlotLayout.ClampRows(result2);
			}
			s_rowsFor = p;
			s_rows = result;
			return result;
		}

		public static void InvalidateRows()
		{
			s_rowsFor = null;
			s_rows = -1;
		}

		public static bool HiddenRowActive(Inventory inv, out int visibleRows)
		{
			visibleRows = VisibleRows(Player.m_localPlayer);
			return inv.m_height == visibleRows + 1;
		}

		public static void Reset()
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			InvalidateRows();
			Suspended = false;
			Internal = false;
			UpgradeCell = new Vector2i(-1, -1);
			PendingOldRows = (PendingNewRows = -1);
		}
	}
}
namespace VSM.Slots.Core
{
	public sealed class SlotDefinition
	{
		public string Id;

		public int Order;

		public ItemType Type;

		public string NameToken;

		public int Column;

		public int Row;

		public bool Accepts(ItemData item)
		{
			//IL_0012: 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)
			return item != null && item.m_shared != null && item.m_shared.m_itemType == Type && item.m_shared.m_maxStackSize == 1 && item.IsEquipable();
		}

		public ItemData Equipped(Humanoid h)
		{
			//IL_0002: 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_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Invalid comparison between Unknown and I4
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Invalid comparison between Unknown and I4
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Invalid comparison between Unknown and I4
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Invalid comparison between Unknown and I4
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Invalid comparison between Unknown and I4
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Invalid comparison between Unknown and I4
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Invalid comparison between Unknown and I4
			ItemType type = Type;
			ItemType val = type;
			if ((int)val <= 11)
			{
				if ((int)val == 6)
				{
					return h.m_helmetItem;
				}
				if ((int)val == 7)
				{
					return h.m_chestItem;
				}
				if ((int)val == 11)
				{
					return h.m_legItem;
				}
			}
			else
			{
				if ((int)val == 17)
				{
					return h.m_shoulderItem;
				}
				if ((int)val == 18)
				{
					return h.m_utilityItem;
				}
				if ((int)val == 24)
				{
					return h.m_trinketItem;
				}
			}
			return null;
		}
	}
	public static class SlotLayout
	{
		public const int Width = 8;

		public const int MaxRows = 9;

		public static readonly SlotDefinition[] All = new SlotDefinition[6]
		{
			new SlotDefinition
			{
				Id = "helmet",
				Order = 0,
				Type = (ItemType)6,
				NameToken = "$vsm_slots_helmet",
				Column = 0,
				Row = 0
			},
			new SlotDefinition
			{
				Id = "chest",
				Order = 1,
				Type = (ItemType)7,
				NameToken = "$vsm_slots_chest",
				Column = 0,
				Row = 1
			},
			new SlotDefinition
			{
				Id = "legs",
				Order = 2,
				Type = (ItemType)11,
				NameToken = "$vsm_slots_legs",
				Column = 0,
				Row = 2
			},
			new SlotDefinition
			{
				Id = "shoulder",
				Order = 3,
				Type = (ItemType)17,
				NameToken = "$vsm_slots_shoulder",
				Column = 1,
				Row = 0
			},
			new SlotDefinition
			{
				Id = "utility",
				Order = 4,
				Type = (ItemType)18,
				NameToken = "$vsm_slots_utility",
				Column = 1,
				Row = 1
			},
			new SlotDefinition
			{
				Id = "trinket",
				Order = 5,
				Type = (ItemType)24,
				NameToken = "$vsm_slots_trinket",
				Column = 1,
				Row = 2
			}
		};

		private static HashSet<string> s_enabled = new HashSet<string>(StringComparer.OrdinalIgnoreCase) { "helmet", "chest", "legs", "shoulder", "utility", "trinket" };

		public static void SetEnabled(string csv)
		{
			HashSet<string> hashSet = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
			string[] array = (csv ?? string.Empty).Split(new char[1] { ',' });
			foreach (string text in array)
			{
				string text2 = text.Trim();
				if (text2.Length > 0)
				{
					hashSet.Add(text2);
				}
			}
			s_enabled = hashSet;
		}

		public static bool IsEnabled(SlotDefinition slot)
		{
			return slot != null && s_enabled.Contains(slot.Id);
		}

		public static int ClampRows(int rows)
		{
			return (rows >= 0) ? ((rows > 9) ? 9 : rows) : 0;
		}

		public static int FullHeight(int visibleRows)
		{
			return ClampRows(visibleRows) + 1;
		}

		public static Vector2i CellOf(SlotDefinition slot, int visibleRows)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			return new Vector2i(slot.Order, ClampRows(visibleRows));
		}

		public static bool IsHiddenRow(Vector2i pos, int visibleRows)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			return pos.y == ClampRows(visibleRows) && pos.x >= 0 && pos.x < 8;
		}

		public static SlotDefinition SlotAt(Vector2i pos, int visibleRows)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			if (!IsHiddenRow(pos, visibleRows))
			{
				return null;
			}
			SlotDefinition[] all = All;
			foreach (SlotDefinition slotDefinition in all)
			{
				if (slotDefinition.Order == pos.x)
				{
					return IsEnabled(slotDefinition) ? slotDefinition : null;
				}
			}
			return null;
		}

		public static bool IsReservedCell(Vector2i pos, int visibleRows)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			return IsHiddenRow(pos, visibleRows) && SlotAt(pos, visibleRows) == null;
		}

		public static SlotDefinition ForType(ItemType type)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			SlotDefinition[] all = All;
			foreach (SlotDefinition slotDefinition in all)
			{
				if (slotDefinition.Type == type)
				{
					return slotDefinition;
				}
			}
			return null;
		}

		public static SlotDefinition ById(string id)
		{
			SlotDefinition[] all = All;
			foreach (SlotDefinition slotDefinition in all)
			{
				if (string.Equals(slotDefinition.Id, id, StringComparison.OrdinalIgnoreCase))
				{
					return slotDefinition;
				}
			}
			return null;
		}
	}
	public static class SlotMath
	{
		public static int LegalRows(int baseRows, int boughtPockets)
		{
			return SlotLayout.ClampRows(Math.Max(0, baseRows) + Math.Max(0, boughtPockets));
		}

		public static int EmptyVisible(int width, int visibleRows, int visibleItemCount)
		{
			return Math.Max(0, width * Math.Max(0, visibleRows) - Math.Max(0, visibleItemCount));
		}

		public static bool CanAdd(int freeStackSpace, int emptyVisibleCells, int maxStack, int stack)
		{
			return freeStackSpace + emptyVisibleCells * Math.Max(1, maxStack) >= stack;
		}
	}
	public struct RebaseEntry
	{
		public int Id;

		public int X;

		public int Y;

		public int SlotOrder;

		public bool WasHidden;
	}
	public struct RebaseMove
	{
		public int Id;

		public int X;

		public int Y;

		public bool Drop;
	}
	public static class RebasePlanner
	{
		public static List<RebaseMove> Plan(IList<RebaseEntry> items, int width, int newVisibleRows)
		{
			int num = SlotLayout.ClampRows(newVisibleRows);
			List<RebaseMove> list = new List<RebaseMove>();
			HashSet<long> hashSet = new HashSet<long>();
			HashSet<int> hashSet2 = new HashSet<int>();
			HashSet<int> hashSet3 = new HashSet<int>();
			foreach (RebaseEntry item2 in items)
			{
				if (item2.SlotOrder < 0 && InGrid(item2, width) && item2.Y < num && hashSet.Add(Key(item2.X, item2.Y)))
				{
					hashSet3.Add(item2.Id);
				}
			}
			List<RebaseEntry> list2 = new List<RebaseEntry>();
			foreach (RebaseEntry item3 in items)
			{
				if (item3.SlotOrder < 0)
				{
					list2.Add(item3);
				}
				else if (item3.SlotOrder >= width || !hashSet2.Add(item3.SlotOrder))
				{
					RebaseEntry item = item3;
					item.SlotOrder = -1;
					list2.Add(item);
				}
				else if (item3.X != item3.SlotOrder || item3.Y != num)
				{
					list.Add(new RebaseMove
					{
						Id = item3.Id,
						X = item3.SlotOrder,
						Y = num
					});
				}
			}
			HashSet<int> hashSet4 = new HashSet<int>(hashSet2);
			List<RebaseEntry> list3 = new List<RebaseEntry>(list2.Count);
			for (int i = 0; i < 3; i++)
			{
				foreach (RebaseEntry item4 in list2)
				{
					bool flag = InGrid(item4, width) && item4.Y == num && !hashSet4.Contains(item4.X);
					if (((!item4.WasHidden) ? (flag ? 1 : 2) : 0) == i)
					{
						list3.Add(item4);
					}
				}
			}
			foreach (RebaseEntry item5 in list3)
			{
				if (IsResident(list2, item5, width, num, hashSet4))
				{
					hashSet2.Add(item5.X);
				}
			}
			foreach (RebaseEntry item6 in list3)
			{
				if (hashSet3.Contains(item6.Id))
				{
					continue;
				}
				bool flag2 = InGrid(item6, width);
				if (flag2 && item6.Y < num && hashSet.Add(Key(item6.X, item6.Y)))
				{
					continue;
				}
				bool flag3 = IsResident(list2, item6, width, num, hashSet4);
				bool flag4 = flag2 && item6.Y == num && !hashSet4.Contains(item6.X) && OwnsHiddenCell(list2, item6, num);
				if (FindFree(hashSet, width, num, out var x, out var y))
				{
					hashSet.Add(Key(x, y));
					if (flag3)
					{
						hashSet2.Remove(item6.X);
					}
					list.Add(new RebaseMove
					{
						Id = item6.Id,
						X = x,
						Y = y
					});
				}
				else
				{
					if (flag3 || (flag4 && hashSet2.Add(item6.X)))
					{
						continue;
					}
					if (item6.WasHidden || (flag2 && item6.Y == num))
					{
						int num2 = FreeHidden(hashSet2, width);
						if (num2 >= 0)
						{
							hashSet2.Add(num2);
							list.Add(new RebaseMove
							{
								Id = item6.Id,
								X = num2,
								Y = num
							});
							continue;
						}
					}
					list.Add(new RebaseMove
					{
						Id = item6.Id,
						Drop = true
					});
				}
			}
			return list;
		}

		private static bool InGrid(RebaseEntry e, int width)
		{
			return e.X >= 0 && e.X < width && e.Y >= 0;
		}

		private static bool IsResident(List<RebaseEntry> rest, RebaseEntry e, int width, int v, HashSet<int> slotCells)
		{
			return e.WasHidden && InGrid(e, width) && e.Y == v && !slotCells.Contains(e.X) && OwnsHiddenCell(rest, e, v);
		}

		private static bool OwnsHiddenCell(List<RebaseEntry> rest, RebaseEntry e, int v)
		{
			foreach (RebaseEntry item in rest)
			{
				if (item.X == e.X && item.Y == v)
				{
					return item.Id == e.Id;
				}
			}
			return false;
		}

		private static long Key(int x, int y)
		{
			return ((long)y << 32) | (uint)x;
		}

		private static int FreeHidden(HashSet<int> taken, int width)
		{
			for (int num = width - 1; num >= 0; num--)
			{
				if (!taken.Contains(num))
				{
					return num;
				}
			}
			return -1;
		}

		private static bool FindFree(HashSet<long> occupied, int width, int v, out int x, out int y)
		{
			for (int num = v - 1; num >= 0; num--)
			{
				for (int i = 0; i < width; i++)
				{
					if (!occupied.Contains(Key(i, num)))
					{
						x = i;
						y = num;
						return true;
					}
				}
			}
			x = (y = -1);
			return false;
		}
	}
}
namespace System.Runtime.CompilerServices
{
	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
	internal sealed class <f38ba538-35fd-47fd-b707-af2183e34bfc>IgnoresAccessChecksToAttribute : Attribute
	{
		public <f38ba538-35fd-47fd-b707-af2183e34bfc>IgnoresAccessChecksToAttribute(string assemblyName)
		{
		}
	}
}
namespace VSM.Core.Ui
{
	internal static class VanillaStyle
	{
		public static TMP_Text TitleFont => ((Object)(object)InventoryGui.instance != (Object)null) ? InventoryGui.instance.m_playerName : null;

		public static TMP_Text BodyFont => (!((Object)(object)InventoryGui.instance != (Object)null)) ? null : (((Object)(object)InventoryGui.instance.m_armor != (Object)null) ? InventoryGui.instance.m_armor : InventoryGui.instance.m_playerName);

		public static Image FindBackground(Transform root, Transform exclude1, Transform exclude2)
		{
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)root == (Object)null)
			{
				return null;
			}
			Image result = null;
			float num = 0f;
			Image[] componentsInChildren = ((Component)root).GetComponentsInChildren<Image>(true);
			foreach (Image val in componentsInChildren)
			{
				if ((Object)(object)val == (Object)null || (Object)(object)val.sprite == (Object)null)
				{
					continue;
				}
				Transform transform = ((Component)val).transform;
				if ((!((Object)(object)exclude1 != (Object)null) || !transform.IsChildOf(exclude1)) && (!((Object)(object)exclude2 != (Object)null) || !transform.IsChildOf(exclude2)))
				{
					Rect rect = ((Graphic)val).rectTransform.rect;
					float num2 = Mathf.Abs(((Rect)(ref rect)).width * ((Rect)(ref rect)).height);
					if (num2 > num)
					{
						num = num2;
						result = val;
					}
				}
			}
			return result;
		}

		public static bool CopyImage(Image source, Image target)
		{
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)target == (Object)null)
			{
				return false;
			}
			if ((Object)(object)source == (Object)null)
			{
				((Graphic)target).color = new Color(0f, 0f, 0f, 0.6f);
				return false;
			}
			target.sprite = source.sprite;
			target.type = source.type;
			((Graphic)target).material = ((Graphic)source).material;
			((Graphic)target).color = ((Graphic)source).color;
			target.fillCenter = source.fillCenter;
			target.pixelsPerUnitMultiplier = source.pixelsPerUnitMultiplier;
			target.preserveAspect = false;
			return true;
		}

		public static Image InventoryBackground(Transform exclude)
		{
			InventoryGui instance = InventoryGui.instance;
			if ((Object)(object)instance == (Object)null || (Object)(object)instance.m_player == (Object)null)
			{
				return null;
			}
			Transform exclude2 = (Transform)(object)(((Object)(object)instance.m_playerGrid != (Object)null) ? instance.m_playerGrid.m_gridRoot : null);
			return FindBackground((Transform)(object)instance.m_player, exclude2, exclude);
		}

		public static void CopyFont(TMP_Text source, TMP_Text target)
		{
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)source == (Object)null) && !((Object)(object)target == (Object)null))
			{
				target.font = source.font;
				target.fontSharedMaterial = source.fontSharedMaterial;
				((Graphic)target).color = ((Graphic)source).color;
				target.fontStyle = source.fontStyle;
			}
		}

		public static TextMeshProUGUI NewText(Transform parent, string name, TMP_Text style, float size, TextAlignmentOptions align)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Expected O, but got Unknown
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject(name, new Type[1] { typeof(RectTransform) });
			val.transform.SetParent(parent, false);
			TextMeshProUGUI val2 = val.AddComponent<TextMeshProUGUI>();
			CopyFont(style, (TMP_Text)(object)val2);
			((TMP_Text)val2).fontSize = size;
			((TMP_Text)val2).alignment = align;
			((Graphic)val2).raycastTarget = false;
			((TMP_Text)val2).enableWordWrapping = false;
			((TMP_Text)val2).richText = true;
			return val2;
		}
	}
}
namespace VSM.Core.Runtime
{
	internal static class Headless
	{
		private static bool? s_isHeadless;

		public static bool IsHeadless
		{
			get
			{
				//IL_0013: Unknown result type (might be due to invalid IL or missing references)
				//IL_0019: Invalid comparison between Unknown and I4
				if (!s_isHeadless.HasValue)
				{
					s_isHeadless = (int)SystemInfo.graphicsDeviceType == 4 || Application.isBatchMode;
				}
				return s_isHeadless.Value;
			}
		}

		public static bool IsServerProcess => (Object)(object)ZNet.instance != (Object)null && ZNet.instance.IsServer();

		public static bool IsDedicatedServer => (Object)(object)ZNet.instance != (Object)null && ZNet.instance.IsServer() && ZNet.instance.IsDedicated();

		public static bool IsListenHost => (Object)(object)ZNet.instance != (Object)null && ZNet.instance.IsServer() && !ZNet.instance.IsDedicated();

		public static bool IsRemoteClient => (Object)(object)ZNet.instance != (Object)null && !ZNet.instance.IsServer();
	}
	internal static class Keys
	{
		public static bool Pressed(KeyboardShortcut shortcut)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: 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)
			KeyCode mainKey = ((KeyboardShortcut)(ref shortcut)).MainKey;
			return (int)mainKey != 0 && ZInput.GetKeyDown(mainKey, false) && ((KeyboardShortcut)(ref shortcut)).Modifiers.All((KeyCode m) => ZInput.GetKey(m, false));
		}
	}
}
namespace VSM.Core.Reflection
{
	internal static class GameConstants
	{
		private static uint? s_networkVersion;

		private static long? s_routedEverybody;

		public static uint NetworkVersion
		{
			get
			{
				if (!s_networkVersion.HasValue)
				{
					s_networkVersion = ReadConstant<uint>(typeof(Version), new string[2] { "c_networkVersion", "m_networkVersion" });
				}
				return s_networkVersion.Value;
			}
		}

		public static long RoutedRpcEverybody
		{
			get
			{
				if (!s_routedEverybody.HasValue)
				{
					s_routedEverybody = ReadConstant<long>(typeof(ZRoutedRpc), new string[1] { "Everybody" });
				}
				return s_routedEverybody.Value;
			}
		}

		public static string GameVersionString
		{
			get
			{
				//IL_0002: 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)
				try
				{
					return ((object)Version.CurrentVersion/*cast due to .constrained prefix*/).ToString();
				}
				catch (Exception)
				{
					return "?";
				}
			}
		}

		private static T ReadConstant<T>(Type type, params string[] names) where T : struct
		{
			foreach (string name in names)
			{
				FieldInfo field = type.GetField(name, BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
				if (!(field == null))
				{
					object obj = (field.IsLiteral ? field.GetRawConstantValue() : field.GetValue(null));
					if (obj is T result)
					{
						return result;
					}
					try
					{
						return (T)Convert.ChangeType(obj, typeof(T));
					}
					catch (Exception)
					{
					}
				}
			}
			return default(T);
		}
	}
}
namespace VSM.Core.Net
{
	internal static class ZPackageExt
	{
		public static bool HasMore(this ZPackage pkg)
		{
			return pkg != null && pkg.GetPos() < pkg.Size();
		}

		public static int ReadIntOr(this ZPackage pkg, int fallback)
		{
			return pkg.HasMore() ? pkg.ReadInt() : fallback;
		}

		public static string ReadStringOr(this ZPackage pkg, string fallback)
		{
			return pkg.HasMore() ? pkg.ReadString() : fallback;
		}

		public static bool ReadBoolOr(this ZPackage pkg, bool fallback)
		{
			return pkg.HasMore() ? pkg.ReadBool() : fallback;
		}

		public static string ReadBoundedString(this ZPackage pkg, int maxLength)
		{
			string text = pkg.ReadString();
			return (text != null && text.Length <= maxLength) ? text : null;
		}
	}
}
namespace VSM.Core.Localization
{
	internal static class VsmLocalization
	{
		public static void Register(ManualLogSource log, string pluginDirectory, IDictionary<string, string> embeddedSpanish)
		{
			Dictionary<string, string> dictionary = new Dictionary<string, string>(StringComparer.Ordinal);
			if (embeddedSpanish != null)
			{
				foreach (KeyValuePair<string, string> item in embeddedSpanish)
				{
					dictionary[item.Key] = item.Value;
				}
			}
			string path = Path.Combine(pluginDirectory ?? string.Empty, "Translations");
			MergeFile(log, Path.Combine(path, "Spanish.json"), dictionary);
			string text = SafeSelectedLanguage();
			if (!string.Equals(text, "Spanish", StringComparison.OrdinalIgnoreCase))
			{
				MergeFile(log, Path.Combine(path, text + ".json"), dictionary);
			}
			Apply(log, dictionary);
		}

		public static string Localize(string token, params object[] args)
		{
			string text = token;
			try
			{
				if (Localization.instance != null && !string.IsNullOrEmpty(token))
				{
					bool flag = token[0] != '$' && token.IndexOf(' ') < 0 && token.IndexOf('\n') < 0;
					string text2 = Localization.instance.Localize(flag ? ("$" + token) : token);
					text = ((flag && text2.Length > 1 && text2[0] == '[' && text2[text2.Length - 1] == ']') ? token : text2);
				}
			}
			catch (Exception)
			{
				text = token;
			}
			if (args != null && args.Length != 0)
			{
				try
				{
					text = string.Format(text, args);
				}
				catch (FormatException)
				{
				}
			}
			return text;
		}

		private static string SafeSelectedLanguage()
		{
			try
			{
				return (Localization.instance != null) ? Localization.instance.GetSelectedLanguage() : "Spanish";
			}
			catch (Exception)
			{
				return "Spanish";
			}
		}

		private static void Apply(ManualLogSource log, Dictionary<string, string> words)
		{
			if (Localization.instance == null)
			{
				if (log != null)
				{
					log.LogWarning((object)"Localization.instance aún no existe; las traducciones no se han aplicado.");
				}
				return;
			}
			foreach (KeyValuePair<string, string> word in words)
			{
				string text = (word.Key.StartsWith("$", StringComparison.Ordinal) ? word.Key.Substring(1) : word.Key);
				Localization.instance.AddWord(text, word.Value);
			}
		}

		private static void MergeFile(ManualLogSource log, string path, Dictionary<string, string> into)
		{
			if (!File.Exists(path))
			{
				return;
			}
			try
			{
				foreach (KeyValuePair<string, string> item in ParseFlatJson(File.ReadAllText(path, Encoding.UTF8)))
				{
					into[item.Key] = item.Value;
				}
			}
			catch (Exception ex)
			{
				if (log != null)
				{
					log.LogWarning((object)("No se pudo leer " + path + ": " + ex.Message));
				}
			}
		}

		public static Dictionary<string, string> ParseFlatJson(string json)
		{
			Dictionary<string, string> dictionary = new Dictionary<string, string>(StringComparer.Ordinal);
			if (string.IsNullOrEmpty(json))
			{
				return dictionary;
			}
			int i = 0;
			SkipWs(json, ref i);
			if (i >= json.Length || json[i] != '{')
			{
				return dictionary;
			}
			i++;
			while (true)
			{
				SkipWs(json, ref i);
				if (i >= json.Length || json[i] == '}')
				{
					break;
				}
				if (json[i] == ',')
				{
					i++;
					continue;
				}
				string text = ReadString(json, ref i);
				if (text == null)
				{
					i++;
					continue;
				}
				SkipWs(json, ref i);
				if (i < json.Length && json[i] == ':')
				{
					i++;
				}
				SkipWs(json, ref i);
				if (i < json.Length && json[i] == '"')
				{
					string text2 = ReadString(json, ref i);
					dictionary[text] = text2 ?? string.Empty;
				}
				else
				{
					for (; i < json.Length && json[i] != ',' && json[i] != '}'; i++)
					{
					}
				}
			}
			return dictionary;
		}

		private static void SkipWs(string s, ref int i)
		{
			while (i < s.Length && char.IsWhiteSpace(s[i]))
			{
				i++;
			}
		}

		private static string ReadString(string s, ref int i)
		{
			if (i >= s.Length || s[i] != '"')
			{
				return null;
			}
			i++;
			StringBuilder stringBuilder = new StringBuilder();
			while (i < s.Length)
			{
				char c = s[i++];
				switch (c)
				{
				case '"':
					return stringBuilder.ToString();
				case '\\':
				{
					if (i >= s.Length)
					{
						break;
					}
					char c2 = s[i++];
					switch (c2)
					{
					case 'n':
						stringBuilder.Append('\n');
						break;
					case 't':
						stringBuilder.Append('\t');
						break;
					case 'r':
						stringBuilder.Append('\r');
						break;
					case 'b':
						stringBuilder.Append('\b');
						break;
					case 'f':
						stringBuilder.Append('\f');
						break;
					case 'u':
						if (i + 4 <= s.Length)
						{
							stringBuilder.Append((char)Convert.ToInt32(s.Substring(i, 4), 16));
							i += 4;
						}
						break;
					default:
						stringBuilder.Append(c2);
						break;
					}
					continue;
				}
				}
				stringBuilder.Append(c);
			}
			return stringBuilder.ToString();
		}
	}
}
namespace VSM.Core.Harmony
{
	internal static class PatchUtil
	{
		private static readonly List<string> s_failed = new List<string>();

		public static IReadOnlyList<string> FailedTargets => s_failed;

		public static bool IsDegraded => s_failed.Count > 0;

		public static MethodInfo DeclaredMethodOrNull(ManualLogSource log, Type type, string name, Type[] parameters, string owner)
		{
			if (type == null)
			{
				Fail(log, owner, name + " (tipo nulo)");
				return null;
			}
			MethodInfo methodInfo = AccessTools.DeclaredMethod(type, name, parameters, (Type[])null);
			if (methodInfo == null)
			{
				Fail(log, owner, type.FullName + "." + name + "(" + Describe(parameters) + ")");
			}
			return methodInfo;
		}

		public static void PatchAllSafely(ManualLogSource log, Harmony harmony, Assembly assembly)
		{
			Type[] typesFromAssembly = AccessTools.GetTypesFromAssembly(assembly);
			foreach (Type type in typesFromAssembly)
			{
				if (type.GetCustomAttributes(typeof(HarmonyPatch), inherit: true).Length != 0)
				{
					PatchClassSafely(log, harmony, type);
				}
			}
		}

		public static bool PatchClassSafely(ManualLogSource log, Harmony harmony, Type patchClass)
		{
			try
			{
				harmony.CreateClassProcessor(patchClass).Patch();
				return true;
			}
			catch (Exception ex)
			{
				Fail(log, harmony.Id, patchClass.FullName + " -> " + ex.GetType().Name + ": " + ex.Message);
				return false;
			}
		}

		private static void Fail(ManualLogSource log, string owner, string what)
		{
			s_failed.Add(what);
			if (log != null)
			{
				log.LogError((object)("[" + owner + "] No se pudo aplicar el parche (¿cambió el juego?): " + what + ". El mod sigue cargado en modo degradado."));
			}
		}

		private static string Describe(Type[] parameters)
		{
			if (parameters == null || parameters.Length == 0)
			{
				return string.Empty;
			}
			string[] array = new string[parameters.Length];
			for (int i = 0; i < parameters.Length; i++)
			{
				array[i] = ((parameters[i] == null) ? "?" : parameters[i].Name);
			}
			return string.Join(", ", array);
		}
	}
}
namespace VSM.Core.Config
{
	internal sealed class ConfigurationManagerAttributes
	{
		public bool? ShowRangeAsPercent;

		public Action<ConfigEntryBase> CustomDrawer;

		public bool? Browsable;

		public string Category;

		public object DefaultValue;

		public bool? HideDefaultButton;

		public bool? HideSettingName;

		public string Description;

		public string DispName;

		public int? Order;

		public bool? ReadOnly;

		public bool? IsAdvanced;

		public bool? IsAdminOnly;

		public Func<object, string> ObjToStr;

		public Func<string, object> StrToObj;
	}
}
namespace VSM.Core.Camera
{
	internal struct RigSettings
	{
		public float Speed;

		public float FastMultiplier;

		public bool MoveRelativeToView;
	}
	internal sealed class CameraRig
	{
		public const float MaxPitch = 89f;

		public float Yaw;

		public float Pitch;

		public Vector3 Position;

		public Vector3 Velocity;

		public Vector3 ForwardVector => Forward(Yaw, Pitch);

		public Quaternion Rotation => Quaternion.Euler(Pitch, Yaw, 0f);

		public static Vector3 Forward(float yawDeg, float pitchDeg)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			float num = yawDeg * ((float)Math.PI / 180f);
			float num2 = pitchDeg * ((float)Math.PI / 180f);
			float num3 = Mathf.Cos(num2);
			return new Vector3(Mathf.Sin(num) * num3, 0f - Mathf.Sin(num2), Mathf.Cos(num) * num3);
		}

		public static Vector3 FlatForward(float yawDeg)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			float num = yawDeg * ((float)Math.PI / 180f);
			return new Vector3(Mathf.Sin(num), 0f, Mathf.Cos(num));
		}

		public static Vector3 Right(float yawDeg)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			float num = yawDeg * ((float)Math.PI / 180f);
			return new Vector3(Mathf.Cos(num), 0f, 0f - Mathf.Sin(num));
		}

		public void Reset(Vector3 position, Vector3 forward)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			Position = position;
			Velocity = Vector3.zero;
			SetFromDirection(forward);
		}

		public void SetFromDirection(Vector3 forward)
		{
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			if (((Vector3)(ref forward)).sqrMagnitude < 1E-08f)
			{
				Yaw = 0f;
				Pitch = 0f;
			}
			else
			{
				((Vector3)(ref forward)).Normalize();
				Yaw = Mathf.Repeat(Mathf.Atan2(forward.x, forward.z) * 57.29578f, 360f);
				Pitch = Mathf.Clamp((0f - Mathf.Asin(Mathf.Clamp(forward.y, -1f, 1f))) * 57.29578f, -89f, 89f);
			}
		}

		public void ApplyLook(Vector2 delta)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			Yaw = Mathf.Repeat(Yaw + delta.x, 360f);
			Pitch = Mathf.Clamp(Pitch - delta.y, -89f, 89f);
		}

		public Vector3 DesiredVelocity(Vector3 move, float vertical, bool fast, RigSettings settings)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: 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_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: 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_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			Vector3 val = (settings.MoveRelativeToView ? Forward(Yaw, Pitch) : FlatForward(Yaw));
			Vector3 val2 = Right(Yaw) * Mathf.Clamp(move.x, -1f, 1f) + val * Mathf.Clamp(move.z, -1f, 1f) + Vector3.up * Mathf.Clamp(vertical, -1f, 1f);
			if (((Vector3)(ref val2)).sqrMagnitude > 1f)
			{
				((Vector3)(ref val2)).Normalize();
			}
			float num = Mathf.Max(0f, settings.Speed) * (fast ? Mathf.Max(1f, settings.FastMultiplier) : 1f);
			return val2 * num;
		}

		public void Integrate(Vector3 desiredVelocity, float dt, float smoothing)
		{
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			if (!(dt <= 0f))
			{
				float num = ((smoothing <= 0f) ? 1f : (1f - Mathf.Exp((0f - dt) / smoothing)));
				Velocity = Vector3.Lerp(Velocity, desiredVelocity, num);
				Position += Velocity * dt;
			}
		}

		public static Vector3 ClampToSphere(Vector3 pos, Vector3 center, float radius)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: 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_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			Vector3 val = pos - center;
			float num = Mathf.Max(0f, radius);
			if (((Vector3)(ref val)).sqrMagnitude <= num * num)
			{
				return pos;
			}
			return center + ((Vector3)(ref val)).normalized * num;
		}
	}
	internal static class CameraWorld
	{
		public const float CollisionRadius = 0.25f;

		public static Vector3 Anchor(Player player)
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			Transform eye = ((Character)player).m_eye;
			return ((Object)(object)eye != (Object)null) ? eye.position : (((Component)player).transform.position + Vector3.up * 1.6f);
		}

		public static Vector3 Constrain(Vector3 from, Vector3 to, Vector3 anchor, float maxDistance, float clearance, GameCamera cam)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: 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_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: 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_0039: 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_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			Vector3 pos = CameraRig.ClampToSphere(to, anchor, maxDistance);
			pos = Lift(pos, clearance, cam);
			pos = CameraRig.ClampToSphere(pos, anchor, maxDistance + 1f);
			LayerMask blockCameraMask = cam.m_blockCameraMask;
			Vector3 val = (Overlaps(from, blockCameraMask) ? anchor : from);
			return Collide(val, pos, blockCameraMask);
		}

		public static Vector3 Lift(Vector3 pos, float clearance, GameCamera cam)
		{
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			clearance = Mathf.Max(0f, clearance);
			ZoneSystem instance = ZoneSystem.instance;
			float num = default(float);
			if ((Object)(object)instance != (Object)null && instance.GetGroundHeight(pos, ref num))
			{
				pos.y = Mathf.Max(pos.y, num + clearance);
			}
			float num2 = Floating.GetLiquidLevel(pos, 1f, (LiquidType)10);
			if ((Object)(object)instance != (Object)null && !Character.InInterior(pos))
			{
				num2 = Mathf.Max(num2, instance.m_waterLevel);
			}
			if (num2 > -9000f)
			{
				pos.y = Mathf.Max(pos.y, num2 + Mathf.Max(clearance, cam.m_minWaterDistance));
			}
			return pos;
		}

		public static bool Overlaps(Vector3 pos, LayerMask mask)
		{
			//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)
			return Physics.CheckSphere(pos, 0.225f, LayerMask.op_Implicit(mask), (QueryTriggerInteraction)1);
		}

		public static Vector3 Collide(Vector3 from, Vector3 to, LayerMask mask)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: 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_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: 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_0063: 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)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			Vector3 val = to - from;
			float magnitude = ((Vector3)(ref val)).magnitude;
			if (magnitude < 1E-05f)
			{
				return to;
			}
			Vector3 val2 = val / magnitude;
			RaycastHit val3 = default(RaycastHit);
			if (Physics.SphereCast(from, 0.25f, val2, ref val3, magnitude, LayerMask.op_Implicit(mask), (QueryTriggerInteraction)1))
			{
				return from + val2 * Mathf.Max(0f, ((RaycastHit)(ref val3)).distance - 0.02f);
			}
			return to;
		}
	}
	internal static class CameraLock
	{
		private const string Prefix = "vsm_camera_lock:";

		public static string Holder()
		{
			GameCamera instance = GameCamera.instance;
			if ((Object)(object)instance == (Object)null)
			{
				return null;
			}
			Transform transform = ((Component)instance).transform;
			for (int i = 0; i < transform.childCount; i++)
			{
				string name = ((Object)transform.GetChild(i)).name;
				if (name.StartsWith("vsm_camera_lock:", StringComparison.Ordinal))
				{
					return name.Substring("vsm_camera_lock:".Length);
				}
			}
			return null;
		}

		public static bool TryAcquire(string owner)
		{
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Expected O, but got Unknown
			GameCamera instance = GameCamera.instance;
			if ((Object)(object)instance == (Object)null)
			{
				return false;
			}
			string text = Holder();
			if (text != null)
			{
				return text == owner;
			}
			GameObject val = new GameObject("vsm_camera_lock:" + owner);
			val.transform.SetParent(((Component)instance).transform, false);
			return true;
		}

		public static void Release(string owner)
		{
			GameCamera instance = GameCamera.instance;
			if ((Object)(object)instance == (Object)null)
			{
				return;
			}
			Transform transform = ((Component)instance).transform;
			for (int num = transform.childCount - 1; num >= 0; num--)
			{
				Transform child = transform.GetChild(num);
				if (((Object)child).name == "vsm_camera_lock:" + owner)
				{
					Object.Destroy((Object)(object)((Component)child).gameObject);
					((Object)child).name = "vsm_camera_lock_released";
				}
			}
		}
	}
	internal sealed class BodyHider
	{
		private readonly List<Renderer> _hidden = new List<Renderer>();

		private float _nextScan;

		public void Update(Player player, bool hide)
		{
			if (!hide || (Object)(object)player == (Object)null)
			{
				Restore();
			}
			else
			{
				if (Time.unscaledTime < _nextScan)
				{
					return;
				}
				_nextScan = Time.unscaledTime + 0.5f;
				Renderer[] componentsInChildren = ((Component)player).GetComponentsInChildren<Renderer>(false);
				foreach (Renderer val in componentsInChildren)
				{
					if ((Object)(object)val != (Object)null && val.enabled && (val is SkinnedMeshRenderer || val is MeshRenderer))
					{
						val.enabled = false;
						_hidden.Add(val);
					}
				}
			}
		}

		public void Restore()
		{
			foreach (Renderer item in _hidden)
			{
				if ((Object)(object)item != (Object)null)
				{
					item.enabled = true;
				}
			}
			_hidden.Clear();
			_nextScan = 0f;
		}
	}
}
namespace System.Runtime.CompilerServices
{
	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
	internal sealed class IgnoresAccessChecksToAttribute : Attribute
	{
		public IgnoresAccessChecksToAttribute(string assemblyName)
		{
		}
	}
}