Decompiled source of SelfSortingStorage v1.0.9

Get the Thunderstore App

Easily install and manage your mods with the Thunderstore App!
Get App
Decompiled source of SelfSortingStorage v1.0.9

plugins/SelfSortingStorage.dll

Decompiled a week ago
Download (142.3 KB)
The result has been truncated due to the large size, download it to view full contents!
using System;
using System.Collections;
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.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using GameNetcodeStuff;
using GeneralImprovements.API;
using HarmonyLib;
using LethalLib.Extras;
using LethalLib.Modules;
using Microsoft.CodeAnalysis;
using Newtonsoft.Json;
using SelfSortingStorage.Cupboard;
using SelfSortingStorage.NetcodePatcher;
using SelfSortingStorage.Utils;
using TMPro;
using Unity.Netcode;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: IgnoresAccessChecksTo("Assembly-CSharp")]
[assembly: AssemblyCompany("SelfSortingStorage")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+acdc176c780e62ff1b18eb808765a80171bc172c")]
[assembly: AssemblyProduct("SelfSortingStorage")]
[assembly: AssemblyTitle("SelfSortingStorage")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[module: NetcodePatchedAssembly]
internal class <Module>
{
	static <Module>()
	{
	}
}
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

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

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

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
}
namespace SelfSortingStorage
{
	internal class Config
	{
		public bool GeneralImprovements = false;

		public readonly Dictionary<int, int> rowsOrder = new Dictionary<int, int>();

		public readonly List<string> itemsBlacklist = new List<string>();

		public readonly ConfigEntry<bool> enableSaving;

		public readonly ConfigEntry<bool> allowScrapItems;

		public readonly ConfigEntry<bool> scanNode;

		public readonly ConfigEntry<string> cupboardColor;

		public readonly ConfigEntry<string> boxPosition;

		public readonly ConfigEntry<bool> rescaleItems;

		public readonly ConfigEntry<bool> perfectRescale;

		public readonly ConfigEntry<string> rowsOrderStr;

		public readonly ConfigEntry<string> blacklistStr;

		public readonly ConfigEntry<int> cupboardPrice;

		public readonly ConfigEntry<bool> wideVersion;

		public readonly ConfigEntry<bool> cozyLights;

		public readonly ConfigEntry<bool> resetButton;

		public readonly ConfigEntry<int> customScreenPos;

		public readonly ConfigEntry<bool> verboseLogging;

		public Config(ConfigFile cfg)
		{
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Expected O, but got Unknown
			cfg.SaveOnConfigSet = false;
			enableSaving = cfg.Bind<bool>("General", "Save items", true, "Allows stored items to be saved in the host player's current save file.");
			allowScrapItems = cfg.Bind<bool>("General", "Allow Scrap items", true, "Allows scrap items to be stored in the Smart Cupboard.");
			scanNode = cfg.Bind<bool>("General", "Scan Node", true, "Adds a scan node on the storage box.");
			cupboardColor = cfg.Bind<string>("General", "Cupboard Color", "#000E57", "Customize the color of the storage, default color is dark blue.");
			boxPosition = cfg.Bind<string>("Storage", "Box position", "R", new ConfigDescription("Adjust the position of the storage box, this can be 'L' for left or 'R' for right.", (AcceptableValueBase)(object)new AcceptableValueList<string>(new string[2] { "L", "R" }), Array.Empty<object>()));
			rescaleItems = cfg.Bind<bool>("Storage", "Rescale big items", true, "Big items will be rescaled when stored in the Smart Cupboard (based on their collider volume).");
			perfectRescale = cfg.Bind<bool>("Storage", "Perfect rescale", true, "Change the rescale algorithm to have items perfectly rescaled when stored (based on their collider max size).");
			rowsOrderStr = cfg.Bind<string>("Storage", "Rows order", "1,2,3,4", "Specify the order of items placement in the storage. Each number represents a shelve of the storage from top to bottom and the first one to be filled will be the number '1'.\nExample: Having an order of '1,2,3,4' will fill items from top to bottom, and having '3,1,2,4' will fill the middle shelves first.\nDON'T CHANGE THIS CONFIG WHEN THE SSS IS ALREADY UNLOCKED, a fresh save is required to avoid bad things happening (or press the Reset Button).");
			blacklistStr = cfg.Bind<string>("Storage", "Items Blacklist", "clipboard,Sticky note,Utility Belt", "Comma separated list of items names that will be rejected from the storage.");
			cupboardPrice = cfg.Bind<int>("Shop", "Price", 20, "The price of the Smart Cupboard in the store.");
			wideVersion = cfg.Bind<bool>("Upgrades", "Wide Cupboard", false, "Activate the S4 upgrade, turns the Smart Cupboard into a wider version.\nDON'T CHANGE THIS CONFIG WHEN THE SSS IS ALREADY UNLOCKED, a fresh save is required to avoid bad things happening (or press the Reset Button).");
			cozyLights = cfg.Bind<bool>("Upgrades", "Cozy Lights", true, "Activate the cozy lights upgrade, adds some lights on the shelves and a button to turn them on and off.");
			resetButton = cfg.Bind<bool>("Upgrades", "Reset Button", false, "Activate the soft reset upgrade, adds the 'button of death' on the side of the storage that you can press to clear every stored items in the SSS.\nPressing this button will effectively destroy everything so you shouldn't have the need to activate this unless you really want a way to reset the storage without being fired.");
			customScreenPos = cfg.Bind<int>("Upgrades", "SSS Screen position", 0, "If GeneralImprovements is installed and this value is not 0, then this mod will display SSS items on the desired screen. In GI config you need to set 'UseBetterMonitors = true', then set to 'None' the screen that will display the SSS items, then provide the screen position here to make it work.");
			verboseLogging = cfg.Bind<bool>("Logs", "Verbose logs", false, "Enable more explicit logs in the console (for debug reasons).");
			cfg.Save();
			cfg.SaveOnConfigSet = true;
		}

		public void SetupCustomConfigs()
		{
			if (Chainloader.PluginInfos.ContainsKey("ShaosilGaming.GeneralImprovements"))
			{
				GeneralImprovements = true;
			}
			if (!GeneralImprovements)
			{
				Plugin.logger.LogError((object)"GeneralImprovements is not installed! The mod will still work but you may notice some item rotation issues.");
			}
			if (!string.IsNullOrEmpty(blacklistStr.Value))
			{
				foreach (string item in from s in blacklistStr.Value.Split(',')
					select s.Trim())
				{
					itemsBlacklist.Add(item);
				}
				if (itemsBlacklist.Count != 0)
				{
					RegisterBlacklist();
				}
			}
			if (rowsOrderStr.Value == (string)((ConfigEntryBase)rowsOrderStr).DefaultValue)
			{
				return;
			}
			int num = 0;
			foreach (string item2 in from s in rowsOrderStr.Value.Split(',')
				select s.Trim())
			{
				if (!int.TryParse(item2, out var result) || result <= 0 || result > 4 || num >= 4)
				{
					break;
				}
				rowsOrder[result] = num++;
			}
			if (rowsOrder.Count != 4 || rowsOrder.Keys.Distinct().Count() != 4)
			{
				Plugin.logger.LogWarning((object)"Invalid 'Rows order' config value. Default order will be used.");
				rowsOrder.Clear();
			}
		}

		private void RegisterBlacklist()
		{
			SmartCupboard.AddTriggerValidation(BlacklistValidation, "[Item blacklisted]");
		}

		private bool BlacklistValidation(PlayerControllerB player)
		{
			GrabbableObject item = player.currentlyHeldObjectServer;
			if (itemsBlacklist.Exists((string i) => i == item.itemProperties.itemName))
			{
				return false;
			}
			return true;
		}
	}
	[BepInPlugin("zigzag.SelfSortingStorage", "SelfSortingStorage", "1.0.9")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public class Plugin : BaseUnityPlugin
	{
		private const string GUID = "zigzag.SelfSortingStorage";

		private const string NAME = "SelfSortingStorage";

		private const string VERSION = "1.0.9";

		public static Plugin instance;

		public static ManualLogSource logger;

		private readonly Harmony harmony = new Harmony("zigzag.SelfSortingStorage");

		internal const string VANILLA_NAME = "LethalCompanyGame";

		internal static readonly List<(Func<PlayerControllerB, bool>, string)> spTriggerValidations = new List<(Func<PlayerControllerB, bool>, string)>();

		internal static Config config { get; private set; } = null;


		internal int ROWS_LENGTH { get; private set; } = 4;


		private void HarmonyPatchAll()
		{
			harmony.PatchAll();
		}

		private void ReplaceTransform(GameObject prefab, string originName, string destinationName)
		{
			//IL_0035: 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)
			Transform val = prefab.transform.Find(originName);
			Transform val2 = prefab.transform.Find(destinationName);
			if ((Object)(object)val != (Object)null && (Object)(object)val2 != (Object)null)
			{
				val.position = val2.position;
				val.rotation = val2.rotation;
			}
		}

		private void Awake()
		{
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			instance = this;
			logger = ((BaseUnityPlugin)this).Logger;
			string text = Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), "selfsortingstorage");
			AssetBundle val = AssetBundle.LoadFromFile(text);
			string text2 = "Assets/Data/_Misc/";
			UnlockableItemDef val2 = val.LoadAsset<UnlockableItemDef>(text2 + "SSS_Module/SSSModuleUnlockable.asset");
			config = new Config(((BaseUnityPlugin)this).Config);
			config.SetupCustomConfigs();
			Effects.SetupNetwork();
			if (config.wideVersion.Value)
			{
				GameObject prefabObject = val.LoadAsset<GameObject>(text2 + "SSS_Module/SSS_Module_WideVariant.prefab");
				val2.unlockable.prefabObject = prefabObject;
				ROWS_LENGTH = 7;
			}
			GameObject prefabObject2 = val2.unlockable.prefabObject;
			Color color = default(Color);
			ColorUtility.TryParseHtmlString(config.cupboardColor.Value, ref color);
			((Renderer)prefabObject2.GetComponent<MeshRenderer>()).materials[0].color = color;
			if (!config.scanNode.Value)
			{
				Transform val3 = prefabObject2.transform.Find("ChutePosition/ActualPos/ScanNode");
				if (val3 != null)
				{
					((Component)val3).gameObject.SetActive(false);
				}
			}
			if (!config.resetButton.Value)
			{
				Transform val4 = prefabObject2.transform.Find("DeathButtonPosition");
				if (val4 != null)
				{
					((Component)val4).gameObject.SetActive(false);
				}
			}
			if (!config.cozyLights.Value)
			{
				Transform val5 = prefabObject2.transform.Find("Lights");
				if (val5 != null)
				{
					((Component)val5).gameObject.SetActive(false);
				}
			}
			if (config.boxPosition.Value == "R")
			{
				ReplaceTransform(prefabObject2, "ChutePosition/ActualPos", "ChutePosition/Pos2");
				if (config.resetButton.Value)
				{
					ReplaceTransform(prefabObject2, "DeathButtonPosition/ActualPos", "DeathButtonPosition/Pos2");
				}
				if (config.cozyLights.Value)
				{
					ReplaceTransform(prefabObject2, "Lights/LightsButtonPosition/ActualPos", "Lights/LightsButtonPosition/Pos2");
				}
			}
			NetworkPrefabs.RegisterNetworkPrefab(prefabObject2);
			Utilities.FixMixerGroups(prefabObject2);
			Unlockables.RegisterUnlockable(val2, config.cupboardPrice.Value, (StoreType)1);
			HarmonyPatchAll();
			logger.LogInfo((object)"SelfSortingStorage is loaded !");
		}
	}
}
namespace SelfSortingStorage.Utils
{
	internal class Effects
	{
		public class ItemNetworkReference
		{
			public NetworkObjectReference netObjectRef;

