using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using FishNet.Connection;
using FishNet.Object;
using FishNet.Object.Synchronizing;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Newtonsoft.Json;
using TMPro;
using UnityEngine;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: IgnoresAccessChecksTo("Assembly-CSharp")]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("com.atomic.stackableitems")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("0.1.0.0")]
[assembly: AssemblyInformationalVersion("0.1.0")]
[assembly: AssemblyProduct("com.atomic.stackableitems")]
[assembly: AssemblyTitle("StackableItems")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.1.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

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

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

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

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace BepInEx
{
	[AttributeUsage(AttributeTargets.Class, Inherited = false, AllowMultiple = false)]
	[Conditional("CodeGeneration")]
	[Embedded]
	internal sealed class BepInAutoPluginAttribute : Attribute
	{
		public BepInAutoPluginAttribute(string? id = null, string? name = null, string? version = null)
		{
		}
	}
}
namespace BepInEx.Preloader.Core.Patching
{
	[AttributeUsage(AttributeTargets.Class, Inherited = false, AllowMultiple = false)]
	[Conditional("CodeGeneration")]
	[Embedded]
	internal sealed class PatcherAutoPluginAttribute : Attribute
	{
		public PatcherAutoPluginAttribute(string? id = null, string? name = null, string? version = null)
		{
		}
	}
}
namespace Microsoft.CodeAnalysis
{
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace StackableItems
{
	[BepInPlugin("com.atomic.stackableitems", "StackableItems", "0.1.0")]
	public class Plugin : BaseUnityPlugin
	{
		private Harmony harmony;

		public static ConfigEntry<int> MaxStackSize;

		public const string Id = "com.atomic.stackableitems";

		internal static ManualLogSource Log { get; private set; }

		public static string Name => "StackableItems";

		public static string Version => "0.1.0";

		private void Awake()
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Expected O, but got Unknown
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Expected O, but got Unknown
			Log = ((BaseUnityPlugin)this).Logger;
			MaxStackSize = ((BaseUnityPlugin)this).Config.Bind<int>("General", "Max Stack Size", 64, new ConfigDescription("The maximum amount of objects you can have in a given slot. The more you have, the more data can be tracked per player.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(1, 100), Array.Empty<object>()));
			harmony = new Harmony("com.atomic.stackableitems");
			harmony.PatchAll();
		}
	}
	public static class StackManager
	{
		public static Item ItemBeingStored;

		public static byte LastRemovedSlot = byte.MaxValue;

		public static Dictionary<ulong, Dictionary<byte, List<Item>>> ServerStacks = new Dictionary<ulong, Dictionary<byte, List<Item>>>();

		public static Dictionary<ulong, Dictionary<byte, List<Item>>> ClientStacks = new Dictionary<ulong, Dictionary<byte, List<Item>>>();

		public static int MaxStackSize => Plugin.MaxStackSize.Value;

		private static ulong GetSteamID(PlayerInventory inv)
		{
			Player player = inv._player;
			if (player == null)
			{
				return 0uL;
			}
			return player.SteamID;
		}

		public static int GetStackCount(PlayerInventory inv, byte index)
		{
			ulong steamID = GetSteamID(inv);
			if (steamID == 0L)
			{
				return 0;
			}
			if (((NetworkBehaviour)inv).IsServerInitialized && ServerStacks.TryGetValue(steamID, out Dictionary<byte, List<Item>> value) && value.TryGetValue(index, out var value2))
			{
				return value2.Count;
			}
			if (((NetworkBehaviour)inv).Owner != (NetworkConnection)null && ((NetworkBehaviour)inv).Owner.IsLocalClient && ClientStacks.TryGetValue(steamID, out Dictionary<byte, List<Item>> value3) && value3.TryGetValue(index, out var value4))
			{
				return value4.Count;
			}
			return 0;
		}

		public static void PushServerStack(PlayerInventory inv, byte index, Item item)
		{
			ulong steamID = GetSteamID(inv);
			if (steamID != 0L)
			{
				if (!ServerStacks.TryGetValue(steamID, out Dictionary<byte, List<Item>> value))
				{
					value = new Dictionary<byte, List<Item>>();
					ServerStacks[steamID] = value;
				}
				if (!value.TryGetValue(index, out var value2))
				{
					value2 = (value[index] = new List<Item>());
				}
				if (value2.Count < MaxStackSize - 1)
				{
					value2.Add(item);
				}
			}
		}

		public static Item PopServerStack(PlayerInventory inv, byte index)
		{
			ulong steamID = GetSteamID(inv);
			if (steamID == 0L)
			{
				return null;
			}
			if (ServerStacks.TryGetValue(steamID, out Dictionary<byte, List<Item>> value) && value.TryGetValue(index, out var value2) && value2.Count > 0)
			{
				Item result = value2[value2.Count - 1];
				value2.RemoveAt(value2.Count - 1);
				return result;
			}
			return null;
		}

		public static void SyncClientStack(PlayerInventory inv, byte index, Item newItem, Item oldItem)
		{
			ulong steamID = GetSteamID(inv);
			if (steamID != 0L)
			{
				if (!ClientStacks.TryGetValue(steamID, out Dictionary<byte, List<Item>> value))
				{
					value = new Dictionary<byte, List<Item>>();
					ClientStacks[steamID] = value;
				}
				if (!value.TryGetValue(index, out var value2))
				{
					value2 = (value[index] = new List<Item>());
				}
				if ((Object)(object)newItem == (Object)null)
				{
					value2.Clear();
				}
				else if (value2.Count > 0 && (Object)(object)value2[value2.Count - 1] == (Object)(object)newItem)
				{
					value2.RemoveAt(value2.Count - 1);
				}
				else if ((Object)(object)oldItem != (Object)null && (Object)(object)oldItem != (Object)(object)newItem)
				{
					value2.Add(oldItem);
				}
			}
		}
	}
	[Serializable]
	public class SavedPlayerStacks
	{
		public ulong SteamID { get; set; }

		public List<SavedItem> StackedItems { get; set; } = new List<SavedItem>();
	}
	[Serializable]
	public class StackSaveFile
	{
		public List<SavedPlayerStacks> Players { get; set; } = new List<SavedPlayerStacks>();
	}
	public static class StackSaveManager
	{
		private static readonly string SaveFolder = Path.Combine(Paths.ConfigPath, "StackableItems", "Saves");

		private static Dictionary<ulong, List<SavedItem>> PendingRestores = new Dictionary<ulong, List<SavedItem>>();

		public static void Save()
		{
			if (SaveManager.CurServerSave == null)
			{
				return;
			}
			foreach (Player player in PlayerManager.Players)
			{
				SavePlayer(player);
			}
		}

		public static void SavePlayer(Player player)
		{
			if (SaveManager.CurServerSave == null)
			{
				return;
			}
			StackSaveFile stackSaveFile = ReadFile(SaveManager.CurServerSave.Name);
			stackSaveFile.Players.RemoveAll((SavedPlayerStacks playerStacks) => playerStacks.SteamID == player.SteamID);
			SavedPlayerStacks savedPlayerStacks = new SavedPlayerStacks
			{
				SteamID = player.SteamID
			};
			if (StackManager.ServerStacks.TryGetValue(player.SteamID, out Dictionary<byte, List<Item>> value))
			{
				foreach (KeyValuePair<byte, List<Item>> item in value)
				{
					foreach (Item item2 in item.Value)
					{
						if ((Object)(object)item2 != (Object)null)
						{
							savedPlayerStacks.StackedItems.Add(SaveManager.ItemToSavedItem(item.Key, item2));
						}
					}
				}
			}
			if (savedPlayerStacks.StackedItems.Count > 0)
			{
				stackSaveFile.Players.Add(savedPlayerStacks);
			}
			Write(SaveManager.CurServerSave.Name, stackSaveFile);
		}

		public static void Load()
		{
			PendingRestores.Clear();
			if (SaveManager.CurServerSave == null)
			{
				return;
			}
			StackSaveFile stackSaveFile = ReadFile(SaveManager.CurServerSave.Name);
			foreach (SavedPlayerStacks player in stackSaveFile.Players)
			{
				PendingRestores[player.SteamID] = new List<SavedItem>(player.StackedItems);
			}
		}

		private static StackSaveFile ReadFile(string serverName)
		{
			string path = GetPath(serverName);
			if (!File.Exists(path))
			{
				return new StackSaveFile();
			}
			try
			{
				string text = File.ReadAllText(path);
				StackSaveFile stackSaveFile = JsonConvert.DeserializeObject<StackSaveFile>(text);
				return stackSaveFile ?? new StackSaveFile();
			}
			catch
			{
				return new StackSaveFile();
			}
		}

		public static List<SavedItem> GetPending(ulong steamID)
		{
			if (!PendingRestores.TryGetValue(steamID, out List<SavedItem> value))
			{
				return null;
			}
			PendingRestores.Remove(steamID);
			return value;
		}

		public static void SetStats(Item item, SavedItem savedItem)
		{
			item._cookness.Value = savedItem.Cookness;
			item._bettingMultiplier.Value = savedItem.BettingMultiplier;
			item._killScoreMultiplier.Value = savedItem.KillScoreMultiplier;
			item._curSkin.Value = savedItem.SkinIndex;
			if ((Object)(object)item._weapon != (Object)null)
			{
				item._weapon._attachments._syncedSight.Value = savedItem.Sight;
				item._weapon._attachments._syncedBarrelAttachment.Value = savedItem.BarrelAttachment;
				item._weapon._attachments._syncedBulletIndex.Value = savedItem.AmmoType;
				item._weapon._attachments._syncedExtendedMag.Value = savedItem.ExtendedMag;
				item._weapon._attachments._syncedLaserSight.Value = savedItem.LaserSight;
			}
			if ((Object)(object)item._melee != (Object)null)
			{
				item._melee._syncedSharpnessIndex.Value = savedItem.Sharpness;
			}
			if ((Object)(object)item._creature != (Object)null)
			{
				((Item)item._creature)._syncedRandomWeight.Value = savedItem.Weight;
			}
		}

		public static void Delete(string serverName)
		{
			string path = GetPath(serverName);
			if (File.Exists(path))
			{
				File.Delete(path);
			}
		}

		private static void Write(string serverName, StackSaveFile saveFile)
		{
			try
			{
				Directory.CreateDirectory(SaveFolder);
				string path = GetPath(serverName);
				string contents = JsonConvert.SerializeObject((object)saveFile, (Formatting)1);
				File.WriteAllText(path, contents);
			}
			catch
			{
			}
		}

		private static string GetPath(string serverName)
		{
			string text = serverName;
			char[] invalidFileNameChars = Path.GetInvalidFileNameChars();
			foreach (char oldChar in invalidFileNameChars)
			{
				text = text.Replace(oldChar, '_');
			}
			return Path.Combine(SaveFolder, text + ".json");
		}
	}
	[HarmonyPatch]
	public static class StackableItemsPatches
	{
		[HarmonyPrefix]
		[HarmonyPatch(typeof(PlayerInventory), "ServerTryStoreHeldItem")]
		public static void ServerTryStoreHeldItem_Prefix(Item item)
		{
			StackManager.ItemBeingStored = item;
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(PlayerInventory), "ServerTryStoreHeldItem")]
		public static void ServerTryStoreHeldItem_Postfix()
		{
			StackManager.ItemBeingStored = null;
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(PlayerInventory), "ResolveHeldItemReplacement")]
		public static void ResolveHeldItemReplacement_Prefix(Item item)
		{
			StackManager.ItemBeingStored = item;
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(PlayerInventory), "ResolveHeldItemReplacement")]
		public static void ResolveHeldItemReplacement_Postfix()
		{
			StackManager.ItemBeingStored = null;
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(PlayerInventory), "LocalTrySelectSlot")]
		public static void LocalTrySelectSlot_Prefix(PlayerInventory __instance)
		{
			StackManager.ItemBeingStored = __instance._player.Holding.HeldItem;
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(PlayerInventory), "LocalTrySelectSlot")]
		public static void LocalTrySelectSlot_Postfix()
		{
			StackManager.ItemBeingStored = null;
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(PlayerInventory), "UpdateHeldItem")]
		public static void UpdateHeldItem_Prefix(PlayerInventory __instance)
		{
			StackManager.ItemBeingStored = __instance._player.Holding.HeldItem;
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(PlayerInventory), "UpdateHeldItem")]
		public static void UpdateHeldItem_Postfix()
		{
			StackManager.ItemBeingStored = null;
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(PlayerInventory), "GetOpenSlot")]
		public static bool GetOpenSlot(PlayerInventory __instance, int selected, ref int __result)
		{
			if ((Object)(object)StackManager.ItemBeingStored != (Object)null)
			{
				string text = ((Object)StackManager.ItemBeingStored).name.Replace("(Clone)", "").Trim();
				for (byte b = 0; b < __instance._availableSlots.Count; b++)
				{
					Item val = __instance._items[b];
					if ((Object)(object)val != (Object)null)
					{
						string text2 = ((Object)val).name.Replace("(Clone)", "").Trim();
						int num = 1 + StackManager.GetStackCount(__instance, b);
						if (text2 == text && num < StackManager.MaxStackSize)
						{
							__result = b;
							return false;
						}
					}
				}
			}
			return true;
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(PlayerInventory), "AddItem")]
		public static bool AddItem(PlayerInventory __instance, byte index, Item item)
		{
			if (!((NetworkBehaviour)__instance).IsServerInitialized || (Object)(object)item == (Object)null)
			{
				return true;
			}
			Item val = __instance._items[index];
			__instance._items[index] = item;
			if ((Object)(object)val != (Object)null && (Object)(object)val != (Object)(object)item)
			{
				StackManager.PushServerStack(__instance, index, val);
			}
			return false;
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(PlayerInventory), "LoadFromSave")]
		public static void LoadFromSave(PlayerInventory __instance)
		{
			//IL_008d: 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)
			if (!((NetworkBehaviour)__instance).IsServerInitialized || (Object)(object)__instance._player == (Object)null)
			{
				return;
			}
			ulong steamID = __instance._player.SteamID;
			List<SavedItem> pending = StackSaveManager.GetPending(steamID);
			if (pending == null || pending.Count == 0)
			{
				return;
			}
			if (!StackManager.ServerStacks.TryGetValue(steamID, out Dictionary<byte, List<Item>> value))
			{
				value = new Dictionary<byte, List<Item>>();
				StackManager.ServerStacks[steamID] = value;
			}
			foreach (SavedItem item in pending)
			{
				Item spawnable = GameInfo.GetSpawnable(item.ItemID);
				if (!Object.op_Implicit((Object)(object)spawnable))
				{
					continue;
				}
				Item val = ItemManager.Instance.SpawnNewItem(spawnable, SpawnManager.PlayerSpawnPos, Quaternion.identity);
				StackSaveManager.SetStats(val, item);
				if ((Object)(object)val.Creature != (Object)null)
				{
					val.Creature.ServerKillOnSpawn();
					if (item.IsDripCreature)
					{
						val.Creature.SetDrip();
					}
				}
				val.SetSyncedHolder(__instance._player, true);
				val.PutInInventory();
				if (!value.TryGetValue(item.InventorySlot, out var value2))
				{
					value2 = new List<Item>();
					value[item.InventorySlot] = value2;
				}
				value2.Add(val);
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(PlayerInventory), "RemoveItem")]
		public static bool RemoveItem(PlayerInventory __instance, Item item)
		{
			if (!((NetworkBehaviour)__instance).IsServerInitialized || (Object)(object)item == (Object)null)
			{
				return true;
			}
			byte b = byte.MaxValue;
			foreach (KeyValuePair<byte, Item> item2 in __instance._items)
			{
				if ((Object)(object)item2.Value == (Object)(object)item)
				{
					b = item2.Key;
					break;
				}
			}
			StackManager.LastRemovedSlot = b;
			if (b != byte.MaxValue)
			{
				Item val = StackManager.PopServerStack(__instance, b);
				if ((Object)(object)val != (Object)null)
				{
					__instance._items[b] = val;
					return false;
				}
			}
			return true;
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(PlayerInventory), "RemoveItem")]
		public static void RemoveItem_Postfix(PlayerInventory __instance, Item item)
		{
			if (StackManager.LastRemovedSlot != byte.MaxValue && ((NetworkBehaviour)__instance).Owner.IsLocalClient)
			{
				__instance.ApplySlot((int)StackManager.LastRemovedSlot);
				StackManager.LastRemovedSlot = byte.MaxValue;
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(Item), "DestroyByEating")]
		public static void EatItem(Item __instance)
		{
			Player lastHolder = __instance.LastHolder;
			PlayerInventory val = ((lastHolder != null) ? lastHolder.Inventory : null);
			if ((Object)(object)val != (Object)null)
			{
				val.ApplySlot(val._localCurSlot);
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(PlayerInventory), "ServerDropAll")]
		public static void ServerDropAll(PlayerInventory __instance, Vector3 pos, Quaternion rot)
		{
			//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)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: 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_00c3: 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_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: 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_00ae: 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_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0103: Unknown result type (might be due to invalid IL or missing references)
			//IL_0108: Unknown result type (might be due to invalid IL or missing references)
			if (!((NetworkBehaviour)__instance).IsServerInitialized)
			{
				return;
			}
			Player player = __instance._player;
			ulong num = ((player != null) ? player.SteamID : 0);
			if (num == 0L || !StackManager.ServerStacks.TryGetValue(num, out Dictionary<byte, List<Item>> value))
			{
				return;
			}
			Vector3 val = Vector3.zero;
			foreach (KeyValuePair<byte, List<Item>> item in value)
			{
				foreach (Item item2 in item.Value)
				{
					if ((Object)(object)item2 != (Object)null)
					{
						val += Vector3.up * item2.ModelHeight;
						item2.SetSyncedHolder((Player)null, false);
						if (!item2.RigidbodySync.IsSimulatedLocal)
						{
							item2.RigidbodySync.StartSimulateLocal(pos + val, rot);
						}
						else
						{
							((Component)item2).transform.position = pos + val;
							item2.Rig.linearVelocity = Vector3.zero;
							item2.Rig.angularVelocity = Vector3.zero;
						}
						val += Vector3.up * item2.ModelHeight;
					}
				}
				item.Value.Clear();
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(PlayerInventory), "OnItemsChange")]
		public static void OnItemsChange(PlayerInventory __instance, SyncDictionaryOperation op, byte index, Item item, bool asServer)
		{
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Invalid comparison between Unknown and I4
			if (!asServer && (int)op == 3 && ((NetworkBehaviour)__instance).Owner != (NetworkConnection)null && ((NetworkBehaviour)__instance).Owner.IsLocalClient)
			{
				Item item2 = __instance._itemSlots[index].Item;
				StackManager.SyncClientStack(__instance, index, item, item2);
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(PlayerInventory), "OnStopServer")]
		public static void OnStopServer(PlayerInventory __instance)
		{
			if ((Object)(object)__instance._player != (Object)null)
			{
				StackSaveManager.SavePlayer(__instance._player);
				ulong steamID = __instance._player.SteamID;
				StackManager.ServerStacks.Remove(steamID);
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(PlayerInventory), "OnStopClient")]
		public static void OnStopClient(PlayerInventory __instance)
		{
			Player player = __instance._player;
			ulong num = ((player != null) ? player.SteamID : 0);
			if (num != 0L)
			{
				StackManager.ClientStacks.Remove(num);
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(InventorySlot), "SetItem")]
		public static void SetItem(InventorySlot __instance, Item item)
		{
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)item == (Object)null)
			{
				((TMP_Text)__instance._itemText).text = "";
				return;
			}
			PlayerInventory inventory = Player.LocalPlayer.Inventory;
			if ((Object)(object)inventory == (Object)null)
			{
				return;
			}
			byte b = byte.MaxValue;
			for (byte b2 = 0; b2 < inventory._itemSlots.Count; b2++)
			{
				if ((Object)(object)inventory._itemSlots[b2] == (Object)(object)__instance)
				{
					b = b2;
					break;
				}
			}
			if (b == byte.MaxValue)
			{
				return;
			}
			int num = StackManager.GetStackCount(inventory, b) + 1;
			if (num > 1)
			{
				if ((Object)(object)item.Mesh == (Object)null)
				{
					((TMP_Text)__instance._itemText).text = $"{((Object)item).name} ({num}x)";
				}
				else
				{
					((TMP_Text)__instance._itemText).text = $"{num}x";
					((Graphic)__instance._itemText).color = Color.white;
				}
				((Component)__instance._itemText).gameObject.SetActive(true);
			}
			else if ((Object)(object)item.Mesh != (Object)null)
			{
				((TMP_Text)__instance._itemText).text = "";
			}
			((TMP_Text)__instance._itemText).transform.SetAsLastSibling();
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(SaveManager), "SaveServer")]
		public static void SaveServer()
		{
			StackSaveManager.Save();
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(SaveManager), "OnServerLoaded")]
		public static void OnServerLoaded()
		{
			StackSaveManager.Load();
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(SaveManager), "DeleteServer")]
		public static void DeleteServer()
		{
			if (SaveManager.CurServerSave != null)
			{
				StackSaveManager.Delete(SaveManager.CurServerSave.Name);
			}
		}
	}
}
namespace System.Diagnostics.CodeAnalysis
{
	[AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class ConstantExpectedAttribute : Attribute
	{
		public object? Min { get; set; }

		public object? Max { get; set; }
	}
	[AttributeUsage(AttributeTargets.Assembly | AttributeTargets.Module | AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Enum | AttributeTargets.Constructor | AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Interface | AttributeTargets.Delegate, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class ExperimentalAttribute : Attribute
	{
		public string DiagnosticId { get; }

		public string? UrlFormat { get; set; }

		public ExperimentalAttribute(string diagnosticId)
		{
			DiagnosticId = diagnosticId;
		}
	}
	[AttributeUsage(AttributeTargets.Method | AttributeTargets.Property, Inherited = false, AllowMultiple = true)]
	[ExcludeFromCodeCoverage]
	internal sealed class MemberNotNullAttribute : Attribute
	{
		public string[] Members { get; }

		public MemberNotNullAttribute(string member)
		{
			Members = new string[1] { member };
		}

		public MemberNotNullAttribute(params string[] members)
		{
			Members = members;
		}
	}
	[AttributeUsage(AttributeTargets.Method | AttributeTargets.Property, Inherited = false, AllowMultiple = true)]
	[ExcludeFromCodeCoverage]
	internal sealed class MemberNotNullWhenAttribute : Attribute
	{
		public bool ReturnValue { get; }

		public string[] Members { get; }

		public MemberNotNullWhenAttribute(bool returnValue, string member)
		{
			ReturnValue = returnValue;
			Members = new string[1] { member };
		}

		public MemberNotNullWhenAttribute(bool returnValue, params string[] members)
		{
			ReturnValue = returnValue;
			Members = members;
		}
	}
	[AttributeUsage(AttributeTargets.Constructor, AllowMultiple = false, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class SetsRequiredMembersAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Parameter, AllowMultiple = false, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class StringSyntaxAttribute : Attribute
	{
		public const string CompositeFormat = "CompositeFormat";

		public const string DateOnlyFormat = "DateOnlyFormat";

		public const string DateTimeFormat = "DateTimeFormat";

		public const string EnumFormat = "EnumFormat";

		public const string GuidFormat = "GuidFormat";

		public const string Json = "Json";

		public const string NumericFormat = "NumericFormat";

		public const string Regex = "Regex";

		public const string TimeOnlyFormat = "TimeOnlyFormat";

		public const string TimeSpanFormat = "TimeSpanFormat";

		public const string Uri = "Uri";

		public const string Xml = "Xml";

		public string Syntax { get; }

		public object?[] Arguments { get; }

		public StringSyntaxAttribute(string syntax)
		{
			Syntax = syntax;
			Arguments = new object[0];
		}

		public StringSyntaxAttribute(string syntax, params object?[] arguments)
		{
			Syntax = syntax;
			Arguments = arguments;
		}
	}
	[AttributeUsage(AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Parameter, AllowMultiple = false, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class UnscopedRefAttribute : Attribute
	{
	}
}
namespace System.Runtime.Versioning
{
	[AttributeUsage(AttributeTargets.Assembly | AttributeTargets.Module | AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Enum | AttributeTargets.Constructor | AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Interface | AttributeTargets.Delegate, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class RequiresPreviewFeaturesAttribute : Attribute
	{
		public string? Message { get; }

		public string? Url { get; set; }

		public RequiresPreviewFeaturesAttribute()
		{
		}

		public RequiresPreviewFeaturesAttribute(string? message)
		{
			Message = message;
		}
	}
}
namespace System.Runtime.CompilerServices
{
	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
	internal sealed class IgnoresAccessChecksToAttribute : Attribute
	{
		public IgnoresAccessChecksToAttribute(string assemblyName)
		{
		}
	}
	[AttributeUsage(AttributeTargets.Parameter, AllowMultiple = false, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class CallerArgumentExpressionAttribute : Attribute
	{
		public string ParameterName { get; }

		public CallerArgumentExpressionAttribute(string parameterName)
		{
			ParameterName = parameterName;
		}
	}
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Interface, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class CollectionBuilderAttribute : Attribute
	{
		public Type BuilderType { get; }

		public string MethodName { get; }

		public CollectionBuilderAttribute(Type builderType, string methodName)
		{
			BuilderType = builderType;
			MethodName = methodName;
		}
	}
	[AttributeUsage(AttributeTargets.All, AllowMultiple = true, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class CompilerFeatureRequiredAttribute : Attribute
	{
		public const string RefStructs = "RefStructs";

		public const string RequiredMembers = "RequiredMembers";

		public string FeatureName { get; }

		public bool IsOptional { get; set; }

		public CompilerFeatureRequiredAttribute(string featureName)
		{
			FeatureName = featureName;
		}
	}
	[AttributeUsage(AttributeTargets.Parameter, AllowMultiple = false, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class InterpolatedStringHandlerArgumentAttribute : Attribute
	{
		public string[] Arguments { get; }

		public InterpolatedStringHandlerArgumentAttribute(string argument)
		{
			Arguments = new string[1] { argument };
		}

		public InterpolatedStringHandlerArgumentAttribute(params string[] arguments)
		{
			Arguments = arguments;
		}
	}
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct, AllowMultiple = false, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class InterpolatedStringHandlerAttribute : Attribute
	{
	}
	[EditorBrowsable(EditorBrowsableState.Never)]
	[ExcludeFromCodeCoverage]
	internal static class IsExternalInit
	{
	}
	[AttributeUsage(AttributeTargets.Method, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class ModuleInitializerAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Constructor | AttributeTargets.Method | AttributeTargets.Property, AllowMultiple = false, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class OverloadResolutionPriorityAttribute : Attribute
	{
		public int Priority { get; }

		public OverloadResolutionPriorityAttribute(int priority)
		{
			Priority = priority;
		}
	}
	[AttributeUsage(AttributeTargets.Parameter, Inherited = true, AllowMultiple = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class ParamCollectionAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Property | AttributeTargets.Field, AllowMultiple = false, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class RequiredMemberAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
	[EditorBrowsable(EditorBrowsableState.Never)]
	[ExcludeFromCodeCoverage]
	internal sealed class RequiresLocationAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Module | AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Constructor | AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Event | AttributeTargets.Interface, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class SkipLocalsInitAttribute : Attribute
	{
	}
}