			public int value;

			public int save;

			public ItemNetworkReference(NetworkObjectReference netObjectRef, int value, int save)
			{
				//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)
				this.netObjectRef = netObjectRef;
				this.value = value;
				this.save = save;
			}
		}

		[CompilerGenerated]
		private sealed class <FadeOutAudio>d__4 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public AudioSource source;

			public float time;

			public bool specialStop;

			private float <volume>5__1;

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

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

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

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

			private bool MoveNext()
			{
				//IL_002f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0039: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (object)new WaitForEndOfFrame();
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<volume>5__1 = source.volume;
					break;
				case 2:
					<>1__state = -1;
					break;
				}
				if (source.volume > 0f)
				{
					AudioSource obj = source;
					obj.volume -= <volume>5__1 * Time.deltaTime / time;
					if (!specialStop || !(source.volume <= 0.04f))
					{
						<>2__current = null;
						<>1__state = 2;
						return true;
					}
				}
				source.Stop();
				source.volume = <volume>5__1;
				return false;
			}

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

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

		[CompilerGenerated]
		private sealed class <SyncItem>d__8 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public NetworkObjectReference itemRef;

			public SmartCupboard cupboard;

			public int spawnIndex;

			public int value;

			public int save;

			private NetworkObject <itemNetObject>5__1;

			private float <startTime>5__2;

			private GrabbableObject <component>5__3;

			private Transform <parent>5__4;

			private Vector3 <targetPosition>5__5;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<itemNetObject>5__1 = null;
				<component>5__3 = null;
				<parent>5__4 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0115: 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_013e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0143: Unknown result type (might be due to invalid IL or missing references)
				//IL_0148: Unknown result type (might be due to invalid IL or missing references)
				//IL_0190: Unknown result type (might be due to invalid IL or missing references)
				//IL_0195: Unknown result type (might be due to invalid IL or missing references)
				//IL_01a6: 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_0049: Unknown result type (might be due to invalid IL or missing references)
				//IL_0053: Expected O, but got Unknown
				//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c1: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<itemNetObject>5__1 = null;
					<startTime>5__2 = Time.realtimeSinceStartup;
					goto IL_0064;
				case 1:
					<>1__state = -1;
					goto IL_0064;
				case 2:
					{
						<>1__state = -1;
						<component>5__3 = ((Component)<itemNetObject>5__1).GetComponent<GrabbableObject>();
						if (!((NetworkBehaviour)<component>5__3).IsServer)
						{
							cupboard.GetPlacePosition(spawnIndex, out <parent>5__4, out Vector3 _, out Quaternion _);
							<targetPosition>5__5 = Vector3.zero + <component>5__3.itemProperties.verticalOffset * new Vector3(0f, 0f, 1f);
							<component>5__3.parentObject = null;
							((Component)<component>5__3).transform.SetParent(<parent>5__4 ?? StartOfRound.Instance.elevatorTransform, true);
							<component>5__3.startFallingPosition = ((Component)<component>5__3).transform.localPosition;
							((Component)<component>5__3).transform.localPosition = <targetPosition>5__5;
							<component>5__3.targetFloorPosition = <targetPosition>5__5;
							<component>5__3.reachedFloorTarget = true;
							<component>5__3.hasHitGround = true;
							<parent>5__4 = null;
						}
						<component>5__3.isInElevator = true;
						<component>5__3.isInShipRoom = true;
						<component>5__3.fallTime = 0f;
						if (<component>5__3.itemProperties.isScrap)
						{
							<component>5__3.SetScrapValue(value);
						}
						if (<component>5__3.itemProperties.saveItemVariable)
						{
							<component>5__3.LoadItemSaveData(save);
						}
						return false;
					}
					IL_0064:
					if (Time.realtimeSinceStartup - <startTime>5__2 < 8f && !((NetworkObjectReference)(ref itemRef)).TryGet(ref <itemNetObject>5__1, (NetworkManager)null))
					{
						<>2__current = (object)new WaitForSeconds(0.03f);
						<>1__state = 1;
						return true;
					}
					if ((Object)(object)<itemNetObject>5__1 == (Object)null)
					{
						Plugin.logger.LogError((object)"Error while trying to sync the item.");
						return false;
					}
					<>2__current = (object)new WaitForEndOfFrame();
					<>1__state = 2;
					return true;
				}
			}

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

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

		public static void SetupNetwork()
		{
			IEnumerable<Type> enumerable;
			try
			{
				enumerable = Assembly.GetExecutingAssembly().GetTypes();
			}
			catch (ReflectionTypeLoadException ex)
			{
				enumerable = ex.Types.Where((Type t) => t != null);
			}
			foreach (Type item in enumerable)
			{
				MethodInfo[] methods = item.GetMethods(BindingFlags.Instance | BindingFlags.Static | BindingFlags.NonPublic);
				MethodInfo[] array = methods;
				foreach (MethodInfo methodInfo in array)
				{
					object[] customAttributes = methodInfo.GetCustomAttributes(typeof(RuntimeInitializeOnLoadMethodAttribute), inherit: false);
					if (customAttributes.Length != 0)
					{
						methodInfo.Invoke(null, null);
					}
				}
			}
		}

		public static void Message(string title, string bottom, bool warning = false)
		{
			HUDManager.Instance.DisplayTip(title, bottom, warning, false, "LC_Tip1");
		}

		public static void SetScreenText(int screenID, string text)
		{
			MonitorsAPI.GetMonitorAtIndex(screenID).QueueRender(text);
		}

		[IteratorStateMachine(typeof(<FadeOutAudio>d__4))]
		public static IEnumerator FadeOutAudio(AudioSource source, float time, bool specialStop = false)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <FadeOutAudio>d__4(0)
			{
				source = source,
				time = time,
				specialStop = specialStop
			};
		}

		public static bool IsTriggerValid(PlayerControllerB player, out string notValidText)
		{
			notValidText = "[Nothing to store]";
			if (player.isHoldingObject && !player.isGrabbingObjectAnimation && (Object)(object)player.currentlyHeldObjectServer != (Object)null)
			{
				if (!StartOfRound.Instance.inShipPhase && (StartOfRound.Instance.shipIsLeaving || !StartOfRound.Instance.shipHasLanded))
				{
					notValidText = "[Wait for ship to " + (StartOfRound.Instance.shipIsLeaving ? "leave" : "land") + "]";
					return false;
				}
				if (player.currentlyHeldObjectServer.itemProperties.itemName == "Body")
				{
					notValidText = "[Bodies not allowed]";
					return false;
				}
				if (player.currentlyHeldObjectServer.itemProperties.itemName == "Stun grenade")
				{
					GrabbableObject currentlyHeldObjectServer = player.currentlyHeldObjectServer;
					StunGrenadeItem val = (StunGrenadeItem)(object)((currentlyHeldObjectServer is StunGrenadeItem) ? currentlyHeldObjectServer : null);
					if (val != null && val.hasExploded)
					{
						notValidText = "[Exploded grenades not allowed]";
						return false;
					}
				}
				if (player.currentlyHeldObjectServer.itemProperties.itemName == "Belt bag")
				{
					notValidText = "[Belt bags not compatible]";
					return false;
				}
				if (!Plugin.config.allowScrapItems.Value && player.currentlyHeldObjectServer.itemProperties.isScrap)
				{
					notValidText = "[Scraps not allowed]";
					return false;
				}
				foreach (var spTriggerValidation in Plugin.spTriggerValidations)
				{
					if (!spTriggerValidation.Item1(player))
					{
						notValidText = spTriggerValidation.Item2;
						return false;
					}
				}
				return true;
			}
			return false;
		}

		public static Item? GetItem(string id)
		{
			string[] idParts = id.Split('/');
			if (idParts == null || idParts.Length <= 1)
			{
				return null;
			}
			if (idParts[0] == "LethalCompanyGame")
			{
				return ((IEnumerable<Item>)StartOfRound.Instance.allItemsList.itemsList).FirstOrDefault((Func<Item, bool>)((Item i) => i.itemName.Equals(idParts[1])));
			}
			return SmartMemory.CacheItems.GetValueOrDefault(id);
		}

		public static ItemNetworkReference SpawnItem(Item item, SmartCupboard cupboard, int spawnIndex, int value = 0, int save = 0)
		{
			//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_0042: 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_0059: 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)
			cupboard.GetPlacePosition(spawnIndex, out Transform parent, out Vector3 position, out Quaternion rotation);
			GameObject val = Object.Instantiate<GameObject>(item.spawnPrefab, position, rotation, parent ?? StartOfRound.Instance.elevatorTransform);
			GrabbableObject component = val.GetComponent<GrabbableObject>();
			((Component)component).transform.rotation = Quaternion.Euler(component.itemProperties.restingRotation);
			((Component)component).transform.localRotation = rotation;
			component.fallTime = 1f;
			component.hasHitGround = true;
			component.reachedFloorTarget = true;
			component.isInElevator = true;
			component.isInShipRoom = true;
			if (component.itemProperties.isScrap)
			{
				component.SetScrapValue(value);
			}
			if (component.itemProperties.saveItemVariable)
			{
				component.LoadItemSaveData(save);
			}
			((NetworkBehaviour)component).NetworkObject.Spawn(false);
			return new ItemNetworkReference(NetworkObjectReference.op_Implicit(val.GetComponent<NetworkObject>()), value, component.itemProperties.saveItemVariable ? component.GetItemDataToSave() : save);
		}

		[IteratorStateMachine(typeof(<SyncItem>d__8))]
		public static IEnumerator SyncItem(NetworkObjectReference itemRef, SmartCupboard cupboard, int spawnIndex, int value, int save)
		{
			//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)
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <SyncItem>d__8(0)
			{
				itemRef = itemRef,
				cupboard = cupboard,
				spawnIndex = spawnIndex,
				value = value,
				save = save
			};
		}

		private static bool ShouldRescale(Vector3 size, out float factor)
		{
			//IL_0089: 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_00a2: 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_0022: 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_003e: 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_0030: 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_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: 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_005c: Unknown result type (might be due to invalid IL or missing references)
			factor = 100f;
			if (Plugin.config.perfectRescale.Value)
			{
				float num = ((size.x > size.y && size.x > size.z) ? size.x : ((size.y > size.x && size.y > size.z) ? size.y : size.z));
				if (num > 0.25f)
				{
					factor = 21f / num;
					return true;
				}
			}
			else
			{
				float num2 = size.x * 2f * (size.y * 2f) * (size.z * 2f);
				if (num2 > 0.08f)
				{
					factor = ((num2 < 0.5f) ? (7f / num2) : 20f);
					return true;
				}
			}
			return false;
		}

		public static void RescaleItemIfTooBig(GrabbableObject component)
		{
			//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_001f: Unknown result type (might be due to invalid IL or missing references)
			BoxCollider component2 = ((Component)component).GetComponent<BoxCollider>();
			if (!((Object)(object)component2 == (Object)null))
			{
				Bounds bounds = ((Collider)component2).bounds;
				RescaleItemIfTooBig(component, ((Bounds)(ref bounds)).extents);
			}
		}

		public static void RescaleItemIfTooBig(GrabbableObject component, Vector3 size)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: 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_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			bool flag = false;
			if (ShouldRescale(size, out var factor))
			{
				((Component)component).transform.localScale = factor * ((Component)component).transform.localScale / 100f;
				Vector3 val = Vector3.zero + factor * component.itemProperties.verticalOffset / 100f * new Vector3(0f, 0f, 1f);
				((Component)component).transform.localPosition = val;
				component.targetFloorPosition = val;
				if (Plugin.config.verboseLogging.Value)
				{
					Plugin.logger.LogInfo((object)"Item was rescaled");
				}
			}
		}

		public static void ScaleBackItem(GrabbableObject component)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			((Component)component).transform.localScale = component.originalScale;
		}

		public static void OverrideOriginalScale(GrabbableObject component, Vector3 value)
		{
			//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)
			component.originalScale = value;
		}

		public static void ReParentItemToCupboard(GrabbableObject component, SmartCupboard cupboard, int spawnIndex, bool overridePosRot = false, Vector3 syncedPos = default(Vector3), Quaternion syncedRot = default(Quaternion))
		{
			//IL_004f: 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_003e: 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)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: 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_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			if (spawnIndex >= 0)
			{
				cupboard.GetPlacePosition(spawnIndex, out Transform parent, out Vector3 _, out Quaternion _);
				Vector3 val = (overridePosRot ? syncedPos : (Vector3.zero + component.itemProperties.verticalOffset * new Vector3(0f, 0f, 1f)));
				component.parentObject = null;
				((Component)component).transform.SetParent(parent ?? StartOfRound.Instance.elevatorTransform, true);
				((Component)component).transform.localPosition = val;
				component.targetFloorPosition = val;
				if (overridePosRot)
				{
					((Component)component).transform.localRotation = syncedRot;
				}
				component.reachedFloorTarget = true;
				component.hasHitGround = true;
			}
		}
	}
	[HarmonyPatch(typeof(GameNetworkManager))]
	internal class GameNetworkManagerPatch
	{
		[HarmonyPrefix]
		[HarmonyPatch("SaveItemsInShip")]
		public static void SaveSmartCupboard()
		{
			if (Plugin.config.enableSaving.Value && !((Object)(object)StartOfRound.Instance == (Object)null) && ((NetworkBehaviour)StartOfRound.Instance).IsServer)
			{
				string currentSaveFileName = GameNetworkManager.Instance.currentSaveFileName;
				SavingModule.Save(currentSaveFileName);
			}
		}
	}
	[HarmonyPatch(typeof(StartOfRound))]
	internal class StartOfRoundPatch
	{
		[HarmonyPostfix]
		[HarmonyPatch("LoadShipGrabbableItems")]
		public static void LoadSmartCupboard()
		{
			if (Plugin.config.enableSaving.Value && !((Object)(object)StartOfRound.Instance == (Object)null) && ((NetworkBehaviour)StartOfRound.Instance).IsServer)
			{
				string currentSaveFileName = GameNetworkManager.Instance.currentSaveFileName;
				SavingModule.Load(currentSaveFileName);
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch("Start")]
		public static void SetSmartCupboardDefaultScreen()
		{
			if (!SmartCupboard.SpawnedInShip && Plugin.config.GeneralImprovements && Plugin.config.customScreenPos.Value > 0 && Plugin.config.customScreenPos.Value <= 14)
			{
				Effects.SetScreenText(Plugin.config.customScreenPos.Value - 1, "<color=#ffff00>Smart Cupboard:\n$" + Plugin.config.cupboardPrice.Value + "</color>");
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch("ResetShip")]
		public static void ResetSmartCupboard()
		{
			if ((Object)(object)StartOfRound.Instance == (Object)null || !((NetworkBehaviour)StartOfRound.Instance).IsServer || SmartMemory.Instance == null || SmartMemory.Instance.Size == 0)
			{
				return;
			}
			SmartCupboard smartCupboard = Object.FindObjectOfType<SmartCupboard>();
			if (!((Object)(object)smartCupboard == (Object)null))
			{
				SmartMemory.Instance.ClearAll();
				smartCupboard.placedItems.Clear();
				if (Plugin.config.verboseLogging.Value)
				{
					Plugin.logger.LogInfo((object)"Smart Cupboard was reseted due to a game over.");
				}
			}
		}
	}
	[HarmonyPatch(typeof(RoundManager))]
	internal class RoundManagerPatch
	{
		[HarmonyPostfix]
		[HarmonyPatch("DespawnPropsAtEndOfRound")]
		public static void ResetSmartCupboardIfAllDeads()
		{
			if ((Object)(object)RoundManager.Instance == (Object)null || !((NetworkBehaviour)RoundManager.Instance).IsServer || SmartMemory.Instance == null || SmartMemory.Instance.Size == 0 || (Object)(object)StartOfRound.Instance == (Object)null || !StartOfRound.Instance.allPlayersDead)
			{
				return;
			}
			int num = 0;
			SmartCupboard smartCupboard = Object.FindObjectOfType<SmartCupboard>();
			if ((Object)(object)smartCupboard == (Object)null)
			{
				return;
			}
			foreach (List<SmartMemory.Data> item in SmartMemory.Instance.ItemList)
			{
				foreach (SmartMemory.Data item2 in item)
				{
					if (item2.IsValid() && item2.Values[0] != 0)
					{
						item2.Id = "INVALID";
						SmartMemory.Instance.Size--;
						smartCupboard.placedItems.Remove(num);
					}
					num++;
				}
			}
			if (Plugin.config.verboseLogging.Value)
			{
				Plugin.logger.LogInfo((object)"Smart Cupboard stored scraps were removed due to all players being dead.");
			}
		}
	}
	[HarmonyPatch(typeof(BeltBagItem))]
	internal class BeltBagItemPatch
	{
		[HarmonyPrefix]
		[HarmonyPatch("TryAddObjectToBagServerRpc")]
		public static bool TryAddObjectToBagServerRpcPatch(BeltBagItem __instance, NetworkObjectReference netObjectRef, int playerWhoAdded)
		{
			//IL_0108: Unknown result type (might be due to invalid IL or missing references)
			//IL_0114: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)StartOfRound.Instance == (Object)null || !((NetworkBehaviour)StartOfRound.Instance).IsServer || SmartMemory.Instance == null || SmartMemory.Instance.Size == 0)
			{
				return true;
			}
			SmartCupboard smartCupboard = Object.FindObjectOfType<SmartCupboard>();
			if ((Object)(object)smartCupboard == (Object)null || smartCupboard.placedItems.Count == 0)
			{
				return true;
			}
			NetworkObject val = default(NetworkObject);
			if (((NetworkObjectReference)(ref netObjectRef)).TryGet(ref val, (NetworkManager)null))
			{
				GrabbableObject component = ((Component)val).GetComponent<GrabbableObject>();
				if ((Object)(object)component != (Object)null && !component.isHeld && !component.heldByPlayerOnServer && !component.isHeldByEnemy)
				{
					foreach (var (_, val3) in smartCupboard.placedItems)
					{
						if (component.itemProperties.itemName == val3.itemProperties.itemName && ((Component)component).transform.position == ((Component)val3).transform.position)
						{
							__instance.CancelAddObjectToBagClientRpc(playerWhoAdded);
							return false;
						}
					}
				}
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(ShipBuildModeManager))]
	internal class ShipBuildModeManagerPatch
	{
		[HarmonyPrefix]
		[HarmonyPatch("CreateGhostObjectAndHighlight")]
		public static bool CreateGhostObjectAndHighlightPatch(ShipBuildModeManager __instance)
		{
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: Unknown result type (might be due to invalid IL or missing references)
			//IL_012b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0140: Unknown result type (might be due to invalid IL or missing references)
			//IL_0145: Unknown result type (might be due to invalid IL or missing references)
			//IL_014a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0160: Unknown result type (might be due to invalid IL or missing references)
			//IL_01af: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01da: Unknown result type (might be due to invalid IL or missing references)
			//IL_0200: Unknown result type (might be due to invalid IL or missing references)
			//IL_0226: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)__instance.placingObject == (Object)null || ((Object)__instance.placingObject.parentObject).name != "SSS_Module_WideVariant(Clone)")
			{
				return true;
			}
			((Behaviour)HUDManager.Instance.buildModeControlTip).enabled = true;
			if (StartOfRound.Instance.localPlayerUsingController)
			{
				((TMP_Text)HUDManager.Instance.buildModeControlTip).text = "Confirm: [Y]   |   Rotate: [L-shoulder]   |   Store: [B]";
			}
			else
			{
				((TMP_Text)HUDManager.Instance.buildModeControlTip).text = "Confirm: [B]   |   Rotate: [R]   |   Store: [X]";
			}
			HUDManager.Instance.UIAudio.PlayOneShot(__instance.beginPlacementSFX);
			((Component)__instance.ghostObject).transform.eulerAngles = ((Component)__instance.placingObject.mainMesh).transform.eulerAngles;
			__instance.ghostObjectMesh.mesh = __instance.placingObject.mainMesh.mesh;
			((Component)__instance.ghostObjectMesh).transform.localScale = ((Component)__instance.placingObject.mainMesh).transform.localScale;
			((Component)__instance.ghostObjectMesh).transform.position = __instance.ghostObject.position + (((Component)__instance.placingObject.mainMesh).transform.position - ((Component)__instance.placingObject.placeObjectCollider).transform.position);
			((Component)__instance.ghostObjectMesh).transform.localEulerAngles = Vector3.zero;
			((Renderer)__instance.ghostObjectRenderer).enabled = true;
			__instance.selectionOutlineMesh.mesh = __instance.placingObject.mainMesh.mesh;
			((Component)__instance.selectionOutlineMesh).transform.localScale = ((Component)__instance.placingObject.mainMesh).transform.localScale;
			((Component)__instance.selectionOutlineMesh).transform.localScale = ((Component)__instance.selectionOutlineMesh).transform.localScale * 1.04f;
			((Component)__instance.selectionOutlineMesh).transform.position = ((Component)__instance.placingObject.mainMesh).transform.position;
			((Component)__instance.selectionOutlineMesh).transform.eulerAngles = ((Component)__instance.placingObject.mainMesh).transform.eulerAngles;
			((Renderer)__instance.selectionOutlineRenderer).enabled = true;
			return false;
		}
	}
}
namespace SelfSortingStorage.Cupboard
{
	internal class SavingModule
	{
		public const string SaveKey = "SmartCupboardItems";

		public static void Save(string saveFile)
		{
			if (!GetItems(out SmartMemory.Data[] items))
			{
				ES3.DeleteKey("SmartCupboardItems", saveFile);
				return;
			}
			ES3.Save<string>("SmartCupboardItems", JsonConvert.SerializeObject((object)items), saveFile);
			Plugin.logger.LogInfo((object)"SmartCupboard items saved.");
		}

		public static void Load(string saveFile)
		{
			if (!ES3.KeyExists("SmartCupboardItems", saveFile) || SmartMemory.Instance == null)
			{
				return;
			}
			SmartCupboard smartCupboard = Object.FindObjectOfType<SmartCupboard>();
			string text = ES3.Load<string>("SmartCupboardItems", saveFile);
			IEnumerable<SmartMemory.Data> enumerable = JsonConvert.DeserializeObject<IEnumerable<SmartMemory.Data>>(text);
			if (enumerable == null || (Object)(object)smartCupboard == (Object)null)
			{
				Plugin.logger.LogError((object)"Items from SmartCupboard could not be loaded.");
				return;
			}
			int num = 0;
			SmartMemory.Data[] array = enumerable.ToArray();
			SmartMemory.Data[] array2 = array;
			foreach (SmartMemory.Data data in array2)
			{
				if (data.IsValid())
				{
					SmartMemory.Instance.StoreData(data, out var _, freeSpaceOnly: true);
				}
				else
				{
					SmartMemory.Instance.IgnoreSpaces.Add(num);
				}
				num++;
			}
			if (Plugin.config.verboseLogging.Value)
			{
				Plugin.logger.LogWarning((object)SmartMemory.Instance.ToString());
			}
			SmartMemory.Instance.IgnoreSpaces.Clear();
			((MonoBehaviour)smartCupboard).StartCoroutine(smartCupboard.ReloadPlacedItems());
			Plugin.logger.LogInfo((object)"SmartCupboard items loaded.");
		}

		private static bool GetItems(out SmartMemory.Data[]? items)
		{
			items = null;
			if (SmartMemory.Instance == null || SmartMemory.Instance.Size == 0)
			{
				return false;
			}
			List<SmartMemory.Data> list = new List<SmartMemory.Data>();
			for (int i = 0; i < 4; i++)
			{
				for (int j = 0; j < Plugin.instance.ROWS_LENGTH; j++)
				{
					SmartMemory.Data item = SmartMemory.Instance.ItemList[i][j];
					list.Add(item);
				}
			}
			items = list.ToArray();
			return true;
		}
	}
	public class SmartCupboard : NetworkBehaviour
	{
		[CompilerGenerated]
		private sealed class <DisplayOnScreen>d__36 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public SmartCupboard <>4__this;

			private int <lastId>5__1;

			private int <it>5__2;

			private StringBuilder <builder>5__3;

			private int <i>5__4;

			private SmartMemory.Data <item>5__5;

			private bool <verifReset>5__6;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<builder>5__3 = null;
				<item>5__5 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_01f8: Unknown result type (might be due to invalid IL or missing references)
				//IL_0202: Expected O, but got Unknown
				//IL_01b0: Unknown result type (might be due to invalid IL or missing references)
				//IL_01ba: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<lastId>5__1 = 0;
					break;
				case 1:
					<>1__state = -1;
					<builder>5__3 = null;
					break;
				case 2:
					<>1__state = -1;
					break;
				}
				while (SmartMemory.Instance != null)
				{
					if (<>4__this.memory.Size != 0)
					{
						<it>5__2 = 0;
						<builder>5__3 = new StringBuilder();
						<i>5__4 = <lastId>5__1;
						while (<i>5__4 < <>4__this.memory.Capacity)
						{
							<item>5__5 = <>4__this.memory.RetrieveData(<i>5__4, updateQuantity: false);
							if (<item>5__5 != null)
							{
								<builder>5__3.Append(<>4__this.GetItemScreenText(<item>5__5));
								<it>5__2++;
							}
							<verifReset>5__6 = <it>5__2 == <>4__this.memory.Size || <i>5__4 + 1 >= <>4__this.memory.Capacity;
							if ((<it>5__2 == 4) | <verifReset>5__6)
							{
								<lastId>5__1 = ((!<verifReset>5__6) ? (<i>5__4 + 1) : 0);
								break;
							}
							<item>5__5 = null;
							<i>5__4++;
						}
						if (<it>5__2 == 0)
						{
							continue;
						}
						<>4__this.SetScreenTextServerRpc(<builder>5__3.ToString());
						<>2__current = (object)new WaitForSeconds(10f);
						<>1__state = 1;
						return true;
					}
					<>4__this.SetScreenTextServerRpc("No items in Smart Cupboard");
					<>2__current = (object)new WaitUntil((Func<bool>)(() => <>4__this.memory.Size != 0));
					<>1__state = 2;
					return true;
				}
				return false;
			}

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

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

		[CompilerGenerated]
		private sealed class <ReloadPlacedItems>d__18 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public SmartCupboard <>4__this;

			private int <spawnIndex>5__1;

			private float <distanceSearch>5__2;

			private GrabbableObject[] <array>5__3;

			private List<List<SmartMemory.Data>>.Enumerator <>s__4;

			private List<SmartMemory.Data> <list>5__5;

			private List<SmartMemory.Data>.Enumerator <>s__6;

			private SmartMemory.Data <item>5__7;

			private int <i>5__8;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<array>5__3 = null;
				<>s__4 = default(List<List<SmartMemory.Data>>.Enumerator);
				<list>5__5 = null;
				<>s__6 = default(List<SmartMemory.Data>.Enumerator);
				<item>5__7 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0026: Unknown result type (might be due to invalid IL or missing references)
				//IL_0030: Expected O, but got Unknown
				//IL_011f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0136: Unknown result type (might be due to invalid IL or missing references)
				//IL_0172: Unknown result type (might be due to invalid IL or missing references)
				//IL_0178: Unknown result type (might be due to invalid IL or missing references)
				//IL_017b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0181: Unknown result type (might be due to invalid IL or missing references)
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (object)new WaitForSeconds(1f);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<spawnIndex>5__1 = 0;
					<distanceSearch>5__2 = 1f;
					<array>5__3 = Object.FindObjectsByType<GrabbableObject>((FindObjectsSortMode)0);
					<>s__4 = <>4__this.memory.ItemList.GetEnumerator();
					try
					{
						while (<>s__4.MoveNext())
						{
							<list>5__5 = <>s__4.Current;
							<>s__6 = <list>5__5.GetEnumerator();
							try
							{
								while (<>s__6.MoveNext())
								{
									<item>5__7 = <>s__6.Current;
									if (<item>5__7.IsValid())
									{
										<i>5__8 = 0;
										while (<i>5__8 < <array>5__3.Length)
										{
											if (<array>5__3[<i>5__8].itemProperties.itemName == <item>5__7.Id.Split('/')[1] && Vector3.Distance(<>4__this.placePositions[<spawnIndex>5__1].position, ((Component)<array>5__3[<i>5__8]).transform.position) <= <distanceSearch>5__2)
											{
												Effects.ReParentItemToCupboard(<array>5__3[<i>5__8], <>4__this, <spawnIndex>5__1);
												if (Plugin.config.rescaleItems.Value)
												{
													Effects.RescaleItemIfTooBig(<array>5__3[<i>5__8]);
												}
												<>4__this.placedItems[<spawnIndex>5__1] = <array>5__3[<i>5__8];
											}
											<i>5__8++;
										}
									}
									<spawnIndex>5__1++;
									<item>5__7 = null;
								}
							}
							finally
							{
								((IDisposable)<>s__6).Dispose();
							}
							<>s__6 = default(List<SmartMemory.Data>.Enumerator);
							<list>5__5 = null;
						}
					}
					finally
					{
						((IDisposable)<>s__4).Dispose();
					}
					<>s__4 = default(List<List<SmartMemory.Data>>.Enumerator);
					return false;
				}
			}

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

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

		[CompilerGenerated]
		private sealed class <ScaleItem>d__27 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public NetworkObjectReference itemRef;

			public bool scaleMode;

			public Vector3 size;

			public bool syncedFromHost;

			public int spawnIndex;

			public Vector3 syncedPos;

			public Quaternion syncedRot;

			public SmartCupboard <>4__this;

			private NetworkObject <itemNetObject>5__1;

			private GrabbableObject <component>5__2;

			private NetworkObject <itemNetObject>5__3;

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

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

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

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

			private bool MoveNext()
			{
				//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_0041: Unknown result type (might be due to invalid IL or missing references)
				//IL_004b: Expected O, but got Unknown
				//IL_008d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0097: Expected O, but got Unknown
				//IL_00d6: 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_0125: Unknown result type (might be due to invalid IL or missing references)
				//IL_0100: Unknown result type (might be due to invalid IL or missing references)
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					if (scaleMode)
					{
						goto IL_005b;
					}
					if (((NetworkObjectReference)(ref itemRef)).TryGet(ref <itemNetObject>5__3, (NetworkManager)null))
					{
						Effects.ScaleBackItem(((Component)<itemNetObject>5__3).GetComponent<GrabbableObject>());
					}
					<itemNetObject>5__3 = null;
					break;
				case 1:
					<>1__state = -1;
					goto IL_005b;
				case 2:
					{
						<>1__state = -1;
						goto IL_00a7;
					}
					IL_005b:
					if (!((NetworkObjectReference)(ref itemRef)).TryGet(ref <itemNetObject>5__1, (NetworkManager)null))
					{
						<>2__current = (object)new WaitForSeconds(0.03f);
						<>1__state = 1;
						return true;
					}
					<component>5__2 = ((Component)<itemNetObject>5__1).GetComponent<GrabbableObject>();
					goto IL_00a7;
					IL_00a7:
					if (<component>5__2.originalScale == Vector3.zero)
					{
						<>2__current = (object)new WaitForSeconds(0.03f);
						<>1__state = 2;
						return true;
					}
					if (!syncedFromHost)
					{
						Effects.RescaleItemIfTooBig(<component>5__2, size);
					}
					else
					{
						if (Plugin.config.rescaleItems.Value)
						{
							Effects.OverrideOriginalScale(<component>5__2, size);
						}
						Effects.ReParentItemToCupboard(<component>5__2, <>4__this, spawnIndex, overridePosRot: true, syncedPos, syncedRot);
					}
					<itemNetObject>5__1 = null;
					<component>5__2 = null;
					break;
				}
				return false;
			}

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

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

		[CompilerGenerated]
		private sealed class <SyncCupboard>d__32 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public SmartCupboard <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				//IL_004b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0055: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					if (Plugin.config.verboseLogging.Value)
					{
						Plugin.logger.LogInfo((object)"Syncing Cupboard from host player");
					}
					break;
				case 1:
					<>1__state = -1;
					break;
				}
				if ((Object)(object)GameNetworkManager.Instance == (Object)null || (Object)(object)GameNetworkManager.Instance.localPlayerController == (Object)null)
				{
					<>2__current = (object)new WaitForSeconds(0.03f);
					<>1__state = 1;
					return true;
				}
				<>4__this.SyncServerRpc(((NetworkBehaviour)GameNetworkManager.Instance.localPlayerController).OwnerClientId);
				return false;
			}

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

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

		[CompilerGenerated]
		private sealed class <SyncItem>d__24 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public NetworkObjectReference itemRef;

			public int value;

			public int save;

			public int spawnIndex;

			public bool isStacked;

			public SmartCupboard <>4__this;

			private NetworkObject <itemNetObject>5__1;

			private GrabbableObject <component>5__2;

			private BoxCollider <collider>5__3;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<itemNetObject>5__1 = null;
				<component>5__2 = null;
				<collider>5__3 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0022: Unknown result type (might be due to invalid IL or missing references)
				//IL_010f: Unknown result type (might be due to invalid IL or missing references)
				//IL_011b: 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_0124: Unknown result type (might be due to invalid IL or missing references)
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = Effects.SyncItem(itemRef, <>4__this, spawnIndex, value, save);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					if (((NetworkObjectReference)(ref itemRef)).TryGet(ref <itemNetObject>5__1, (NetworkManager)null))
					{
						<component>5__2 = ((Component)<itemNetObject>5__1).GetComponent<GrabbableObject>();
						if (!isStacked)
						{
							<component>5__2.PlayDropSFX();
						}
						if (((NetworkBehaviour)<>4__this).IsServer)
						{
							<>4__this.placedItems[spawnIndex] = <component>5__2;
							if (Plugin.config.rescaleItems.Value)
							{
								<collider>5__3 = ((Component)<component>5__2).GetComponent<BoxCollider>();
								if ((Object)(object)<collider>5__3 == (Object)null)
								{
									return false;
								}
								SmartCupboard smartCupboard = <>4__this;
								NetworkObjectReference val = itemRef;
								Bounds bounds = ((Collider)<collider>5__3).bounds;
								smartCupboard.ScaleItemClientRpc(val, scaleMode: true, ((Bounds)(ref bounds)).extents);
								<collider>5__3 = null;
							}
						}
						<component>5__2 = null;
					}
					return false;
				}
			}

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

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

		public NetworkObject parentObject;

		public InteractTrigger triggerScript;

		public Transform[] placePositions;

		public SmartMemory memory = new SmartMemory();

		public readonly Dictionary<int, GrabbableObject> placedItems = new Dictionary<int, GrabbableObject>();

		private readonly List<int> indexToRemove = new List<int>();

		private GrabbableObject? awaitingObject = null;

		private bool responseOnAwaiting = false;

		public static bool SpawnedInShip { get; private set; }

		public override void OnNetworkSpawn()
		{
			((NetworkBehaviour)this).OnNetworkSpawn();
			if (((NetworkBehaviour)this).IsServer)
			{
				memory.Initialize();
				if (Plugin.config.GeneralImprovements && Plugin.config.customScreenPos.Value > 0 && Plugin.config.customScreenPos.Value <= 14)
				{
					((MonoBehaviour)this).StartCoroutine(DisplayOnScreen());
				}
				GameObject val = GameObject.Find("/Environment/HangarShip");
				if ((Object)(object)val != (Object)null)
				{
					((Component)parentObject).transform.SetParent(val.transform, true);
				}
			}
			SpawnedInShip = true;
			PreparePlacePositions();
			if (!((NetworkBehaviour)this).IsServer)
			{
				((MonoBehaviour)this).StartCoroutine(SyncCupboard());
			}
		}

		public override void OnNetworkDespawn()
		{
			((NetworkBehaviour)this).OnNetworkDespawn();
			SpawnedInShip = false;
		}

		private void PreparePlacePositions()
		{
			if (Plugin.config.rowsOrder.Count != 4)
			{
				return;
			}
			Transform[] array = (Transform[])(object)new Transform[placePositions.Length];
			placePositions.CopyTo(array, 0);
			foreach (KeyValuePair<int, int> item in Plugin.config.rowsOrder)
			{
				item.Deconstruct(out var key, out var value);
				int num = key;
				int num2 = value;
				int num3 = num2 * Plugin.instance.ROWS_LENGTH;
				int num4 = (num - 1) * Plugin.instance.ROWS_LENGTH;
				for (int i = num4; i < num4 + Plugin.instance.ROWS_LENGTH; i++)
				{
					placePositions[i] = array[num3++];
				}
			}
		}

		public void Update()
		{
			//IL_0183: Unknown result type (might be due to invalid IL or missing references)
			//IL_018b: 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)
			if ((Object)(object)GameNetworkManager.Instance != (Object)null && (Object)(object)GameNetworkManager.Instance.localPlayerController != (Object)null)
			{
				if (CheckIsFull(GameNetworkManager.Instance.localPlayerController))
				{
					triggerScript.interactable = false;
					triggerScript.disabledHoverTip = "[Full!]";
				}
				else
				{
					triggerScript.interactable = Effects.IsTriggerValid(GameNetworkManager.Instance.localPlayerController, out string notValidText);
					if (!triggerScript.interactable)
					{
						triggerScript.disabledHoverTip = notValidText;
					}
				}
				if (!((NetworkBehaviour)this).IsServer && (Object)(object)awaitingObject != (Object)null && ((Object)(object)GameNetworkManager.Instance.localPlayerController.currentlyHeldObjectServer == (Object)null || (Object)(object)GameNetworkManager.Instance.localPlayerController.currentlyHeldObjectServer != (Object)(object)awaitingObject))
				{
					responseOnAwaiting = false;
					awaitingObject = null;
				}
			}
			if (!((NetworkBehaviour)this).IsServer)
			{
				return;
			}
			foreach (var (num2, val2) in placedItems)
			{
				if (val2.isHeld || val2.isHeldByEnemy)
				{
					if (Plugin.config.rescaleItems.Value)
					{
						ScaleItemClientRpc(NetworkObjectReference.op_Implicit(((Component)val2).gameObject.GetComponent<NetworkObject>()), scaleMode: false);
					}
					SmartMemory.Data data = memory.RetrieveData(num2);
					if (!memory.IsFull())
					{
						SetSizeClientRpc(memory.Size);
					}
					indexToRemove.Add(num2);
					if (data != null && data.Quantity >= 1)
					{
						SpawnItem(data, num2, isStacked: true);
					}
				}
			}
			if (indexToRemove.Count == 0)
			{
				return;
			}
			foreach (int item in indexToRemove)
			{
				placedItems.Remove(item);
			}
			indexToRemove.Clear();
		}

		public static void AddTriggerValidation(Func<PlayerControllerB, bool> func, string notValidText)
		{
			Plugin.spTriggerValidations.Add((func, notValidText));
		}

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

		public void StoreObject(PlayerControllerB player)
		{
			if (!((Object)(object)player == (Object)null) && player.isHoldingObject && !player.isGrabbingObjectAnimation && !((Object)(object)player.currentlyHeldObjectServer == (Object)null))
			{
				StoreDataServerRpc(player.playerClientId);
				player.DestroyItemInSlotAndSync(player.currentItemSlot);
			}
		}

		public void GetPlacePosition(int spawnIndex, out Transform parent, out Vector3 position, out Quaternion rotation)
		{
			//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_001c: 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_0035: 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)
			parent = placePositions[spawnIndex];
			position = parent.position;
			rotation = parent.rotation * Quaternion.Euler(0f, 0f, 180f);
		}

		[ServerRpc(RequireOwnership = false)]
		private void StoreDataServerRpc(ulong playerId)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Invalid comparison between Unknown and I4
			//IL_005f: 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_0071: 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_0173: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				ServerRpcParams val = default(ServerRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(3359588108u, val, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val2, playerId);
				((NetworkBehaviour)this).__endSendServerRpc(ref val2, 3359588108u, val, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage != 1 || (!networkManager.IsServer && !networkManager.IsHost))
			{
				return;
			}
			PlayerControllerB val3 = StartOfRound.Instance.allPlayerScripts[playerId];
			if ((Object)(object)val3 == (Object)null)
			{
				return;
			}
			GrabbableObject currentlyHeldObjectServer = val3.currentlyHeldObjectServer;
			if (!((Object)(object)currentlyHeldObjectServer == (Object)null))
			{
				SmartMemory.Data data = new SmartMemory.Data(currentlyHeldObjectServer);
				int spawnIndex;
				bool flag = memory.StoreData(data, out spawnIndex);
				if (memory.IsFull())
				{
					SetSizeClientRpc(memory.Size);
				}
				GrabbableObject value;
				if (flag)
				{
					SpawnItem(data, spawnIndex);
				}
				else if (placedItems.TryGetValue(spawnIndex, out value))
				{
					PlayDropSFXClientRpc(NetworkObjectReference.op_Implicit(((Component)value).gameObject.GetComponent<NetworkObject>()));
				}
				if (Plugin.config.verboseLogging.Value)
				{
					Plugin.logger.LogWarning((object)memory.ToString());
				}
			}
		}

		private void SpawnItem(SmartMemory.Data itemData, int spawnIndex, bool isStacked = false)
		{
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			if (itemData.IsValid())
			{
				Item item = Effects.GetItem(itemData.Id);
				if ((Object)(object)item != (Object)null)
				{
					Effects.ItemNetworkReference itemNetworkReference = Effects.SpawnItem(item, this, spawnIndex, itemData.Values[0], itemData.Saves[0]);
					SyncItemClientRpc(itemNetworkReference.netObjectRef, itemNetworkReference.value, itemNetworkReference.save, spawnIndex, isStacked);
				}
			}
		}

		[ClientRpc]
		private void SyncItemClientRpc(NetworkObjectReference itemRef, int value, int save, int spawnIndex, bool isStacked)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Invalid comparison between Unknown and I4
			//IL_005f: 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_007d: 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_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: 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_00bf: 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_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_011b: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 2 && (networkManager.IsServer || networkManager.IsHost))
				{
					ClientRpcParams val = default(ClientRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(52998418u, val, (RpcDelivery)0);
					((FastBufferWriter)(ref val2)).WriteValueSafe<NetworkObjectReference>(ref itemRef, default(ForNetworkSerializable));
					BytePacker.WriteValueBitPacked(val2, value);
					BytePacker.WriteValueBitPacked(val2, save);
					BytePacker.WriteValueBitPacked(val2, spawnIndex);
					((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref isStacked, default(ForPrimitives));
					((NetworkBehaviour)this).__endSendClientRpc(ref val2, 52998418u, val, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 2 && (networkManager.IsClient || networkManager.IsHost))
				{
					((MonoBehaviour)this).StartCoroutine(SyncItem(itemRef, value, save, spawnIndex, isStacked));
				}
			}
		}

		[IteratorStateMachine(typeof(<SyncItem>d__24))]
		private IEnumerator SyncItem(NetworkObjectReference itemRef, int value, int save, int spawnIndex, bool isStacked)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <SyncItem>d__24(0)
			{
				<>4__this = this,
				itemRef = itemRef,
				value = value,
				save = save,
				spawnIndex = spawnIndex,
				isStacked = isStacked
			};
		}

		[ClientRpc]
		private void PlayDropSFXClientRpc(NetworkObjectReference itemRef)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Invalid comparison between Unknown and I4
			//IL_005f: 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_007d: 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_0097: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 2 && (networkManager.IsServer || networkManager.IsHost))
				{
					ClientRpcParams val = default(ClientRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(4245719167u, val, (RpcDelivery)0);
					((FastBufferWriter)(ref val2)).WriteValueSafe<NetworkObjectReference>(ref itemRef, default(ForNetworkSerializable));
					((NetworkBehaviour)this).__endSendClientRpc(ref val2, 4245719167u, val, (RpcDelivery)0);
				}
				NetworkObject val3 = default(NetworkObject);
				if ((int)base.__rpc_exec_stage == 2 && (networkManager.IsClient || networkManager.IsHost) && ((NetworkObjectReference)(ref itemRef)).TryGet(ref val3, (NetworkManager)null))
				{
					((Component)val3).GetComponent<GrabbableObject>().PlayDropSFX();
				}
			}
		}

		[ClientRpc]
		private void ScaleItemClientRpc(NetworkObjectReference itemRef, bool scaleMode, Vector3 size = default(Vector3))
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Invalid comparison between Unknown and I4
			//IL_005f: 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_007d: 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_0098: 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_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_0114: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: Unknown result type (might be due to invalid IL or missing references)
			//IL_011b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0121: Unknown result type (might be due to invalid IL or missing references)
			//IL_0124: Unknown result type (might be due to invalid IL or missing references)
			//IL_012a: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 2 && (networkManager.IsServer || networkManager.IsHost))
				{
					ClientRpcParams val = default(ClientRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(2689687125u, val, (RpcDelivery)0);
					((FastBufferWriter)(ref val2)).WriteValueSafe<NetworkObjectReference>(ref itemRef, default(ForNetworkSerializable));
					((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref scaleMode, default(ForPrimitives));
					((FastBufferWriter)(ref val2)).WriteValueSafe(ref size);
					((NetworkBehaviour)this).__endSendClientRpc(ref val2, 2689687125u, val, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 2 && (networkManager.IsClient || networkManager.IsHost) && Plugin.config.rescaleItems.Value)
				{
					((MonoBehaviour)this).StartCoroutine(ScaleItem(itemRef, scaleMode, size));
				}
			}
		}

		[IteratorStateMachine(typeof(<ScaleItem>d__27))]
		private IEnumerator ScaleItem(NetworkObjectReference itemRef, bool scaleMode, Vector3 size, bool syncedFromHost = false, int spawnIndex = -1, Vector3 syncedPos = default(Vector3), Quaternion syncedRot = default(Quaternion))
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: 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_0033: 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)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <ScaleItem>d__27(0)
			{
				<>4__this = this,
				itemRef = itemRef,
				scaleMode = scaleMode,
				size = size,
				syncedFromHost = syncedFromHost,
				spawnIndex = spawnIndex,
				syncedPos = syncedPos,
				syncedRot = syncedRot
			};
		}

		private bool CheckIsFull(PlayerControllerB player)
		{
			if (!memory.IsFull())
			{
				return false;
			}
			if (!player.isHoldingObject || player.isGrabbingObjectAnimation || (Object)(object)player.currentlyHeldObjectServer == (Object)null)
			{
				return true;
			}
			if (((NetworkBehaviour)this).IsServer)
			{
				return ServerCheckingIsFull(player);
			}
			if (responseOnAwaiting)
			{
				return false;
			}
			if ((Object)(object)awaitingObject != (Object)null)
			{
				return true;
			}
			awaitingObject = player.currentlyHeldObjectServer;
			AskServerCheckIsFullServerRpc(player.playerClientId, ((NetworkBehaviour)player).OwnerClientId);
			return true;
		}

		[ServerRpc(RequireOwnership = false)]
		private void AskServerCheckIsFullServerRpc(ulong playerId, ulong clientId)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Invalid comparison between Unknown and I4
			//IL_005f: 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_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: 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: Unknown result type (might be due to invalid IL or missing references)
			//IL_012f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0131: Unknown result type (might be due to invalid IL or missing references)
			//IL_0136: Unknown result type (might be due to invalid IL or missing references)
			//IL_0138: Unknown result type (might be due to invalid IL or missing references)
			//IL_013b: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val = default(ServerRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(3104039900u, val, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val2, playerId);
					BytePacker.WriteValueBitPacked(val2, clientId);
					((NetworkBehaviour)this).__endSendServerRpc(ref val2, 3104039900u, val, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					PlayerControllerB val3 = StartOfRound.Instance.allPlayerScripts[playerId];
					bool response = (Object)(object)val3 == (Object)null || (Object)(object)val3.currentlyHeldObjectServer == (Object)null || ServerCheckingIsFull(val3);
					ClientRpcParams val4 = default(ClientRpcParams);
					val4.Send = new ClientRpcSendParams
					{
						TargetClientIds = new ulong[1] { clientId }
					};
					ClientRpcParams clientRpcParams = val4;
					ServerResponseCheckIsFullClientRpc(response, clientRpcParams);
				}
			}
		}

		private bool ServerCheckingIsFull(PlayerControllerB player)
		{
			foreach (var (_, val2) in placedItems)
			{
				if (player.currentlyHeldObjectServer.itemProperties.itemName == val2.itemProperties.itemName && ((Object)player.currentlyHeldObjectServer.itemProperties).name == ((Object)val2.itemProperties).name)
				{
					return false;
				}
			}
			return true;
		}

		[ClientRpc]
		private void ServerResponseCheckIsFullClientRpc(bool response, ClientRpcParams clientRpcParams = default(ClientRpcParams))
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Invalid comparison between Unknown and I4
			//IL_005f: 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_007d: 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_0097: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 2 && (networkManager.IsServer || networkManager.IsHost))
				{
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(2155821034u, clientRpcParams, (RpcDelivery)0);
					((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref response, default(ForPrimitives));
					((NetworkBehaviour)this).__endSendClientRpc(ref val, 2155821034u, clientRpcParams, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 2 && (networkManager.IsClient || networkManager.IsHost) && !response)
				{
					responseOnAwaiting = true;
				}
			}
		}

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

		[ServerRpc(RequireOwnership = false)]
		private void SyncServerRpc(ulong clientId)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Invalid comparison between Unknown and I4
			//IL_005f: 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_0071: 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_0121: Unknown result type (might be due to invalid IL or missing references)
			//IL_012b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0142: Unknown result type (might be due to invalid IL or missing references)
			//IL_0144: Unknown result type (might be due to invalid IL or missing references)
			//IL_0149: Unknown result type (might be due to invalid IL or missing references)
			//IL_014b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0199: Unknown result type (might be due to invalid IL or missing references)
			//IL_019e: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cd: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				ServerRpcParams val = default(ServerRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(2989470694u, val, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val2, clientId);
				((NetworkBehaviour)this).__endSendServerRpc(ref val2, 2989470694u, val, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage != 1 || (!networkManager.IsServer && !networkManager.IsHost))
			{
				return;
			}
			if (memory.IsFull())
			{
				SetSizeClientRpc(memory.Size);
			}
			if (memory.Size == 0)
			{
				SetScreenTextServerRpc("No items in Smart Cupboard");
			}
			if (placedItems.Count == 0)
			{
				return;
			}
			ClientRpcParams val3 = default(ClientRpcParams);
			val3.Send = new ClientRpcSendParams
			{
				TargetClientIds = new ulong[1] { clientId }
			};
			ClientRpcParams clientRpcParams = val3;
			foreach (var (spawnIndex, val5) in placedItems)
			{
				if (!val5.isHeld && !val5.isHeldByEnemy)
				{
					Vector3 targetFloorPosition = val5.targetFloorPosition;
					Quaternion localRotation = ((Component)val5).transform.localRotation;
					SyncClientRpc(NetworkObjectReference.op_Implicit(((Component)val5).gameObject.GetComponent<NetworkObject>()), spawnIndex, val5.originalScale, targetFloorPosition, localRotation, clientRpcParams);
				}
			}
		}

		[ClientRpc]
		private void SyncClientRpc(NetworkObjectReference itemRef, int spawnIndex, Vector3 originalScale, Vector3 syncedPos, Quaternion syncedRot, ClientRpcParams clientRpcParams = default(ClientRpcParams))
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Invalid comparison between Unknown and I4
			//IL_005f: 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_007d: 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_008c: 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_010d: Unknown result type (might be due to invalid IL or missing references)
			//IL_010f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_0114: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 2 && (networkManager.IsServer || networkManager.IsHost))
				{
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(372149920u, clientRpcParams, (RpcDelivery)0);
					((FastBufferWriter)(ref val)).WriteValueSafe<NetworkObjectReference>(ref itemRef, default(ForNetworkSerializable));
					BytePacker.WriteValueBitPacked(val, spawnIndex);
					((FastBufferWriter)(ref val)).WriteValueSafe(ref originalScale);
					((FastBufferWriter)(ref val)).WriteValueSafe(ref syncedPos);
					((FastBufferWriter)(ref val)).WriteValueSafe(ref syncedRot);
					((NetworkBehaviour)this).__endSendClientRpc(ref val, 372149920u, clientRpcParams, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 2 && (networkManager.IsClient || networkManager.IsHost))
				{
					((MonoBehaviour)this).StartCoroutine(ScaleItem(itemRef, scaleMode: true, originalScale, syncedFromHost: true, spawnIndex, syncedPos, syncedRot));
				}
			}
		}

		[ClientRpc]
		private void SetSizeClientRpc(int size)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Invalid comparison between Unknown and I4
			//IL_005f: 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_0071: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 2 && (networkManager.IsServer || networkManager.IsHost))
				{
					ClientRpcParams val = default(ClientRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(1820484504u, val, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val2, size);
					((NetworkBehaviour)this).__endSendClientRpc(ref val2, 1820484504u, val, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 2 && (networkManager.IsClient || networkManager.IsHost))
				{
					memory.Size = size;
				}
			}
		}

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

		private string GetItemScreenText(SmartMemory.Data item)
		{
			string text = item.Id.Split('/')[1];
			int num = ((item.Quantity >= 100) ? 99 : item.Quantity);
			int num2 = ((num < 10) ? 6 : 5);
			string text2 = ((text.Length >= num2 + 1) ? text.Substring(0, num2) : text);
			return text2 + " x" + num + "\n";
		}

		[ServerRpc(RequireOwnership = false)]
		private void SetScreenTextServerRpc(string text)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Invalid comparison between Unknown and I4
			//IL_005f: 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_0088: 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_00ba: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				ServerRpcParams val = default(ServerRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(958684778u, val, (RpcDelivery)0);
				bool flag = text != null;
				((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
				if (flag)
				{
					((FastBufferWriter)(ref val2)).WriteValueSafe(text, false);
				}
				((NetworkBehaviour)this).__endSendServerRpc(ref val2, 958684778u, val, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				SetScreenTextClientRpc(text);
			}
		}

		[ClientRpc]
		private void SetScreenTextClientRpc(string text)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Invalid comparison between Unknown and I4
			//IL_005f: 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_0088: 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_00ba: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 2 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val = default(ClientRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(3117903183u, val, (RpcDelivery)0);
				bool flag = text != null;
				((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
				if (flag)
				{
					((FastBufferWriter)(ref val2)).WriteValueSafe(text, false);
				}
				((NetworkBehaviour)this).__endSendClientRpc(ref val2, 3117903183u, val, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 2 && (networkManager.IsClient || networkManager.IsHost) && Plugin.config.GeneralImprovements && Plugin.config.customScreenPos.Value > 0 && Plugin.config.customScreenPos.Value <= 14)
			{
				Effects.SetScreenText(Plugin.config.customScreenPos.Value - 1, text);
			}
		}

		protected override void __initializeVariables()
		{
			((NetworkBehaviour)this).__initializeVariables();
		}

		[RuntimeInitializeOnLoadMethod]
		internal static void InitializeRPCS_SmartCupboard()
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Expected O, but got Unknown
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Expected O, but got Unknown
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Expected O, but got Unknown
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Expected O, but got Unknown
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Expected O, but got Unknown
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: 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
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Expected O, but got Unknown
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Expected O, but got Unknown
			//IL_0104: Unknown result type (might be due to invalid IL or missing references)
			//IL_010e: Expected O, but got Unknown
			//IL_011f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0129: Expected O, but got Unknown
			NetworkManager.__rpc_func_table.Add(3359588108u, new RpcReceiveHandler(__rpc_handler_3359588108));
			NetworkManager.__rpc_func_table.Add(52998418u, new RpcReceiveHandler(__rpc_handler_52998418));
			NetworkManager.__rpc_func_table.Add(4245719167u, new RpcReceiveHandler(__rpc_handler_4245719167));
			NetworkManager.__rpc_func_table.Add(2689687125u, new RpcReceiveHandler(__rpc_handler_2689687125));
			NetworkManager.__rpc_func_table.Add(3104039900u, new RpcReceiveHandler(__rpc_handler_3104039900));
			NetworkManager.__rpc_func_table.Add(2155821034u, new RpcReceiveHandler(__rpc_handler_2155821034));
			NetworkManager.__rpc_func_table.Add(2989470694u, new RpcReceiveHandler(__rpc_handler_2989470694));
			NetworkManager.__rpc_func_table.Add(372149920u, new RpcReceiveHandler(__rpc_handler_372149920));
			NetworkManager.__rpc_func_table.Add(1820484504u, new RpcReceiveHandler(__rpc_handler_1820484504));
			NetworkManager.__rpc_func_table.Add(958684778u, new RpcReceiveHandler(__rpc_handler_958684778));
			NetworkManager.__rpc_func_table.Add(3117903183u, new RpcReceiveHandler(__rpc_handler_3117903183));
		}

		private static void __rpc_handler_3359588108(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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_0050: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				ulong playerId = default(ulong);
				ByteUnpacker.ReadValueBitPacked(reader, ref playerId);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((SmartCupboard)(object)target).StoreDataServerRpc(playerId);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_52998418(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: 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_003e: 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_0058: 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_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: 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_00b0: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				NetworkObjectReference itemRef = default(NetworkObjectReference);
				((FastBufferReader)(ref reader)).ReadValueSafe<NetworkObjectReference>(ref itemRef, default(ForNetworkSerializable));
				int value = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref value);
				int save = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref save);
				int spawnIndex = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref spawnIndex);
				bool isStacked = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref isStacked, default(ForPrimitives));
				target.__rpc_exec_stage = (__RpcExecStage)2;
				((SmartCupboard)(object)target).SyncItemClientRpc(itemRef, value, save, spawnIndex, isStacked);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_4245719167(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: 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_0044: 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_005e: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				NetworkObjectReference itemRef = default(NetworkObjectReference);
				((FastBufferReader)(ref reader)).ReadValueSafe<NetworkObjectReference>(ref itemRef, default(ForNetworkSerializable));
				target.__rpc_exec_stage = (__RpcExecStage)2;
				((SmartCupboard)(object)target).PlayDropSFXClientRpc(itemRef);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_2689687125(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: 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_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: 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_007f: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				NetworkObjectReference itemRef = default(NetworkObjectReference);
				((FastBufferReader)(ref reader)).ReadValueSafe<NetworkObjectReference>(ref itemRef, default(ForNetworkSerializable));
				bool scaleMode = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref scaleMode, default(ForPrimitives));
				Vector3 size = default(Vector3);
				((FastBufferReader)(ref reader)).ReadValueSafe(ref size);
				target.__rpc_exec_stage = (__RpcExecStage)2;
				((SmartCupboard)(object)target).ScaleItemClientRpc(itemRef, scaleMode, size);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_3104039900(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				ulong playerId = default(ulong);
				ByteUnpacker.ReadValueBitPacked(reader, ref playerId);
				ulong clientId = default(ulong);
				ByteUnpacker.ReadValueBitPacked(reader, ref clientId);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((SmartCupboard)(object)target).AskServerCheckIsFullServerRpc(playerId, clientId);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_2155821034(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//I
Get the Thunderstore App

Decompiled source of SelfSortingStorage v1.0.9

plugins/SelfSortingStorage.dll

About

Developers
