using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Text;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using ChestFlow.Core;
using ChestFlow.Runtime;
using HarmonyLib;
using JG224.ModCore.API;
using Microsoft.CodeAnalysis;
using Splatform;
using TMPro;
using UnityEngine;
using UnityEngine.EventSystems;
using UnityEngine.Events;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: AssemblyCompany("ChestFlow")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("0.5.2.0")]
[assembly: AssemblyInformationalVersion("0.5.2")]
[assembly: AssemblyProduct("ChestFlow")]
[assembly: AssemblyTitle("ChestFlow")]
[assembly: AssemblyVersion("0.5.2.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

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

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

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

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace ChestFlow
{
	[BepInPlugin("com.jg224.chestflow", "ChestFlow", "0.5.2")]
	[BepInDependency("com.jg224.modcore", "0.5.0")]
	[BepInProcess("valheim.exe")]
	[BepInProcess("valheim_server.exe")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInIncompatibility("goldenrevolver.quick_stack_store")]
	[BepInIncompatibility("com.maxsch.valheim.MultiUserChest")]
	[BepInIncompatibility("Narolith.AutoFeed")]
	public sealed class Plugin : BaseUnityPlugin
	{
		internal const string PluginGuid = "com.jg224.chestflow";

		internal const string PluginName = "ChestFlow";

		internal const string PluginVersion = "0.5.2";

		internal const string ModCoreGuid = "com.jg224.modcore";

		internal const int ProtocolVersion = 2;

		internal static readonly ModuleId ModuleId = new ModuleId("chestflow");

		private Harmony? _harmony;

		private readonly List<IDisposable> _registrations = new List<IDisposable>();

		private bool _shutDown;

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

		internal static ManualLogSource LogInstance { get; private set; } = null;

		internal static ICoreServices Core { get; private set; } = null;

		internal QuickStackService QuickStackService { get; private set; }

		internal static bool IsActive { get; private set; }

		private void Awake()
		{
			//IL_022e: 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_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Expected O, but got Unknown
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: 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_0175: Unknown result type (might be due to invalid IL or missing references)
			//IL_0183: Unknown result type (might be due to invalid IL or missing references)
			//IL_018d: Expected O, but got Unknown
			//IL_01bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c9: Expected O, but got Unknown
			//IL_01df: Unknown result type (might be due to invalid IL or missing references)
			IsActive = false;
			_shutDown = false;
			Instance = this;
			LogInstance = ((BaseUnityPlugin)this).Logger;
			try
			{
				if (!ModCoreApi.IsAvailable)
				{
					throw new InvalidOperationException("ModCore did not initialize before ChestFlow.");
				}
				Core = ModCoreApi.Services;
				SemanticVersion val = default(SemanticVersion);
				if (!SemanticVersion.TryParse("0.5.2", ref val))
				{
					throw new InvalidOperationException("ChestFlow has invalid release version metadata.");
				}
				_registrations.Add(Core.Modules.Register(new ModuleDescriptor(ModuleId, "com.jg224.chestflow", "ChestFlow", val, 2, (ModuleSide)3, (ModuleRequirement)4, 0uL, 1, 1)));
				_registrations.Add(Core.Namespaces.Register(ModuleId, (NamespaceKind)1, "com.jg224.chestflow.", 1, Array.Empty<string>()));
				_registrations.Add(Core.Namespaces.Register(ModuleId, (NamespaceKind)6, "com.jg224.chestflow.", 1, Array.Empty<string>()));
				_registrations.Add(RoutedRpcIngress.Register(ModuleId, new string[8] { "ChestFlow_MultiUserHello", "ChestFlow_RequestContainerControl", "ChestFlow_ContainerControlResponse", "ChestFlow_AutoFeedTake", "ChestFlow_AutoFeedTakeResponse", "ChestFlow_AutoFeedFinalize", "ChestFlow_AutoFeedPrepare", "ChestFlow_AutoFeedPrepared" }));
				_registrations.Add(Core.Namespaces.Register(ModuleId, (NamespaceKind)2, "com.jg224.chestflow.", 1, Array.Empty<string>()));
				_registrations.Add(Core.Ui.Reserve(new UiReservation(ModuleId, (UiSurface)4, "container-logistics-controls", 20, true)));
				ModConfig.Bind(ConfigFileMigration.Open((BaseUnityPlugin)(object)this, Paths.ConfigPath, ((BaseUnityPlugin)this).Logger));
				QuickStackService = new QuickStackService(this);
				StorageCommands.Register();
				_harmony = new Harmony("com.jg224.chestflow");
				PatchAllSafely();
				IsActive = true;
				Core.Modules.SetState(ModuleId, (ModuleRuntimeState)2, "Required server-authoritative chest logistics hooks ready.");
				((BaseUnityPlugin)this).Logger.LogInfo((object)"ChestFlow 0.5.2 loaded.");
			}
			catch (Exception ex)
			{
				((BaseUnityPlugin)this).Logger.LogError((object)string.Format("{0} failed to initialize safely: {1}", "ChestFlow", ex));
				if (Core != null)
				{
					Core.Modules.SetState(ModuleId, (ModuleRuntimeState)5, ex.Message);
				}
				Shutdown();
				throw;
			}
		}

		private void PatchAllSafely()
		{
			Type[] array = (from type2 in typeof(Plugin).Assembly.GetTypes()
				where type2.GetCustomAttributes(typeof(HarmonyPatch), inherit: false).Length != 0
				select type2).OrderBy<Type, string>((Type type2) => type2.FullName, StringComparer.Ordinal).ToArray();
			int num = 0;
			Type[] array2 = array;
			foreach (Type type in array2)
			{
				try
				{
					_harmony.PatchAll(type);
					num++;
				}
				catch (Exception arg)
				{
					((BaseUnityPlugin)this).Logger.LogError((object)$"Failed to apply patch class {type.FullName}; other ChestFlow features will remain available: {arg}");
				}
			}
			((BaseUnityPlugin)this).Logger.LogInfo((object)$"Applied {num} of {array.Length} ChestFlow patch classes.");
		}

		private void Update()
		{
			//IL_0042: 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_005e: Unknown result type (might be due to invalid IL or missing references)
			if (!IsActive)
			{
				return;
			}
			MultiUserContainerService.Update();
			AutoFeedService.Update();
			NearbyResourceService.RepairInvalidPlayerInventoryPositions();
			if (ChestUpgradeService.UpdateLegacyMigration())
			{
				return;
			}
			ChestRuleEditor.Update();
			InventoryButtons.UpdateVisibility();
			if (ModConfig.Enabled.Value && CanAcceptShortcut())
			{
				if (IsShortcutDownAllowingOtherKeys(ModConfig.QuickStackShortcut.Value))
				{
					QuickStackNearby();
				}
				KeyboardShortcut value = ModConfig.SortChestShortcut.Value;
				if (((KeyboardShortcut)(ref value)).IsDown())
				{
					SortOpenChest();
				}
			}
		}

		internal void QuickStackNearby()
		{
			if (!IsActive)
			{
				return;
			}
			try
			{
				QuickStackService.BeginNearbyQuickStack(RestockProfileService.RestockNearby);
			}
			catch (Exception arg)
			{
				((BaseUnityPlugin)this).Logger.LogError((object)$"Nearby quick stack failed: {arg}");
			}
		}

		internal void SortOpenChest()
		{
			if (!IsActive)
			{
				return;
			}
			try
			{
				Container val = InventoryAccess.CurrentContainer(InventoryGui.instance);
				if ((Object)(object)val == (Object)null)
				{
					Player localPlayer = Player.m_localPlayer;
					if (localPlayer != null)
					{
						((Character)localPlayer).Message((MessageType)2, "Open a chest to sort it.", 0, (Sprite)null, false);
					}
				}
				else if (!MultiUserContainerService.TryDeferUntilOwned(val, SortOpenChest))
				{
					int num = InventorySorter.Sort(val.GetInventory(), ModConfig.ChestSortMode.Value, ModConfig.SortDescending.Value);
					Player localPlayer2 = Player.m_localPlayer;
					if (localPlayer2 != null)
					{
						((Character)localPlayer2).Message((MessageType)2, string.Format("Sorted {0} item stack{1} by {2}.", num, (num == 1) ? string.Empty : "s", ModConfig.ChestSortMode.Value), 0, (Sprite)null, false);
					}
				}
			}
			catch (Exception arg)
			{
				((BaseUnityPlugin)this).Logger.LogError((object)$"Chest sort failed: {arg}");
			}
		}

		internal void UpgradeOpenChest(int targetTier)
		{
			if (!IsActive)
			{
				return;
			}
			try
			{
				Container val = InventoryAccess.CurrentContainer(InventoryGui.instance);
				if (!((Object)(object)val != (Object)null) || !MultiUserContainerService.TryDeferUntilOwned(val, delegate
				{
					UpgradeOpenChest(targetTier);
				}))
				{
					ChestUpgradeService.UpgradeOpenChest(targetTier);
				}
			}
			catch (Exception arg)
			{
				((BaseUnityPlugin)this).Logger.LogError((object)$"Chest upgrade failed: {arg}");
				Player localPlayer = Player.m_localPlayer;
				if (localPlayer != null)
				{
					((Character)localPlayer).Message((MessageType)2, "Chest upgrade failed. See the log for details.", 0, (Sprite)null, false);
				}
			}
		}

		private static bool CanAcceptShortcut()
		{
			if ((Object)(object)Player.m_localPlayer == (Object)null)
			{
				return false;
			}
			if (ChestRuleEditor.IsOpen)
			{
				return false;
			}
			if ((Object)(object)Chat.instance != (Object)null && Chat.instance.HasFocus())
			{
				return false;
			}
			if (Console.IsVisible() || Menu.IsVisible() || TextInput.IsVisible())
			{
				return false;
			}
			if ((Object)(object)Minimap.instance != (Object)null && Minimap.InTextInput())
			{
				return false;
			}
			return true;
		}

		private static bool IsShortcutDownAllowingOtherKeys(KeyboardShortcut shortcut)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			KeyCode mainKey = ((KeyboardShortcut)(ref shortcut)).MainKey;
			if ((int)mainKey == 0 || !UnityInput.Current.GetKeyDown(mainKey))
			{
				return false;
			}
			return ((KeyboardShortcut)(ref shortcut)).Modifiers.All((KeyCode modifier) => modifier == mainKey || UnityInput.Current.GetKey(modifier));
		}

		private void OnDestroy()
		{
			Shutdown();
		}

		private void Shutdown()
		{
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			if (_shutDown)
			{
				return;
			}
			_shutDown = true;
			IsActive = false;
			QuickStackService?.Reset();
			MultiUserContainerService.Reset();
			AutoFeedService.Reset();
			InventoryButtons.Detach();
			TransferContext.End();
			Harmony? harmony = _harmony;
			if (harmony != null)
			{
				harmony.UnpatchSelf();
			}
			_harmony = null;
			for (int num = _registrations.Count - 1; num >= 0; num--)
			{
				try
				{
					_registrations[num].Dispose();
				}
				catch (Exception ex)
				{
					ManualLogSource logger = ((BaseUnityPlugin)this).Logger;
					if (logger != null)
					{
						logger.LogWarning((object)("Registration cleanup failed: " + ex.Message));
					}
				}
			}
			_registrations.Clear();
			if (Core != null)
			{
				Core.Metrics.RemoveOwner(ModuleId);
			}
			Core = null;
		}
	}
}
namespace ChestFlow.Runtime
{
	internal static class AutoFeedService
	{
		private sealed class ClientRequest
		{
			internal int Id;

			internal Container Container;

			internal ZDOID Animal;

			internal float Expires;

			internal float RetryAt;
		}

		private sealed class ServerRequest
		{
			internal string Key = "";

			internal int Id;

			internal long Sender;

			internal long Actor;

			internal Container Container;

			internal ZDOID Animal;

			internal long PreviousOwner;

			internal float Expires;

			internal bool Prepared;

			internal byte[]? Inventory;
		}

		internal const string TakeFoodRpc = "ChestFlow_AutoFeedTake";

		internal const string TakeFoodResponseRpc = "ChestFlow_AutoFeedTakeResponse";

		internal const string FinalizeFoodRpc = "ChestFlow_AutoFeedFinalize";

		internal const string PrepareFoodRpc = "ChestFlow_AutoFeedPrepare";

		internal const string PreparedFoodRpc = "ChestFlow_AutoFeedPrepared";

		private const string ReceiptKey = "ChestFlow.AutoFeedReceipt.v1";

		private const string LeaseKey = "ChestFlow.AutoFeedLeaseUntil.v1";

		private const int MaximumInventoryBytes = 65536;

		private static readonly FieldInfo TameableNetViewField = AccessTools.Field(typeof(Tameable), "m_nview");

		private static readonly FieldInfo MonsterAiField = AccessTools.Field(typeof(Tameable), "m_monsterAI");

		private static readonly MethodInfo ConsumedItemMethod = AccessTools.Method(typeof(Tameable), "OnConsumedItem", (Type[])null, (Type[])null);

		private static readonly FieldInfo ContainerNetViewField = AccessTools.Field(typeof(Container), "m_nview");

		private static readonly MethodInfo GetPrefabNameMethod = AccessTools.Method(typeof(ZNetView), "GetPrefabName", (Type[])null, (Type[])null);

		private static readonly MethodInfo InventoryChangedMethod = AccessTools.Method(typeof(Inventory), "Changed", new Type[2]
		{
			typeof(bool),
			typeof(bool)
		}, (Type[])null);

		private static readonly Dictionary<int, float> NextScanAt = new Dictionary<int, float>();

		private static readonly Dictionary<int, ClientRequest> ClientRequests = new Dictionary<int, ClientRequest>();

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

		private static readonly FeedRequestLedger Receipts = new FeedRequestLedger();

		private static readonly HashSet<ZDOID> BusyAnimals = new HashSet<ZDOID>();

		private static readonly HashSet<ZDOID> BlockedChests = new HashSet<ZDOID>();

		private static readonly Dictionary<long, Queue<float>> RequestRates = new Dictionary<long, Queue<float>>();

		private static int nextRequestId;

		internal static void Attach(Container container)
		{
			ZNetView view = GetNetView(container);
			if ((Object)(object)view == (Object)null || !view.IsValid())
			{
				return;
			}
			view.Register<ZPackage>("ChestFlow_AutoFeedTake", (Action<long, ZPackage>)delegate(long sender, ZPackage package)
			{
				ReceiveRequest(container, sender, package);
			});
			view.Register<int, bool>("ChestFlow_AutoFeedTakeResponse", (Action<long, int, bool>)delegate(long sender, int request, bool committed)
			{
				if (Plugin.IsActive && ChestAuthority.IsServerSender(sender) && ClientRequests.TryGetValue(request, out ClientRequest value) && !((Object)(object)value.Container != (Object)(object)container))
				{
					ClientRequests.Remove(request);
					view.InvokeRPC(sender, "ChestFlow_AutoFeedFinalize", new object[2] { request, committed });
				}
			});
			view.Register<int, bool>("ChestFlow_AutoFeedFinalize", (Action<long, int, bool>)delegate
			{
			});
			view.Register<ZPackage>("ChestFlow_AutoFeedPrepare", (Action<long, ZPackage>)delegate(long sender, ZPackage package)
			{
				PrepareInventory(container, sender, package);
			});
			view.Register<ZPackage>("ChestFlow_AutoFeedPrepared", (Action<long, ZPackage>)delegate(long sender, ZPackage package)
			{
				ReceivePrepared(container, sender, package);
			});
		}

		internal static void TryFeed(Tameable tameable)
		{
			//IL_01c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_021b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0220: Unknown result type (might be due to invalid IL or missing references)
			//IL_0239: Unknown result type (might be due to invalid IL or missing references)
			//IL_0294: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_02bb: Unknown result type (might be due to invalid IL or missing references)
			if (!Plugin.IsActive || !ModConfig.Enabled.Value || !ModConfig.AutoFeedEnabled.Value || (Object)(object)tameable == (Object)null || (Object)(object)ZNet.instance == (Object)null)
			{
				return;
			}
			ZNetView animalView = default(ZNetView);
			ref ZNetView reference = ref animalView;
			object? value = TameableNetViewField.GetValue(tameable);
			reference = (ZNetView)((value is ZNetView) ? value : null);
			object? value2 = MonsterAiField.GetValue(tameable);
			MonsterAI val = (MonsterAI)((value2 is MonsterAI) ? value2 : null);
			if ((Object)(object)animalView == (Object)null || !animalView.IsValid() || !animalView.IsOwner() || (Object)(object)val == (Object)null || ((BaseAI)val).IsAlerted() || !tameable.IsHungry())
			{
				return;
			}
			int instanceID = ((Object)tameable).GetInstanceID();
			float realtimeSinceStartup = Time.realtimeSinceStartup;
			if (NextScanAt.TryGetValue(instanceID, out var value3) && !AutoFeedPolicy.ShouldScan(realtimeSinceStartup, value3))
			{
				return;
			}
			NextScanAt[instanceID] = realtimeSinceStartup + ModConfig.AutoFeedInterval.Value;
			if (ClientRequests.Values.Any((ClientRequest request) => request.Animal == animalView.GetZDO().m_uid))
			{
				return;
			}
			Dictionary<string, ItemDrop> accepted = AcceptedFood(val);
			foreach (Container container in Object.FindObjectsByType<Container>((FindObjectsSortMode)0).OrderBy(delegate(Container candidate)
			{
				//IL_0006: 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_001b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0020: Unknown result type (might be due to invalid IL or missing references)
				Vector3 val2 = ((Component)candidate).transform.position - ((Component)tameable).transform.position;
				return ((Vector3)(ref val2)).sqrMagnitude;
			}))
			{
				long num;
				if (!ZNet.instance.IsServer())
				{
					Player localPlayer = Player.m_localPlayer;
					num = ((localPlayer != null) ? localPlayer.GetPlayerID() : 0);
				}
				else
				{
					num = Creator(container);
				}
				long actor = num;
				if (!IsEligible(container, ((Component)tameable).transform.position, actor) || !container.GetInventory().GetAllItems().Any((ItemData item) => !item.m_shared.m_questItem && accepted.ContainsKey(item.m_shared.m_name) && ChestReserveStore.Available(container, item) > 0))
				{
					continue;
				}
				int num2 = NextRequestId();
				ZDOID uid = animalView.GetZDO().m_uid;
				if (ZNet.instance.IsServer())
				{
					BeginRequest(container, 0L, num2, uid);
					break;
				}
				ZNetPeer serverPeer = ZNet.instance.GetServerPeer();
				if (serverPeer != null)
				{
					animalView.GetZDO().SetOwner(serverPeer.m_uid);
					ZDOMan.instance.ForceSendZDO(serverPeer.m_uid, animalView.GetZDO().m_uid);
					ClientRequest clientRequest = new ClientRequest
					{
						Id = num2,
						Container = container,
						Animal = uid,
						Expires = realtimeSinceStartup + 12f,
						RetryAt = realtimeSinceStartup + 1f
					};
					ClientRequests[num2] = clientRequest;
					SendRequest(serverPeer.m_uid, clientRequest);
				}
				break;
			}
		}

		internal static void Update()
		{
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ce: Expected O, but got Unknown
			//IL_01d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e1: Expected O, but got Unknown
			//IL_02c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0288: Unknown result type (might be due to invalid IL or missing references)
			//IL_0291: Unknown result type (might be due to invalid IL or missing references)
			//IL_0296: Unknown result type (might be due to invalid IL or missing references)
			//IL_029b: Unknown result type (might be due to invalid IL or missing references)
			if (!Plugin.IsActive)
			{
				return;
			}
			float realtimeSinceStartup = Time.realtimeSinceStartup;
			ClientRequest[] array = ClientRequests.Values.ToArray();
			foreach (ClientRequest clientRequest in array)
			{
				if ((Object)(object)clientRequest.Container == (Object)null || realtimeSinceStartup >= clientRequest.Expires)
				{
					ClientRequests.Remove(clientRequest.Id);
				}
				else if (!(realtimeSinceStartup < clientRequest.RetryAt))
				{
					clientRequest.RetryAt = realtimeSinceStartup + 1f;
					ZNet instance = ZNet.instance;
					ZNetPeer val = ((instance != null) ? instance.GetServerPeer() : null);
					if (val != null)
					{
						SendRequest(val.m_uid, clientRequest);
					}
				}
			}
			if ((Object)(object)ZNet.instance == (Object)null || !ZNet.instance.IsServer())
			{
				return;
			}
			ServerRequest[] array2 = ServerRequests.Values.ToArray();
			foreach (ServerRequest serverRequest in array2)
			{
				if ((Object)(object)serverRequest.Container == (Object)null || realtimeSinceStartup >= serverRequest.Expires)
				{
					Finish(serverRequest, committed: false);
					continue;
				}
				ZNetScene instance2 = ZNetScene.instance;
				GameObject obj = ((instance2 != null) ? instance2.FindInstance(serverRequest.Animal) : null);
				Tameable val2 = ((obj != null) ? obj.GetComponent<Tameable>() : null);
				ZNetView val3 = (ZNetView)(((Object)(object)val2 == (Object)null) ? null : /*isinst with value type is only supported in some contexts*/);
				ZNetView netView = GetNetView(serverRequest.Container);
				if ((Object)(object)val3 == (Object)null || !val3.IsValid() || !val3.IsOwner() || (Object)(object)netView == (Object)null || !netView.IsOwner() || !serverRequest.Prepared)
				{
					continue;
				}
				bool committed = false;
				try
				{
					if (serverRequest.Inventory != null)
					{
						Inventory inventory = serverRequest.Container.GetInventory();
						Inventory val4 = new Inventory("ChestFlow feed validation", inventory.GetBkg(), inventory.GetWidth(), inventory.GetHeight());
						val4.Load(new ZPackage(serverRequest.Inventory));
						inventory.GetAllItems().Clear();
						inventory.GetAllItems().AddRange(val4.GetAllItems());
						InventoryChangedMethod.Invoke(inventory, new object[2] { false, false });
						serverRequest.Inventory = null;
						MultiUserContainerService.SaveContainer(serverRequest.Container);
					}
					else
					{
						MultiUserContainerService.LoadContainer(serverRequest.Container);
					}
					long num = ((serverRequest.Sender == 0L) ? Creator(serverRequest.Container) : serverRequest.Actor);
					if (serverRequest.Sender != 0L)
					{
						if (ChestAuthority.ResolveActor(serverRequest.Sender, out var playerId, out var position) && playerId == num)
						{
							Vector3 val5 = position - ((Component)val2).transform.position;
							if (!(((Vector3)(ref val5)).sqrMagnitude > 16384f))
							{
								goto IL_02b5;
							}
						}
						Finish(serverRequest, committed: false);
						continue;
					}
					goto IL_02b5;
					IL_02b5:
					if (IsEligible(serverRequest.Container, ((Component)val2).transform.position, num, ownLease: true))
					{
						committed = CompleteOperation(serverRequest, val2);
					}
				}
				catch (Exception ex)
				{
					Plugin.LogInstance.LogError((object)("Server Auto Feed operation failed: " + ex));
				}
				Finish(serverRequest, committed);
			}
			long[] array3 = RequestRates.Keys.Where((long peer) => ZNet.instance.GetPeer(peer) == null).ToArray();
			foreach (long key in array3)
			{
				RequestRates.Remove(key);
			}
		}

		private static void SendRequest(long server, ClientRequest request)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Expected O, but got Unknown
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			ZPackage val = new ZPackage();
			val.Write(request.Id);
			val.Write(request.Animal);
			ZNetView? netView = GetNetView(request.Container);
			if (netView != null)
			{
				netView.InvokeRPC(server, "ChestFlow_AutoFeedTake", new object[1] { val });
			}
		}

		private static void ReceiveRequest(Container container, long sender, ZPackage package)
		{
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			if (!Plugin.IsActive || (Object)(object)ZNet.instance == (Object)null || !ZNet.instance.IsServer() || package == null || package.Size() > 64 || !ChestAuthority.ResolveActor(sender, out var _, out var _))
			{
				return;
			}
			if (!RequestRates.TryGetValue(sender, out Queue<float> value))
			{
				RequestRates.Add(sender, value = new Queue<float>());
			}
			float realtimeSinceStartup = Time.realtimeSinceStartup;
			while (value.Count > 0 && realtimeSinceStartup - value.Peek() >= 1f)
			{
				value.Dequeue();
			}
			if (value.Count >= 20)
			{
				return;
			}
			value.Enqueue(realtimeSinceStartup);
			try
			{
				int num = package.ReadInt();
				ZDOID animal = package.ReadZDOID();
				if (num > 0 && package.GetPos() == package.Size())
				{
					BeginRequest(container, sender, num, animal);
				}
			}
			catch (Exception ex)
			{
				Plugin.LogInstance.LogWarning((object)("Rejected Auto Feed request: " + ex.Message));
			}
		}

		private unsafe static void BeginRequest(Container container, long sender, int id, ZDOID animal)
		{
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: 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_018e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0153: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0232: Unknown result type (might be due to invalid IL or missing references)
			//IL_0233: Unknown result type (might be due to invalid IL or missing references)
			//IL_027a: 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_02bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c4: Expected O, but got Unknown
			ZNetView netView = GetNetView(container);
			if (!ModConfig.Enabled.Value || !ModConfig.AutoFeedEnabled.Value || (Object)(object)netView == (Object)null || !netView.IsValid() || BlockedChests.Contains(netView.GetZDO().m_uid))
			{
				return;
			}
			string text = sender + ":" + id;
			ZDOID uid = netView.GetZDO().m_uid;
			string? text2 = ((object)(*(ZDOID*)(&uid))/*cast due to .constrained prefix*/).ToString();
			uid = animal;
			string context = text2 + "/" + ((object)(*(ZDOID*)(&uid))/*cast due to .constrained prefix*/).ToString();
			FeedRequestState feedRequestState = Receipts.Begin(text, context, Time.realtimeSinceStartup);
			if (feedRequestState != FeedRequestState.New)
			{
				if (sender != 0L && feedRequestState != FeedRequestState.Pending)
				{
					netView.InvokeRPC(sender, "ChestFlow_AutoFeedTakeResponse", new object[2]
					{
						id,
						feedRequestState == FeedRequestState.Committed
					});
				}
				return;
			}
			long playerId = Creator(container);
			if (sender != 0L && !ChestAuthority.ResolveActor(sender, out playerId, out var _))
			{
				Receipts.Complete(text, committed: false);
				return;
			}
			ZNetScene instance = ZNetScene.instance;
			GameObject obj = ((instance != null) ? instance.FindInstance(animal) : null);
			Tameable val = ((obj != null) ? obj.GetComponent<Tameable>() : null);
			if ((Object)(object)val == (Object)null || !IsEligible(container, ((Component)val).transform.position, playerId) || ServerRequests.Count >= 64 || BusyAnimals.Contains(animal))
			{
				Receipts.Complete(text, committed: false);
				if (sender != 0L)
				{
					netView.InvokeRPC(sender, "ChestFlow_AutoFeedTakeResponse", new object[2] { id, false });
				}
				ReturnAnimal(animal, sender);
				return;
			}
			string text3 = netView.GetZDO().GetString("ChestFlow.AutoFeedReceipt.v1", "");
			uid = animal;
			if (text3 == text + "/" + ((object)(*(ZDOID*)(&uid))/*cast due to .constrained prefix*/).ToString())
			{
				Receipts.Complete(text, committed: true);
				if (sender != 0L)
				{
					netView.InvokeRPC(sender, "ChestFlow_AutoFeedTakeResponse", new object[2] { id, true });
				}
				ReturnAnimal(animal, sender);
				return;
			}
			ServerRequest serverRequest = new ServerRequest
			{
				Key = text,
				Id = id,
				Sender = sender,
				Actor = playerId,
				Container = container,
				Animal = animal,
				PreviousOwner = netView.GetZDO().GetOwner(),
				Expires = Time.realtimeSinceStartup + 8f,
				Prepared = netView.IsOwner()
			};
			ServerRequests.Add(text, serverRequest);
			BusyAnimals.Add(animal);
			if (serverRequest.Prepared)
			{
				SetLease(netView);
			}
			else if (serverRequest.PreviousOwner == 0L)
			{
				netView.ClaimOwnership();
				serverRequest.Prepared = netView.IsOwner();
				if (serverRequest.Prepared)
				{
					SetLease(netView);
				}
			}
			else
			{
				ZPackage val2 = new ZPackage();
				val2.Write(text);
				netView.InvokeRPC(serverRequest.PreviousOwner, "ChestFlow_AutoFeedPrepare", new object[1] { val2 });
			}
		}

		private static void PrepareInventory(Container container, long sender, ZPackage package)
		{
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Expected O, but got Unknown
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Expected O, but got Unknown
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			if (!Plugin.IsActive)
			{
				return;
			}
			ZNetView netView = GetNetView(container);
			if (!ChestAuthority.IsServerSender(sender) || (Object)(object)netView == (Object)null || !netView.IsOwner() || container.IsInUse() || package == null || package.Size() > 128)
			{
				return;
			}
			try
			{
				string text = package.ReadString();
				if (text.Length <= 96 && package.GetPos() == package.Size())
				{
					MultiUserContainerService.SaveContainer(container);
					ZPackage val = new ZPackage();
					container.GetInventory().Save(val);
					byte[] array = val.GetArray();
					if (array.Length <= 65536)
					{
						ZPackage val2 = new ZPackage();
						val2.Write(text);
						val2.Write(array);
						SetLease(netView);
						netView.GetZDO().SetOwner(sender);
						ZDOMan.instance.ForceSendZDO(sender, netView.GetZDO().m_uid);
						netView.InvokeRPC(sender, "ChestFlow_AutoFeedPrepared", new object[1] { val2 });
					}
				}
			}
			catch (Exception ex)
			{
				Plugin.LogInstance.LogWarning((object)("Could not prepare Auto Feed chest: " + ex.Message));
			}
		}

		private static void ReceivePrepared(Container container, long sender, ZPackage package)
		{
			if (!Plugin.IsActive || (Object)(object)ZNet.instance == (Object)null || !ZNet.instance.IsServer() || package == null || package.Size() > 65792)
			{
				return;
			}
			try
			{
				string text = package.ReadString();
				byte[] array = package.ReadByteArray();
				if (text.Length <= 96 && array.Length <= 65536 && package.GetPos() == package.Size() && ServerRequests.TryGetValue(text, out ServerRequest value) && !((Object)(object)value.Container != (Object)(object)container) && value.PreviousOwner == sender && !value.Prepared)
				{
					value.Inventory = array;
					value.Prepared = true;
				}
			}
			catch (Exception ex)
			{
				Plugin.LogInstance.LogWarning((object)("Rejected Auto Feed chest preparation: " + ex.Message));
			}
		}

		private unsafe static bool CompleteOperation(ServerRequest request, Tameable tameable)
		{
			//IL_01d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0129: Unknown result type (might be due to invalid IL or missing references)
			object? value = MonsterAiField.GetValue(tameable);
			MonsterAI val = (MonsterAI)((value is MonsterAI) ? value : null);
			if ((Object)(object)val == (Object)null || ((BaseAI)val).IsAlerted() || !tameable.IsHungry())
			{
				return false;
			}
			Dictionary<string, ItemDrop> accepted = AcceptedFood(val);
			Inventory inventory = request.Container.GetInventory();
			ItemData item = ((IEnumerable<ItemData>)inventory.GetAllItems()).FirstOrDefault((Func<ItemData, bool>)((ItemData candidate) => !candidate.m_shared.m_questItem && accepted.ContainsKey(candidate.m_shared.m_name) && ChestReserveStore.Available(request.Container, candidate) > 0));
			if (item == null)
			{
				return false;
			}
			ItemData[] originals = inventory.GetAllItems().ToArray();
			int[] stacks = originals.Select((ItemData candidate) => candidate.m_stack).ToArray();
			Vector2i[] positions = originals.Select((ItemData candidate) => candidate.m_gridPos).ToArray();
			ZDO animal = ((ZNetView)TameableNetViewField.GetValue(tameable)).GetZDO();
			long before = animal.GetLong(ZDOVars.s_tameLastFeeding, 0L);
			ZDO chest = GetNetView(request.Container).GetZDO();
			string oldReceipt = chest.GetString("ChestFlow.AutoFeedReceipt.v1", "");
			try
			{
				return FeedTransaction.Execute(() => inventory.RemoveItem(item, 1), delegate
				{
					ConsumedItemMethod.Invoke(tameable, new object[1] { accepted[item.m_shared.m_name] });
				}, () => !tameable.IsHungry(), delegate
				{
					//IL_0031: Unknown result type (might be due to invalid IL or missing references)
					//IL_0036: Unknown result type (might be due to invalid IL or missing references)
					MultiUserContainerService.SaveContainer(request.Container);
					ZDO obj = chest;
					string key = request.Key;
					ZDOID animal2 = request.Animal;
					obj.Set("ChestFlow.AutoFeedReceipt.v1", key + "/" + ((object)(*(ZDOID*)(&animal2))/*cast due to .constrained prefix*/).ToString());
				}, delegate
				{
					//IL_004e: Unknown result type (might be due to invalid IL or missing references)
					//IL_0053: Unknown result type (might be due to invalid IL or missing references)
					inventory.GetAllItems().Clear();
					inventory.GetAllItems().AddRange(originals);
					for (int i = 0; i < originals.Length; i++)
					{
						originals[i].m_stack = stacks[i];
						originals[i].m_gridPos = positions[i];
					}
					animal.Set(ZDOVars.s_tameLastFeeding, before);
					chest.Set("ChestFlow.AutoFeedReceipt.v1", oldReceipt);
					InventoryChangedMethod.Invoke(inventory, new object[2] { false, false });
					MultiUserContainerService.SaveContainer(request.Container);
				});
			}
			catch (AggregateException ex)
			{
				BlockedChests.Add(chest.m_uid);
				Plugin.LogInstance.LogError((object)("Auto Feed could not finish rollback persistence. This chest is paused; preserve the world and logs before recovery: " + ex));
				return false;
			}
		}

		private static void Finish(ServerRequest request, bool committed)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			ServerRequests.Remove(request.Key);
			BusyAnimals.Remove(request.Animal);
			Receipts.Complete(request.Key, committed);
			ZNetView netView = GetNetView(request.Container);
			if ((Object)(object)netView != (Object)null && netView.IsOwner())
			{
				netView.GetZDO().Set("ChestFlow.AutoFeedLeaseUntil.v1", 0L);
			}
			if (request.Sender != 0L && (Object)(object)request.Container != (Object)null)
			{
				ZNetView? netView2 = GetNetView(request.Container);
				if (netView2 != null)
				{
					netView2.InvokeRPC(request.Sender, "ChestFlow_AutoFeedTakeResponse", new object[2] { request.Id, committed });
				}
			}
			ReturnAnimal(request.Animal, request.Sender);
		}

		private static void ReturnAnimal(ZDOID animal, long sender)
		{
			//IL_0024: 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)
			if (sender == 0L)
			{
				return;
			}
			ZNet instance = ZNet.instance;
			if (((instance != null) ? instance.GetPeer(sender) : null) != null)
			{
				ZNetScene instance2 = ZNetScene.instance;
				object obj;
				if (instance2 == null)
				{
					obj = null;
				}
				else
				{
					GameObject obj2 = instance2.FindInstance(animal);
					obj = ((obj2 != null) ? obj2.GetComponent<ZNetView>() : null);
				}
				ZNetView val = (ZNetView)obj;
				if (!((Object)(object)val == (Object)null) && val.IsValid() && val.IsOwner())
				{
					val.GetZDO().SetOwner(sender);
					ZDOMan.instance.ForceSendZDO(sender, animal);
				}
			}
		}

		internal static bool IsLocked(Container container)
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			ZNetView? netView = GetNetView(container);
			ZDO val = ((netView != null) ? netView.GetZDO() : null);
			if (val != null)
			{
				if (!BlockedChests.Contains(val.m_uid))
				{
					if ((Object)(object)ZNet.instance != (Object)null)
					{
						return val.GetLong("ChestFlow.AutoFeedLeaseUntil.v1", 0L) > ZNet.instance.GetTime().Ticks;
					}
					return false;
				}
				return true;
			}
			return false;
		}

		private static void SetLease(ZNetView view)
		{
			view.GetZDO().Set("ChestFlow.AutoFeedLeaseUntil.v1", ZNet.instance.GetTime().AddSeconds(12.0).Ticks);
		}

		private static bool IsEligible(Container container, Vector3 animalPosition, long actor, bool ownLease = false)
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_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)
			if (!((Object)(object)container == (Object)null) && ((Behaviour)container).isActiveAndEnabled && !container.IsInUse() && (ownLease || !IsLocked(container)))
			{
				Vector3 val = ((Component)container).transform.position - animalPosition;
				if (!(((Vector3)(ref val)).sqrMagnitude > ModConfig.AutoFeedRange.Value * ModConfig.AutoFeedRange.Value) && !((Object)(object)((Component)container).GetComponent<Player>() != (Object)null) && !((Object)(object)((Component)container).GetComponent<TombStone>() != (Object)null))
				{
					if (!ModConfig.IncludeVehicleContainers.Value && ((Object)(object)container.m_wagon != (Object)null || (Object)(object)((Component)container).GetComponentInParent<Ship>() != (Object)null))
					{
						return false;
					}
					Piece val2 = ((Component)container).GetComponent<Piece>() ?? ((Component)container).GetComponentInParent<Piece>();
					if (!ModConfig.IncludeWorldContainers.Value && ((Object)(object)val2 == (Object)null || !val2.IsPlacedByPlayer()))
					{
						return false;
					}
					ZNetView netView = GetNetView(container);
					if ((Object)(object)netView == (Object)null || !netView.IsValid() || !AutoFeedPolicy.MatchesContainerPrefix(GetPrefabNameMethod.Invoke(netView, Array.Empty<object>()) as string, ModConfig.AutoFeedContainerPrefix.Value))
					{
						return false;
					}
					if (MultiUserContainerService.HasAccess(container, actor))
					{
						return ChestAuthority.WardAccess(container, actor);
					}
					return false;
				}
			}
			return false;
		}

		private static long Creator(Container container)
		{
			Piece obj = ((Component)container).GetComponent<Piece>() ?? ((Component)container).GetComponentInParent<Piece>();
			if (obj == null)
			{
				return 0L;
			}
			return obj.GetCreator();
		}

		private static Dictionary<string, ItemDrop> AcceptedFood(MonsterAI monsterAi)
		{
			Dictionary<string, ItemDrop> dictionary = new Dictionary<string, ItemDrop>(StringComparer.Ordinal);
			foreach (ItemDrop item in monsterAi.m_consumeItems ?? new List<ItemDrop>())
			{
				string text = item?.m_itemData?.m_shared?.m_name;
				if ((Object)(object)item != (Object)null && !string.IsNullOrEmpty(text) && !dictionary.ContainsKey(text))
				{
					dictionary.Add(text, item);
				}
			}
			return dictionary;
		}

		private static ZNetView? GetNetView(Container container)
		{
			if (!((Object)(object)container == (Object)null))
			{
				object? value = ContainerNetViewField.GetValue(container);
				return (ZNetView?)((value is ZNetView) ? value : null);
			}
			return null;
		}

		private static int NextRequestId()
		{
			nextRequestId = ((nextRequestId == int.MaxValue) ? 1 : (nextRequestId + 1));
			return nextRequestId;
		}

		internal static void Reset()
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			ServerRequest[] array = ServerRequests.Values.ToArray();
			foreach (ServerRequest serverRequest in array)
			{
				ReturnAnimal(serverRequest.Animal, serverRequest.Sender);
			}
			ServerRequests.Clear();
			ClientRequests.Clear();
			BusyAnimals.Clear();
			BlockedChests.Clear();
			Receipts.Clear();
			NextScanAt.Clear();
			RequestRates.Clear();
		}
	}
	internal static class ChestAuthority
	{
		private static readonly FieldInfo AllAreas = AccessTools.Field(typeof(PrivateArea), "m_allAreas");

		private static readonly MethodInfo IsPermitted = AccessTools.Method(typeof(PrivateArea), "IsPermitted", (Type[])null, (Type[])null);

		private static readonly MethodInfo IsInside = AccessTools.Method(typeof(PrivateArea), "IsInside", (Type[])null, (Type[])null);

		private static readonly MethodInfo IsEnabled = AccessTools.Method(typeof(PrivateArea), "IsEnabled", (Type[])null, (Type[])null);

		internal static bool IsServerSender(long sender)
		{
			if ((Object)(object)ZNet.instance != (Object)null && !ZNet.instance.IsServer())
			{
				ZNetPeer serverPeer = ZNet.instance.GetServerPeer();
				if (serverPeer == null)
				{
					return false;
				}
				return serverPeer.m_uid == sender;
			}
			return false;
		}

		internal static bool ResolveActor(long sender, out long playerId, out Vector3 position)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: 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_0117: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			playerId = 0L;
			position = Vector3.zero;
			ZNet instance = ZNet.instance;
			if ((Object)(object)instance == (Object)null)
			{
				return false;
			}
			ZNetPeer peer = instance.GetPeer(sender);
			if (instance.IsServer() && peer == null)
			{
				return false;
			}
			if (peer != null && peer.m_characterID != ZDOID.None)
			{
				ZDOMan instance2 = ZDOMan.instance;
				ZDO val = ((instance2 != null) ? instance2.GetZDO(peer.m_characterID) : null);
				if (val != null && val.GetOwner() == sender)
				{
					ZNetScene instance3 = ZNetScene.instance;
					object obj;
					if (instance3 == null)
					{
						obj = null;
					}
					else
					{
						GameObject prefab = instance3.GetPrefab(val.GetPrefab());
						obj = ((prefab != null) ? prefab.GetComponent<Player>() : null);
					}
					if (!((Object)obj == (Object)null))
					{
						playerId = val.GetLong(ZDOVars.s_playerID, 0L);
						position = val.GetPosition();
						return playerId != 0;
					}
				}
				return false;
			}
			foreach (Player allPlayer in Player.GetAllPlayers())
			{
				ZNetView component = ((Component)allPlayer).GetComponent<ZNetView>();
				if (!((Object)(object)component == (Object)null) && component.IsValid() && component.GetZDO().GetOwner() == sender)
				{
					playerId = allPlayer.GetPlayerID();
					position = ((Component)allPlayer).transform.position;
					return playerId != 0;
				}
			}
			return false;
		}

		internal static bool CanUse(Container container, long sender, long claimedPlayerId)
		{
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: 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)
			if (!ResolveActor(sender, out var playerId, out var position) || playerId != claimedPlayerId)
			{
				return false;
			}
			float num = Mathf.Clamp(ModConfig.NearbyRange.Value, 4f, 100f);
			Vector3 val = ((Component)container).transform.position - position;
			if (((Vector3)(ref val)).sqrMagnitude <= num * num && MultiUserContainerService.HasAccess(container, playerId))
			{
				return WardAccess(container, playerId);
			}
			return false;
		}

		internal static bool WardAccess(Container container, long playerId)
		{
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			if (!container.m_checkGuardStone)
			{
				return true;
			}
			if (!(AllAreas.GetValue(null) is IEnumerable<PrivateArea> enumerable))
			{
				return false;
			}
			bool flag = false;
			bool flag2 = default(bool);
			foreach (PrivateArea item in enumerable)
			{
				if ((Object)(object)item == (Object)null)
				{
					continue;
				}
				object obj = IsEnabled.Invoke(item, Array.Empty<object>());
				if (!(obj is bool) || !(bool)obj)
				{
					continue;
				}
				obj = IsInside.Invoke(item, new object[2]
				{
					((Component)container).transform.position,
					0f
				});
				if (!(obj is bool) || !(bool)obj)
				{
					continue;
				}
				flag = true;
				Piece component = ((Component)item).GetComponent<Piece>();
				if (playerId == 0L)
				{
					continue;
				}
				if (component == null || component.GetCreator() != playerId)
				{
					obj = IsPermitted.Invoke(item, new object[1] { playerId });
					int num;
					if (obj is bool)
					{
						flag2 = (bool)obj;
						num = 1;
					}
					else
					{
						num = 0;
					}
					if (((uint)num & (flag2 ? 1u : 0u)) == 0)
					{
						continue;
					}
				}
				return true;
			}
			return !flag;
		}
	}
	internal static class ChestReserveStore
	{
		internal const string Key = "ChestFlow.StorageReserves.v1";

		internal static string ReadRaw(Container container)
		{
			ZNetView component = ((Component)container).GetComponent<ZNetView>();
			object obj;
			if (component == null)
			{
				obj = null;
			}
			else
			{
				ZDO zDO = component.GetZDO();
				obj = ((zDO != null) ? zDO.GetString("ChestFlow.StorageReserves.v1", "") : null);
			}
			if (obj == null)
			{
				obj = "";
			}
			return (string)obj;
		}

		internal static int Available(Container container, ItemData item)
		{
			try
			{
				Dictionary<string, int> dictionary = StorageReserves.Decode(ReadRaw(container));
				string prefab = ValheimItemCategoryClassifier.PrefabName(item);
				if (!dictionary.TryGetValue(prefab, out var value))
				{
					return item.m_stack;
				}
				int total = (from candidate in container.GetInventory().GetAllItems()
					where string.Equals(ValheimItemCategoryClassifier.PrefabName(candidate), prefab, StringComparison.OrdinalIgnoreCase)
					select candidate).Sum((ItemData candidate) => candidate.m_stack);
				return Math.Min(item.m_stack, StorageReserves.Available(total, value));
			}
			catch (Exception)
			{
				return 0;
			}
		}

		internal static int Count(Container container, string name, int quality)
		{
			try
			{
				Dictionary<string, int> dictionary = StorageReserves.Decode(ReadRaw(container));
				int num = 0;
				foreach (IGrouping<string, ItemData> item in (from item in container.GetInventory().GetAllItems()
					where item.m_shared.m_name == name && !item.m_shared.m_questItem
					select item).GroupBy<ItemData, string>(ValheimItemCategoryClassifier.PrefabName, StringComparer.OrdinalIgnoreCase))
				{
					dictionary.TryGetValue(item.Key, out var value);
					num += Math.Min(item.Where((ItemData item) => item.m_worldLevel >= Game.m_worldLevel && (quality < 0 || item.m_quality == quality)).Sum((ItemData item) => item.m_stack), StorageReserves.Available(item.Sum((ItemData item) => item.m_stack), value));
				}
				return num;
			}
			catch (Exception)
			{
				return 0;
			}
		}

		internal static void Write(Container container, string encoded)
		{
			StorageReserves.Decode(encoded);
			ZNetView component = ((Component)container).GetComponent<ZNetView>();
			if ((Object)(object)component == (Object)null || !component.IsValid() || !component.IsOwner() || AutoFeedService.IsLocked(container))
			{
				throw new InvalidOperationException("Open the chest and wait for ownership before changing its reserves.");
			}
			component.GetZDO().Set("ChestFlow.StorageReserves.v1", encoded);
		}
	}
	internal static class ChestRuleEditor
	{
		private sealed class ButtonVisual
		{
			internal RectTransform Rect { get; }

			internal Image Image { get; }

			internal Button Button { get; }

			internal TMP_Text Label { get; }

			internal Color NormalImageColor { get; }

			internal Color NormalLabelColor { get; }

			internal ButtonVisual(RectTransform rect, Image image, Button button, TMP_Text label, Color normalImageColor, Color normalLabelColor)
			{
				//IL_0024: Unknown result type (might be due to invalid IL or missing references)
				//IL_0026: Unknown result type (might be due to invalid IL or missing references)
				//IL_002c: Unknown result type (might be due to invalid IL or missing references)
				//IL_002e: Unknown result type (might be due to invalid IL or missing references)
				Rect = rect;
				Image = image;
				Button = button;
				Label = label;
				NormalImageColor = normalImageColor;
				NormalLabelColor = normalLabelColor;
			}
		}

		private sealed class ItemChoice
		{
			internal string PrefabName { get; }

			internal string DisplayName { get; }

			internal ItemCategory Category { get; }

			internal Sprite? Icon { get; }

			internal string SearchText { get; }

			internal ItemChoice(string prefabName, string displayName, ItemCategory category, Sprite? icon)
			{
				PrefabName = prefabName;
				DisplayName = displayName;
				Category = category;
				Icon = icon;
				ItemCategoryDefinition itemCategoryDefinition = ItemCategoryCatalog.Get(category);
				SearchText = displayName + " " + prefabName + " " + itemCategoryDefinition.DisplayName + " " + itemCategoryDefinition.Group;
			}
		}

		[CompilerGenerated]
		private static class <>O
		{
			public static UnityAction <0>__Save;

			public static Func<Image, float> <1>__ImageArea;
		}

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

			public static UnityAction <>9__49_0;

			public static UnityAction <>9__49_1;

			public static Action<string> <>9__55_0;

			public static Func<ItemCategoryDefinition, bool> <>9__55_1;

			public static Action<string> <>9__56_0;

			public static UnityAction<string> <>9__59_0;

			public static Func<ItemChoice, bool> <>9__61_0;

			public static Func<ItemChoice, int> <>9__64_0;

			public static Func<ItemChoice, string> <>9__64_1;

			public static Func<ItemChoice, string> <>9__64_2;

			public static Func<Image, bool> <>9__81_0;

			internal void <Build>b__49_0()
			{
				Close();
			}

			internal void <Build>b__49_1()
			{
				Close();
			}

			internal void <BuildCategoryView>b__55_0(string groupId)
			{
				_activeCategoryGroupId = groupId;
				RenderScope();
			}

			internal bool <BuildCategoryView>b__55_1(ItemCategoryDefinition definition)
			{
				return string.Equals(definition.GroupId, _activeCategoryGroupId, StringComparison.OrdinalIgnoreCase);
			}

			internal void <BuildItemsView>b__56_0(string groupId)
			{
				_activeItemGroupId = groupId;
				RenderScope();
			}

			internal void <CreateSearchField>b__59_0(string value)
			{
				_itemSearch = value ?? string.Empty;
				RefreshItemTiles();
			}

			internal bool <RenderItemTiles>b__61_0(ItemChoice choice)
			{
				return string.Equals(ItemCategoryCatalog.Get(choice.Category).GroupId, _activeItemGroupId, StringComparison.OrdinalIgnoreCase);
			}

			internal int <CollectItemChoices>b__64_0(ItemChoice choice)
			{
				return ItemCategoryCatalog.SortRank(choice.Category);
			}

			internal string <CollectItemChoices>b__64_1(ItemChoice choice)
			{
				return choice.DisplayName;
			}

			internal string <CollectItemChoices>b__64_2(ItemChoice choice)
			{
				return choice.PrefabName;
			}

			internal bool <FindContainerBackground>b__81_0(Image candidate)
			{
				if ((Object)(object)candidate.sprite != (Object)null)
				{
					if (((Object)((Component)candidate).gameObject).name.IndexOf("bkg", StringComparison.OrdinalIgnoreCase) < 0)
					{
						return ((Object)((Component)candidate).gameObject).name.IndexOf("background", StringComparison.OrdinalIgnoreCase) >= 0;
					}
					return true;
				}
				return false;
			}
		}

		private const string Prefix = "ChestFlow_RuleEditor_";

		private const float PanelWidth = 900f;

		private const float PanelHeight = 650f;

		private const float RailWidth = 190f;

		private const float Gap = 10f;

		private static readonly Color Gold = new Color(1f, 0.66f, 0.24f, 1f);

		private static readonly Color GoldFaint = new Color(0.95f, 0.58f, 0.18f, 0.42f);

		private static readonly Color SelectedGold = new Color(1f, 0.76f, 0.42f, 1f);

		private static readonly Color Cream = new Color(0.9f, 0.87f, 0.79f, 1f);

		private static readonly Color Muted = new Color(0.73f, 0.69f, 0.61f, 1f);

		private static InventoryGui? _gui;

		private static Container? _container;

		private static GameObject? _root;

		private static RectTransform? _body;

		private static RectTransform? _itemContent;

		private static TMP_Text? _status;

		private static Image? _panelImage;

		private static Image? _sourcePanelImage;

		private static Button? _buttonTemplate;

		private static TMP_Text? _titleTemplate;

		private static Sprite? _buttonSprite;

		private static Type _buttonImageType;

		private static Color _buttonImageColor = Color.white;

		private static Color _buttonLabelColor = Gold;

		private static TMP_FontAsset? _bodyFont;

		private static Material? _bodyFontMaterial;

		private static Sprite? _panelSprite;

		private static Type _panelImageType;

		private static Color _panelImageColor = Color.white;

		private static Material? _panelMaterial;

		private static bool _panelFillCenter = true;

		private static bool _panelPreserveAspect;

		private static float _panelPixelsPerUnitMultiplier = 1f;

		private static bool _panelUseSpriteMesh;

		private static ChestRuleScope _scope;

		private static string _selectedGroupId = "materials";

		private static string _activeCategoryGroupId = "materials";

		private static string _activeItemGroupId = "materials";

		private static string _itemSearch = string.Empty;

		private static readonly HashSet<ItemCategory> SelectedCategories = new HashSet<ItemCategory>();

		private static readonly HashSet<string> SelectedItems = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

		private static readonly Dictionary<ChestRuleScope, ButtonVisual> ModeButtons = new Dictionary<ChestRuleScope, ButtonVisual>();

		private static readonly Dictionary<string, ButtonVisual> BrowserGroupButtons = new Dictionary<string, ButtonVisual>(StringComparer.OrdinalIgnoreCase);

		private static readonly List<ItemChoice> ItemChoices = new List<ItemChoice>();

		internal static bool IsOpen => (Object)(object)_root != (Object)null;

		internal static void Open(InventoryGui gui, Container container)
		{
			if (!((Object)(object)gui == (Object)null) && !((Object)(object)container == (Object)null))
			{
				Close();
				_gui = gui;
				_container = container;
				ChestStorageRule chestStorageRule = ChestRuleStore.Read(container);
				_scope = chestStorageRule.Scope;
				_selectedGroupId = ((chestStorageRule.Scope == ChestRuleScope.Group) ? chestStorageRule.GroupId : "materials");
				_activeCategoryGroupId = FirstCategoryGroup(chestStorageRule) ?? "materials";
				_activeItemGroupId = "materials";
				_itemSearch = string.Empty;
				SelectedCategories.Clear();
				SelectedCategories.UnionWith(chestStorageRule.Categories);
				SelectedItems.Clear();
				SelectedItems.UnionWith(chestStorageRule.ItemPrefabNames);
				CollectItemChoices(container);
				Build(gui, container);
			}
		}

		internal static void Update()
		{
			if ((Object)(object)_root == (Object)null)
			{
				return;
			}
			if ((Object)(object)_gui == (Object)null || (Object)(object)_container == (Object)null || !InventoryGui.IsVisible() || (Object)(object)InventoryAccess.CurrentContainer(_gui) != (Object)(object)_container)
			{
				Close();
				return;
			}
			RefreshPanelBackground();
			if (Input.GetKeyDown((KeyCode)27))
			{
				Close();
			}
		}

		internal static void Close(InventoryGui? gui = null)
		{
			if (!((Object)(object)gui != (Object)null) || !((Object)(object)_gui != (Object)null) || !((Object)(object)gui != (Object)(object)_gui))
			{
				if ((Object)(object)_root != (Object)null)
				{
					_root.SetActive(false);
					Object.Destroy((Object)(object)_root);
				}
				_root = null;
				_body = null;
				_itemContent = null;
				_status = null;
				_panelImage = null;
				_sourcePanelImage = null;
				_gui = null;
				_container = null;
				ModeButtons.Clear();
				BrowserGroupButtons.Clear();
				ItemChoices.Clear();
			}
		}

		private static void Build(InventoryGui gui, Container container)
		{
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Expected O, but got Unknown
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Expected O, but got Unknown
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0103: Unknown result type (might be due to invalid IL or missing references)
			//IL_0118: Unknown result type (might be due to invalid IL or missing references)
			//IL_0161: Unknown result type (might be due to invalid IL or missing references)
			//IL_017f: Expected O, but got Unknown
			//IL_01d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0211: Expected O, but got Unknown
			//IL_02d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0338: Unknown result type (might be due to invalid IL or missing references)
			//IL_0357: Unknown result type (might be due to invalid IL or missing references)
			//IL_0375: Unknown result type (might be due to invalid IL or missing references)
			//IL_0393: Expected O, but got Unknown
			//IL_0268: Unknown result type (might be due to invalid IL or missing references)
			//IL_026d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0273: Expected O, but got Unknown
			//IL_03f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_03fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0400: Expected O, but got Unknown
			//IL_045f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0464: Unknown result type (might be due to invalid IL or missing references)
			//IL_046a: Expected O, but got Unknown
			Transform transform = ((Component)gui).transform;
			RectTransform val = (RectTransform)(object)(((transform is RectTransform) ? transform : null) ?? throw new InvalidOperationException("InventoryGui does not use a RectTransform root."));
			_root = new GameObject("ChestFlow_RuleEditor_Overlay", new Type[2]
			{
				typeof(RectTransform),
				typeof(Image)
			});
			_root.transform.SetParent((Transform)(object)val, false);
			_root.transform.SetAsLastSibling();
			RectTransform val2 = (RectTransform)_root.transform;
			Stretch(val2, Vector2.zero, Vector2.zero);
			Image component = _root.GetComponent<Image>();
			((Graphic)component).color = new Color(0f, 0f, 0f, 0.52f);
			((Graphic)component).raycastTarget = true;
			CaptureVanillaStyle(gui, container);
			RectTransform val3 = CreateRect("ChestFlow_RuleEditor_Panel", (Transform)(object)val2);
			Vector2 val4 = default(Vector2);
			((Vector2)(ref val4))..ctor(0.5f, 0.5f);
			val3.anchorMax = val4;
			val3.anchorMin = val4;
			val3.pivot = new Vector2(0.5f, 0.5f);
			val3.anchoredPosition = Vector2.zero;
			val3.sizeDelta = new Vector2(900f, 650f);
			_panelImage = ((Component)val3).gameObject.AddComponent<Image>();
			ApplyPanelStyle(_panelImage);
			TMP_Text obj = CreateVanillaTitle((Transform)(object)val3, "ChestFlow_RuleEditor_Title", "Storage Rule", 30f);
			obj.alignment = (TextAlignmentOptions)514;
			SetTopRect((RectTransform)obj.transform, 70f, 8f, 70f, 40f);
			string content = (((Object)(object)gui.m_containerName != (Object)null && !string.IsNullOrWhiteSpace(gui.m_containerName.text)) ? gui.m_containerName.text : ((Localization.instance != null) ? Localization.instance.Localize(container.m_name) : container.m_name));
			TMP_Text obj2 = CreateText((Transform)(object)val3, "ChestFlow_RuleEditor_Subtitle", content, 13f, Gold, (TextAlignmentOptions)514);
			obj2.fontStyle = (FontStyles)1;
			SetTopRect((RectTransform)obj2.transform, 70f, 43f, 70f, 24f);
			ButtonVisual buttonVisual = CreateButton((Transform)(object)val3, "ChestFlow_RuleEditor_Close", "×", 16f, (TextAlignmentOptions)514);
			SetTopRect(buttonVisual.Rect, 842f, 10f, 14f, 38f);
			ButtonClickedEvent onClick = buttonVisual.Button.onClick;
			object obj3 = <>c.<>9__49_0;
			if (obj3 == null)
			{
				UnityAction val5 = delegate
				{
					Close();
				};
				<>c.<>9__49_0 = val5;
				obj3 = (object)val5;
			}
			((UnityEvent)onClick).AddListener((UnityAction)obj3);
			RectTransform obj4 = CreateRect("ChestFlow_RuleEditor_Modes", (Transform)(object)val3);
			SetTopRect(obj4, 24f, 72f, 24f, 36f);
			BuildModeButtons(obj4);
			RectTransform obj5 = CreateRect("ChestFlow_RuleEditor_ModeRule", (Transform)(object)val3);
			SetTopRect(obj5, 24f, 110f, 24f, 1f);
			((Graphic)((Component)obj5).gameObject.AddComponent<Image>()).color = GoldFaint;
			_body = CreateRect("ChestFlow_RuleEditor_Body", (Transform)(object)val3);
			SetInsets(_body, 24f, 120f, 24f, 68f);
			RectTransform obj6 = CreateRect("ChestFlow_RuleEditor_FooterRule", (Transform)(object)val3);
			SetTopRect(obj6, 24f, 589f, 24f, 1f);
			((Graphic)((Component)obj6).gameObject.AddComponent<Image>()).color = GoldFaint;
			_status = CreateText((Transform)(object)val3, "ChestFlow_RuleEditor_Status", ScopeHelp(_scope), 12f, Muted, (TextAlignmentOptions)4097);
			SetTopRect((RectTransform)_status.transform, 24f, 596f, 360f, 34f);
			_status.textWrappingMode = (TextWrappingModes)1;
			ButtonVisual buttonVisual2 = CreateButton((Transform)(object)val3, "ChestFlow_RuleEditor_Cancel", "Cancel", 15f, (TextAlignmentOptions)514);
			SetTopRect(buttonVisual2.Rect, 570f, 598f, 220f, 34f);
			ButtonClickedEvent onClick2 = buttonVisual2.Button.onClick;
			object obj7 = <>c.<>9__49_1;
			if (obj7 == null)
			{
				UnityAction val6 = delegate
				{
					Close();
				};
				<>c.<>9__49_1 = val6;
				obj7 = (object)val6;
			}
			((UnityEvent)onClick2).AddListener((UnityAction)obj7);
			ButtonVisual buttonVisual3 = CreateButton((Transform)(object)val3, "ChestFlow_RuleEditor_Save", "Save rule", 15f, (TextAlignmentOptions)514);
			SetTopRect(buttonVisual3.Rect, 690f, 598f, 24f, 34f);
			SetButtonSelected(buttonVisual3, selected: true);
			ButtonClickedEvent onClick3 = buttonVisual3.Button.onClick;
			object obj8 = <>O.<0>__Save;
			if (obj8 == null)
			{
				UnityAction val7 = Save;
				<>O.<0>__Save = val7;
				obj8 = (object)val7;
			}
			((UnityEvent)onClick3).AddListener((UnityAction)obj8);
			RenderScope();
			EventSystem current = EventSystem.current;
			if ((Object)(object)current != (Object)null && ModeButtons.TryGetValue(_scope, out ButtonVisual value))
			{
				current.SetSelectedGameObject(((Component)value.Button).gameObject);
			}
		}

		private static void BuildModeButtons(RectTransform parent)
		{
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: 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_0129: Expected O, but got Unknown
			ModeButtons.Clear();
			ChestRuleScope[] array = new ChestRuleScope[4]
			{
				ChestRuleScope.Auto,
				ChestRuleScope.Group,
				ChestRuleScope.Categories,
				ChestRuleScope.Items
			};
			string[] array2 = new string[4] { "Auto", "Group", "Category", "Items" };
			float num = 208.5f;
			for (int i = 0; i < array.Length; i++)
			{
				ChestRuleScope selectedScope = array[i];
				ButtonVisual buttonVisual = CreateButton((Transform)(object)parent, "ChestFlow_RuleEditor_Mode_" + array2[i], array2[i], 12f, (TextAlignmentOptions)514);
				buttonVisual.Rect.anchorMin = new Vector2(0f, 0f);
				buttonVisual.Rect.anchorMax = new Vector2(0f, 1f);
				buttonVisual.Rect.pivot = new Vector2(0f, 0.5f);
				buttonVisual.Rect.anchoredPosition = new Vector2((float)i * (num + 6f), 0f);
				buttonVisual.Rect.sizeDelta = new Vector2(num, 0f);
				((UnityEvent)buttonVisual.Button.onClick).AddListener((UnityAction)delegate
				{
					_scope = selectedScope;
					SetStatus(ScopeHelp(_scope), error: false);
					RenderScope();
				});
				ModeButtons.Add(selectedScope, buttonVisual);
			}
			UpdateModeAppearance();
		}

		private static void RenderScope()
		{
			if (!((Object)(object)_body == (Object)null))
			{
				ClearChildren(_body);
				BrowserGroupButtons.Clear();
				UpdateModeAppearance();
				switch (_scope)
				{
				case ChestRuleScope.Group:
					BuildGroupView(_body);
					break;
				case ChestRuleScope.Categories:
					BuildCategoryView(_body);
					break;
				case ChestRuleScope.Items:
					BuildItemsView(_body);
					break;
				default:
					BuildAutoView(_body);
					break;
				}
			}
		}

		private static void BuildAutoView(RectTransform body)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Expected O, but got Unknown
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Expected O, but got Unknown
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			TMP_Text obj = CreateText((Transform)(object)body, "ChestFlow_RuleEditor_AutoHeading", "Automatic by chest contents", 18f, Gold, (TextAlignmentOptions)257);
			obj.fontStyle = (FontStyles)1;
			SetTopRect((RectTransform)obj.transform, 18f, 12f, 18f, 38f);
			TMP_Text obj2 = CreateText((Transform)(object)body, "ChestFlow_RuleEditor_AutoText", "ChestFlow reads the items already stored in this chest as seeds. Exact item matches always qualify. With category matching enabled, one item also seeds its detailed category.\n\nChoose GROUP for every item under a main heading, CATEGORY for one or more detailed categories, or ITEMS for exact combinations such as Corewood + Finewood.", 15f, Cream, (TextAlignmentOptions)257);
			SetTopRect((RectTransform)obj2.transform, 18f, 62f, 18f, 138f);
			obj2.textWrappingMode = (TextWrappingModes)1;
			CreateExampleCard(body, new Vector2(18f, -226f), "Seed", "Wood in chest", "Accepts the Wood category");
			CreateExampleCard(body, new Vector2(292f, -226f), "Exact", "Obsidian in chest", "Always accepts Obsidian");
			CreateExampleCard(body, new Vector2(566f, -226f), "Empty", "No stored items", "No automatic destination");
		}

		private static void CreateExampleCard(RectTransform parent, Vector2 position, string tag, string title, string detail)
		{
			//IL_0024: 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_003b: 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_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Expected O, but got Unknown
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_010d: Expected O, but got Unknown
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			//IL_012e: Unknown result type (might be due to invalid IL or missing references)
			//IL_014c: Expected O, but got Unknown
			RectTransform obj = CreateRect("ChestFlow_RuleEditor_Example_" + tag, (Transform)(object)parent);
			Vector2 val = default(Vector2);
			((Vector2)(ref val))..ctor(0f, 1f);
			obj.anchorMax = val;
			obj.anchorMin = val;
			obj.pivot = new Vector2(0f, 1f);
			obj.anchoredPosition = position;
			obj.sizeDelta = new Vector2(256f, 112f);
			Image obj2 = ((Component)obj).gameObject.AddComponent<Image>();
			ApplyButtonSprite(obj2);
			((Graphic)obj2).color = _buttonImageColor;
			((Graphic)obj2).raycastTarget = false;
			TMP_Text obj3 = CreateText((Transform)(object)obj, "ChestFlow_RuleEditor_Tag", tag, 11f, Gold, (TextAlignmentOptions)257);
			obj3.fontStyle = (FontStyles)1;
			SetTopRect((RectTransform)obj3.transform, 12f, 8f, 12f, 22f);
			TMP_Text obj4 = CreateText((Transform)(object)obj, "ChestFlow_RuleEditor_CardTitle", title, 14f, Cream, (TextAlignmentOptions)257);
			obj4.fontStyle = (FontStyles)1;
			SetTopRect((RectTransform)obj4.transform, 12f, 32f, 12f, 26f);
			TMP_Text obj5 = CreateText((Transform)(object)obj, "ChestFlow_RuleEditor_CardDetail", detail, 12f, Muted, (TextAlignmentOptions)257);
			SetTopRect((RectTransform)obj5.transform, 12f, 62f, 12f, 36f);
			obj5.textWrappingMode = (TextWrappingModes)1;
		}

		private static void BuildGroupView(RectTransform body)
		{
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_011b: Expected O, but got Unknown
			CreateSectionIntro(body, "Main category", "Choose one broad destination. Every subcategory beneath it will be accepted.");
			float num = 66f;
			float num2 = 419f;
			Vector2 val = default(Vector2);
			for (int i = 0; i < ItemCategoryCatalog.Groups.Count; i++)
			{
				ItemCategoryGroupDefinition itemCategoryGroupDefinition = ItemCategoryCatalog.Groups[i];
				int num3 = i % 2;
				int num4 = i / 2;
				ButtonVisual buttonVisual = CreateButton((Transform)(object)body, "ChestFlow_RuleEditor_Group_" + itemCategoryGroupDefinition.Id, itemCategoryGroupDefinition.DisplayName, 14f, (TextAlignmentOptions)4097);
				RectTransform rect = buttonVisual.Rect;
				RectTransform rect2 = buttonVisual.Rect;
				((Vector2)(ref val))..ctor(0f, 1f);
				rect2.anchorMax = val;
				rect.anchorMin = val;
				buttonVisual.Rect.pivot = new Vector2(0f, 1f);
				buttonVisual.Rect.anchoredPosition = new Vector2((float)num3 * (num2 + 14f), 0f - (num + (float)num4 * 58f));
				buttonVisual.Rect.sizeDelta = new Vector2(num2, 48f);
				string groupId = itemCategoryGroupDefinition.Id;
				((UnityEvent)buttonVisual.Button.onClick).AddListener((UnityAction)delegate
				{
					_selectedGroupId = groupId;
					UpdateGroupSelection();
				});
				BrowserGroupButtons[itemCategoryGroupDefinition.Id] = buttonVisual;
			}
			UpdateGroupSelection();
		}

		private static void BuildCategoryView(RectTransform body)
		{
			//IL_0128: 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_0168: Unknown result type (might be due to invalid IL or missing references)
			//IL_0185: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_020a: Expected O, but got Unknown
			//IL_0255: Unknown result type (might be due to invalid IL or missing references)
			//IL_025f: Expected O, but got Unknown
			CreateSectionIntro(body, "Detailed categories", "Select one or more categories. Main headings remain filters, not a third tier.");
			RectTransform obj = CreateRect("ChestFlow_RuleEditor_CategoryRail", (Transform)(object)body);
			SetInsets(obj, 0f, 62f, 662f, 0f);
			RectTransform val = CreateRect("ChestFlow_RuleEditor_CategoryContent", (Transform)(object)body);
			SetInsets(val, 200f, 62f, 0f, 0f);
			BuildBrowserRail(obj, _activeCategoryGroupId, includeAll: false, delegate(string groupId)
			{
				_activeCategoryGroupId = groupId;
				RenderScope();
			});
			ScrollRect scroll;
			RectTransform val2 = CreateScrollContent(val, "ChestFlow_RuleEditor_CategoryScroll", out scroll);
			List<ItemCategoryDefinition> list = ItemCategoryCatalog.All.Where((ItemCategoryDefinition definition) => string.Equals(definition.GroupId, _activeCategoryGroupId, StringComparison.OrdinalIgnoreCase)).ToList();
			float num = 0f;
			foreach (ItemCategoryDefinition item in list)
			{
				ButtonVisual visual = CreateButton((Transform)(object)val2, "ChestFlow_RuleEditor_Category_" + item.Id, item.DisplayName, 13f, (TextAlignmentOptions)4097);
				visual.Rect.anchorMin = new Vector2(0f, 1f);
				visual.Rect.anchorMax = new Vector2(1f, 1f);
				visual.Rect.pivot = new Vector2(0.5f, 1f);
				visual.Rect.anchoredPosition = new Vector2(0f, 0f - num);
				visual.Rect.sizeDelta = new Vector2(-4f, 42f);
				TMP_Text check = CreateText((Transform)(object)visual.Rect, "ChestFlow_RuleEditor_Check", "✓", 16f, Gold, (TextAlignmentOptions)514);
				SetRightFill((RectTransform)check.transform, 34f, 8f, 4f, 8f);
				SetCategoryVisual(visual, check, SelectedCategories.Contains(item.Category));
				ItemCategory category = item.Category;
				((UnityEvent)visual.Button.onClick).AddListener((UnityAction)delegate
				{
					if (!SelectedCategories.Add(category))
					{
						SelectedCategories.Remove(category);
					}
					SetCategoryVisual(visual, check, SelectedCategories.Contains(category));
					RefreshBrowserRailCounts(items: false);
				});
				num += 48f;
			}
			SetContentHeight(val2, num);
			RefreshBrowserRailCounts(items: false);
		}

		private static void BuildItemsView(RectTransform body)
		{
			SetTopRect(CreateSearchField(body), 0f, 6f, 0f, 36f);
			RectTransform obj = CreateRect("ChestFlow_RuleEditor_ItemRail", (Transform)(object)body);
			SetInsets(obj, 0f, 52f, 662f, 0f);
			RectTransform val = CreateRect("ChestFlow_RuleEditor_ItemContent", (Transform)(object)body);
			SetInsets(val, 200f, 52f, 0f, 0f);
			BuildBrowserRail(obj, _activeItemGroupId, includeAll: true, delegate(string groupId)
			{
				_activeItemGroupId = groupId;
				RenderScope();
			});
			_itemContent = CreateScrollContent(val, "ChestFlow_RuleEditor_ItemScroll", out ScrollRect _);
			RenderItemTiles(_itemContent);
			RefreshBrowserRailCounts(items: true);
		}

		private static void BuildBrowserRail(RectTransform rail, string activeGroupId, bool includeAll, Action<string> onSelected)
		{
			float num = 0f;
			if (includeAll)
			{
				AddRailButton(rail, "all", "All items", activeGroupId, num, onSelected);
				num += 34f;
			}
			foreach (ItemCategoryGroupDefinition group in ItemCategoryCatalog.Groups)
			{
				AddRailButton(rail, group.Id, group.DisplayName, activeGroupId, num, onSelected);
				num += 34f;
			}
		}

		private static void AddRailButton(RectTransform rail, string groupId, string label, string activeGroupId, float y, Action<string> onSelected)
		{
			//IL_0047: 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)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: Expected O, but got Unknown
			ButtonVisual buttonVisual = CreateButton((Transform)(object)rail, "ChestFlow_RuleEditor_Rail_" + groupId, label, 10.5f, (TextAlignmentOptions)4097);
			buttonVisual.Rect.anchorMin = new Vector2(0f, 1f);
			buttonVisual.Rect.anchorMax = new Vector2(1f, 1f);
			buttonVisual.Rect.pivot = new Vector2(0.5f, 1f);
			buttonVisual.Rect.anchoredPosition = new Vector2(0f, 0f - y);
			buttonVisual.Rect.sizeDelta = new Vector2(0f, 30f);
			SetButtonSelected(buttonVisual, string.Equals(groupId, activeGroupId, StringComparison.OrdinalIgnoreCase));
			((UnityEvent)buttonVisual.Button.onClick).AddListener((UnityAction)delegate
			{
				onSelected(groupId);
			});
			BrowserGroupButtons[groupId] = buttonVisual;
		}

		private static RectTransform CreateSearchField(RectTransform parent)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: 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_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Expected O, but got Unknown
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Expected O, but got Unknown
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Expected O, but got Unknown
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0106: Expected O, but got Unknown
			//IL_015f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0192: Unknown result type (might be due to invalid IL or missing references)
			//IL_0225: Unknown result type (might be due to invalid IL or missing references)
			//IL_022f: Expected O, but got Unknown
			RectTransform val = CreateRect("ChestFlow_RuleEditor_Search", (Transform)(object)parent);
			Image val2 = ((Component)val).gameObject.AddComponent<Image>();
			ApplyButtonSprite(val2);
			((Graphic)val2).color = _buttonImageColor;
			TMP_InputField input = ((Component)val).gameObject.AddComponent<TMP_InputField>();
			RectTransform val3 = CreateRect("ChestFlow_RuleEditor_SearchViewport", (Transform)(object)val);
			Stretch(val3, new Vector2(8f, 2f), new Vector2(-30f, -2f));
			((Component)val3).gameObject.AddComponent<RectMask2D>();
			TextMeshProUGUI val4 = (TextMeshProUGUI)CreateText((Transform)(object)val3, "ChestFlow_RuleEditor_SearchText", string.Empty, 12f, Cream, (TextAlignmentOptions)4097);
			Stretch((RectTransform)((TMP_Text)val4).transform, Vector2.zero, Vector2.zero);
			((TMP_Text)val4).fontStyle = (FontStyles)0;
			TextMeshProUGUI val5 = (TextMeshProUGUI)CreateText((Transform)(object)val3, "ChestFlow_RuleEditor_SearchPlaceholder", "Search known items", 12f, Muted, (TextAlignmentOptions)4097);
			Stretch((RectTransform)((TMP_Text)val5).transform, Vector2.zero, Vector2.zero);
			((TMP_Text)val5).fontStyle = (FontStyles)0;
			((Selectable)input).targetGraphic = (Graphic)(object)val2;
			input.textViewport = val3;
			input.textComponent = (TMP_Text)(object)val4;
			input.placeholder = (Graphic)(object)val5;
			input.lineType = (LineType)0;
			input.characterLimit = 64;
			input.caretColor = Gold;
			input.selectionColor = new Color(SelectedGold.r, SelectedGold.g, SelectedGold.b, 0.55f);
			input.SetTextWithoutNotify(_itemSearch);
			((UnityEvent<string>)(object)input.onValueChanged).AddListener((UnityAction<string>)delegate(string value)
			{
				_itemSearch = value ?? string.Empty;
				RefreshItemTiles();
			});
			ButtonVisual buttonVisual = CreateButton((Transform)(object)val, "ChestFlow_RuleEditor_SearchClear", "×", 15f, (TextAlignmentOptions)514);
			SetRightFill(buttonVisual.Rect, 26f, 2f, 2f, 2f);
			((UnityEvent)buttonVisual.Button.onClick).AddListener((UnityAction)delegate
			{
				_itemSearch = string.Empty;
				input.SetTextWithoutNotify(string.Empty);
				RefreshItemTiles();
			});
			return val;
		}

		private static void RefreshItemTiles()
		{
			if (!((Object)(object)_itemContent == (Object)null))
			{
				ClearChildren(_itemContent);
				RenderItemTiles(_itemContent);
				RefreshBrowserRailCounts(items: true);
			}
		}

		private static void RenderItemTiles(RectTransform content)
		{
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_0154: Unknown result type (might be due to invalid IL or missing references)
			//IL_015b: 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_01a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_020b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0212: Unknown result type (might be due to invalid IL or missing references)
			//IL_0224: Unknown result type (might be due to invalid IL or missing references)
			//IL_0239: Unknown result type (might be due to invalid IL or missing references)
			//IL_024e: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0301: Expected O, but got Unknown
			//IL_0335: Unknown result type (might be due to invalid IL or missing references)
			//IL_0349: Unknown result type (might be due to invalid IL or missing references)
			//IL_0367: Expected O, but got Unknown
			//IL_0384: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c2: Expected O, but got Unknown
			//IL_040d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0417: Expected O, but got Unknown
			//IL_02a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_04a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_04b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_04d2: Expected O, but got Unknown
			IEnumerable<ItemChoice> source = ItemChoices;
			if (!string.Equals(_activeItemGroupId, "all", StringComparison.OrdinalIgnoreCase))
			{
				source = source.Where((ItemChoice choice) => string.Equals(ItemCategoryCatalog.Get(choice.Category).GroupId, _activeItemGroupId, StringComparison.OrdinalIgnoreCase));
			}
			string query = (_itemSearch ?? string.Empty).Trim();
			if (query.Length > 0)
			{
				source = source.Where((ItemChoice choice) => choice.SearchText.IndexOf(query, StringComparison.OrdinalIgnoreCase) >= 0);
			}
			List<ItemChoice> list = source.ToList();
			float num = 620f;
			Transform parent = ((Transform)content).parent;
			RectTransform val = (RectTransform)(object)((parent is RectTransform) ? parent : null);
			if (val != null)
			{
				Rect rect = val.rect;
				if (((Rect)(ref rect)).width > 10f)
				{
					rect = val.rect;
					num = ((Rect)(ref rect)).width;
				}
			}
			float num2 = (num - 14f - 4f) / 3f;
			Vector2 val2 = default(Vector2);
			for (int num3 = 0; num3 < list.Count; num3++)
			{
				ItemChoice itemChoice = list[num3];
				int num4 = num3 % 3;
				int num5 = num3 / 3;
				ButtonVisual visual = CreateButton((Transform)(object)content, "ChestFlow_RuleEditor_Item_" + num3, string.Empty, 11f, (TextAlignmentOptions)514);
				RectTransform rect2 = visual.Rect;
				RectTransform rect3 = visual.Rect;
				((Vector2)(ref val2))..ctor(0f, 1f);
				rect3.anchorMax = val2;
				rect2.anchorMin = val2;
				visual.Rect.pivot = new Vector2(0f, 1f);
				visual.Rect.anchoredPosition = new Vector2((float)num4 * (num2 + 7f), (float)(-num5) * 65f);
				visual.Rect.sizeDelta = new Vector2(num2, 58f);
				((Component)visual.Label).gameObject.SetActive(false);
				RectTransform obj = CreateRect("ChestFlow_RuleEditor_Icon", (Transform)(object)visual.Rect);
				((Vector2)(ref val2))..ctor(0f, 0.5f);
				obj.anchorMax = val2;
				obj.anchorMin = val2;
				obj.pivot = new Vector2(0f, 0.5f);
				obj.anchoredPosition = new Vector2(8f, 0f);
				obj.sizeDelta = new Vector2(40f, 40f);
				Image val3 = ((Component)obj).gameObject.AddComponent<Image>();
				val3.sprite = itemChoice.Icon;
				val3.preserveAspect = true;
				((Graphic)val3).raycastTarget = false;
				if ((Object)(object)itemChoice.Icon == (Object)null)
				{
					((Graphic)val3).color = new Color(1f, 1f, 1f, 0.2f);
				}
				TMP_Text obj2 = CreateText((Transform)(object)visual.Rect, "ChestFlow_RuleEditor_ItemName", itemChoice.DisplayName, 11.5f, Cream, (TextAlignmentOptions)257);
				SetTopRect((RectTransform)obj2.transform, 54f, 7f, 24f, 24f);
				obj2.textWrappingMode = (TextWrappingModes)1;
				obj2.overflowMode = (TextOverflowModes)1;
				SetTopRect((RectTransform)CreateText((Transform)(object)visual.Rect, "ChestFlow_RuleEditor_ItemCategory", ItemCategoryCatalog.Get(itemChoice.Category).DisplayName, 8.5f, Gold, (TextAlignmentOptions)1025).transform, 54f, 32f, 24f, 18f);
				TMP_Text check = CreateText((Transform)(object)visual.Rect, "ChestFlow_RuleEditor_ItemCheck", "✓", 14f, Gold, (TextAlignmentOptions)514);
				SetRightFill((RectTransform)check.transform, 22f, 2f, 2f, 36f);
				SetCategoryVisual(visual, check, SelectedItems.Contains(itemChoice.PrefabName));
				string prefabName = itemChoice.PrefabName;
				((UnityEvent)visual.Button.onClick).AddListener((UnityAction)delegate
				{
					if (!SelectedItems.Add(prefabName))
					{
						SelectedItems.Remove(prefabName);
					}
					SetCategoryVisual(visual, check, SelectedItems.Contains(prefabName));
					RefreshBrowserRailCounts(items: true);
				});
				if ((Object)(object)_gui != (Object)null)
				{
					VanillaTooltip.Attach(((Component)visual.Button).gameObject, (Component)(object)_gui, itemChoice.DisplayName, itemChoice.PrefabName);
				}
			}
			int num6 = (list.Count + 3 - 1) / 3;
			SetContentHeight(content, Mathf.Max(20f, (float)num6 * 65f));
			if (list.Count == 0)
			{
				SetTopRect((RectTransform)CreateText((Transform)(object)content, "ChestFlow_RuleEditor_NoItems", "No known items match this filter", 12f, Muted, (TextAlignmentOptions)257).transform, 8f, 8f, 8f, 26f);
			}
		}

		private static void RefreshBrowserRailCounts(bool items)
		{
			foreach (KeyValuePair<string, ButtonVisual> browserGroupButton in BrowserGroupButtons)
			{
				string id = browserGroupButton.Key;
				if (string.Equals(id, "all", StringComparison.OrdinalIgnoreCase))
				{
					browserGroupButton.Value.Label.text = "All items" + CountSuffix(SelectedItems.Count);
				}
				else
				{
					if (!ItemCategoryCatalog.TryGetGroup(id, out ItemCategoryGroupDefinition definition) || definition == null)
					{
						continue;
					}
					int count = (items ? SelectedItems.Count((string name) => ItemChoices.Any((ItemChoice choice) => string.Equals(choice.PrefabName, name, StringComparison.OrdinalIgnoreCase) && string.Equals(ItemCategoryCatalog.Get(choice.Category).GroupId, id, StringComparison.OrdinalIgnoreCase))) : SelectedCategories.Count((ItemCategory category) => string.Equals(ItemCategoryCatalog.Get(category).GroupId, id, StringComparison.OrdinalIgnoreCase)));
					browserGroupButton.Value.Label.text = definition.DisplayName + CountSuffix(count);
				}
			}
		}

		private static string CountSuffix(int count)
		{
			if (count <= 0)
			{
				return string.Empty;
			}
			return "  [" + count + "]";
		}

		private static void CollectItemChoices(Container container)
		{
			ItemChoices.Clear();
			Dictionary<string, ItemChoice> dictionary = new Dictionary<string, ItemChoice>(StringComparer.OrdinalIgnoreCase);
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)ObjectDB.instance != (Object)null)
			{
				foreach (GameObject item in ObjectDB.instance.m_items)
				{
					if (!((Object)(object)item == (Object)null))
					{
						ItemDrop component = item.GetComponent<ItemDrop>();
						if (!((Object)(object)component == (Object)null) && component.m_itemData?.m_shared != null && (Object)(object)localPlayer != (Object)null && localPlayer.IsKnownMaterial(component.m_itemData.m_shared.m_name))
						{
							AddItemChoice(dictionary, ((Object)item).name, component.m_itemData, component.m_itemData.GetIcon());
						}
					}
				}
			}
			if ((Object)(object)localPlayer != (Object)null)
			{
				foreach (ItemData allItem in ((Humanoid)localPlayer).GetInventory().GetAllItems())
				{
					AddItemChoice(dictionary, ValheimItemCategoryClassifier.PrefabName(allItem), allItem, allItem.GetIcon());
				}
			}
			foreach (ItemData allItem2 in container.GetInventory().GetAllItems())
			{
				AddItemChoice(dictionary, ValheimItemCategoryClassifier.PrefabName(allItem2), allItem2, allItem2.GetIcon());
			}
			foreach (string selectedItem in SelectedItems)
			{
				if (!dictionary.ContainsKey(selectedItem))
				{
					dictionary[selectedItem] = new ItemChoice(selectedItem, selectedItem, ItemCategory.Miscellaneous, null);
				}
			}
			ItemChoices.AddRange(dictionary.Values.OrderBy((ItemChoice choice) => ItemCategoryCatalog.SortRank(choice.Category)).ThenBy<ItemChoice, string>((ItemChoice choice) => choice.DisplayName, StringComparer.CurrentCultureIgnoreCase).ThenBy<ItemChoice, string>((ItemChoice choice) => choice.PrefabName, StringComparer.OrdinalIgnoreCase));
		}

		private static void AddItemChoice(IDictionary<string, ItemChoice> choices, string prefabName, ItemData item, Sprite? icon)
		{
			string text = ChestStorageRule.NormalizePrefabName(prefabName);
			if (text.Length != 0 && !choices.ContainsKey(text) && !item.m_shared.m_questItem && item.m_shared.m_autoStack)
			{
				string text2 = ((Localization.instance != null) ? Localization.instance.Localize(item.m_shared.m_name) : item.m_shared.m_name);
				choices[text] = new ItemChoice(text, string.IsNullOrWhiteSpace(text2) ? text : text2, ValheimItemCategoryClassifier.Classify(item), icon);
			}
		}

		private static void Save()
		{
			if (!Plugin.IsActive || (Object)(object)_container == (Object)null)
			{
				return;
			}
			Container container = _container;
			if (MultiUserContainerService.TryDeferUntilOwned(container, delegate
			{
				if ((Object)(object)_container == (Object)(object)container)
				{
					Save();
				}
			}))
			{
				return;
			}
			try
			{
				ChestStorageRule rule = _scope switch
				{
					ChestRuleScope.Group => ChestStorageRule.ForGroup(_selectedGroupId), 
					ChestRuleScope.Categories => ChestStorageRule.ForCategories(SelectedCategories), 
					ChestRuleScope.Items => ChestStorageRule.ForItems(SelectedItems), 
					_ => ChestStorageRule.Automatic(), 
				};
				if (!ChestRuleStore.TryWrite(_container, rule, out string error))
				{
					SetStatus(error, error: true);
					return;
				}
				Player localPlayer = Player.m_localPlayer;
				if (localPlayer != null)
				{
					((Character)localPlayer).Message((MessageType)2, "Chest storage rule: " + ChestRuleStore.ShortSummary(rule), 0, (Sprite)null, false);
				}
				InventoryButtons.RefreshRuleLabel();
				Close();
			}
			catch (ArgumentException ex)
			{
				SetStatus(ex.Message, error: true);
			}
		}

		private static void CreateSectionIntro(RectTransform parent, string heading, string description)
		{
			//IL_000c: 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_0045: Expected O, but got Unknown
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Expected O, but got Unknown
			TMP_Text obj = CreateText((Transform)(object)parent, "ChestFlow_RuleEditor_SectionTitle", heading, 14f, Gold, (TextAlignmentOptions)257);
			obj.fontStyle = (FontStyles)1;
			SetTopRect((RectTransform)obj.transform, 0f, 0f, 0f, 24f);
			TMP_Text obj2 = CreateText((Transform)(object)parent, "ChestFlow_RuleEditor_SectionDetail", description, 12f, Muted, (TextAlignmentOptions)257);
			SetTopRect((RectTransform)obj2.transform, 0f, 26f, 0f, 29f);
			obj2.textWrappingMode = (TextWrappingModes)1;
		}

		private static RectTransform CreateScrollContent(RectTransform host, string name, out ScrollRect scroll)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			RectTransform val = CreateRect(name + "Viewport", (Transform)(object)host);
			Stretch(val, Vector2.zero, Vector2.zero);
			((Component)val).gameObject.AddComponent<RectMask2D>();
			RectTransform val2 = CreateRect(name + "Content", (Transform)(object)val);
			val2.anchorMin = new Vector2(0f, 1f);
			val2.anchorMax = new Vector2(1f, 1f);
			val2.pivot = new Vector2(0.5f, 1f);
			val2.anchoredPosition = Vector2.zero;
			val2.sizeDelta = Vector2.zero;
			scroll = ((Component)host).gameObject.AddComponent<ScrollRect>();
			scroll.viewport = val;
			scroll.content = val2;
			scroll.horizontal = false;
			scroll.vertical = true;
			scroll.movementType = (MovementType)2;
			scroll.scrollSensitivity = ModConfig.RuleEditorScrollSensitivity.Value;
			return val2;
		}

		private static void SetContentHeight(RectTransform content, float height)
		{
			content.SetSizeWithCurrentAnchors((Axis)1, Mathf.Max(1f, height));
		}

		private static void UpdateModeAppearance()
		{
			foreach (KeyValuePair<ChestRuleScope, ButtonVisual> modeButton in ModeButtons)
			{
				bool selected = modeButton.Key == _scope;
				SetButtonSelected(modeButton.Value, selected);
			}
		}

		private static void UpdateGroupSelection()
		{
			foreach (KeyValuePair<string, ButtonVisual> browserGroupButton in BrowserGroupButtons)
			{
				bool selected = string.Equals(browserGroupButton.Key, _selectedGroupId, StringComparison.OrdinalIgnoreCase);
				SetButtonSelected(browserGroupButton.Value, selected);
			}
		}

		private static void SetCategoryVisual(ButtonVisual visual, TMP_Text check, bool selected)
		{
			SetButtonSelected(visual, selected);
			((Component)check).gameObject.SetActive(selected);
		}

		private static void SetButtonSelected(ButtonVisual visual, bool selected)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			((Graphic)visual.Image).color = (selected ? SelectedGold : visual.NormalImageColor);
			((Graphic)visual.Label).color = (selected ? Color.white : visual.NormalLabelColor);
		}

		private static void SetStatus(string message, bool error)
		{
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)_status == (Object)null))
			{
				_status.text = message;
				((Graphic)_status).color = (Color)(error ? new Color(1f, 0.55f, 0.42f, 1f) : Muted);
			}
		}

		private static string ScopeHelp(ChestRuleScope scope)
		{
			return scope switch
			{
				ChestRuleScope.Group => "One main category; all of its detailed categories are accepted.", 
				ChestRuleScope.Categories => "One or more detailed categories; selected categories can span main headings.", 
				ChestRuleScope.Items => "One or more exact items; ideal for Wood alone or Corewood + Finewood.", 
				_ => "Automatic routing uses the items already stored in the chest as seeds.", 
			};
		}

		private static string? FirstCategoryGroup(ChestStorageRule rule)
		{
			using (IEnumerator<ItemCategory> enumerator = rule.Categories.GetEnumerator())
			{
				if (enumerator.MoveNext())
				{
					return ItemCategoryCatalog.Get(enumerator.Current).GroupId;
				}
			}
			return null;
		}

		private static void CaptureVanillaStyle(InventoryGui gui, Container container)
		{
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: 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_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_0206: Unknown result type (might be due to invalid IL or missing references)
			//IL_020b: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_0229: Unknown result type (might be due to invalid IL or missing references)
			//IL_021d: Unknown result type (might be due to invalid IL or missing references)
			//IL_020b: Unknown result type (might be due to invalid IL or missing references)
			//IL_022e: Unknown result type (might be due to invalid IL or missing references)
			_buttonTemplate = (((Object)(object)gui.m_stackAllButton != (Object)null) ? gui.m_stackAllButton : gui.m_takeAllButton);
			Image val = (((Object)(object)_buttonTemplate != (Object)null) ? ((Component)_buttonTemplate).GetComponent<Image>() : null);
			if ((Object)(object)val == (Object)null && (Object)(object)gui.m_tabCraft != (Object)null)
			{
				val = ((Component)gui.m_tabCraft).GetComponent<Image>();
			}
			_buttonSprite = (((Object)(object)val != (Object)null) ? val.sprite : null);
			_buttonImageType = (Type)(((Object)(object)val != (Object)null) ? ((int)val.type) : 0);
			_buttonImageColor = (((Object)(object)val != (Object)null) ? ((Graphic)val).color : Color.white);
			TMP_Text val2 = (((Object)(object)_buttonTemplate != (Object)null) ? ((Component)_buttonTemplate).GetComponentInChildren<TMP_Text>(true) : null);
			_buttonLabelColor = (((Object)(object)val2 != (Object)null) ? ((Graphic)val2).color : Gold);
			TMP_Text val3 = gui.m_recipeDecription;
			if ((Object)(object)val3 == (Object)null || (Object)(object)val3.font == (Object)null)
			{
				val3 = val2;
			}
			if ((Object)(object)val3 == (Object)null || (Object)(object)val3.font == (Object)null)
			{
				val3 = gui.m_containerName;
			}
			if ((Object)(object)val3 == (Object)null || (Object)(object)val3.font == (Object)null)
			{
				val3 = gui.m_recipeName;
			}
			_bodyFont = (((Object)(object)val3 != (Object)null) ? val3.font : null);
			_bodyFontMaterial = (((Object)(object)val3 != (Object)null) ? val3.fontSharedMaterial : null);
			_titleTemplate = (((Object)(object)gui.m_containerName != (Object)null) ? gui.m_containerName : gui.m_recipeName);
			_sourcePanelImage = FindContainerBackground(gui, container);
			_panelSprite = (((Object)(object)container.m_bkg != (Object)null) ? container.m_bkg : (((Object)(object)_sourcePanelImage != (Object)null) ? _sourcePanelImage.sprite : null));
			_panelImageType = (Type)((!((Object)(object)_sourcePanelImage != (Object)null)) ? (((Object)(object)_panelSprite != (Object)null && _panelSprite.border != Vector4.zero) ? 1 : 0) : ((int)_sourcePanelImage.type));
			_panelImageColor = (((Object)(object)_sourcePanelImage != (Object)null) ? ((Graphic)_sourcePanelImage).color : Color.white);
			_panelMaterial = (((Object)(object)_sourcePanelImage != (Object)null) ? ((Graphic)_sourcePanelImage).material : null);
			_panelFillCenter = (Object)(object)_sourcePanelImage == (Object)null || _sourcePanelImage.fillCenter;
			_panelPreserveAspect = (Object)(object)_sourcePanelImage != (Object)null && _sourcePanelImage.preserveAspect;
			_panelPixelsPerUnitMultiplier = (((Object)(object)_sourcePanelImage != (Object)null) ? _sourcePanelImage.pixelsPerUnitMultiplier : 1f);
			_panelUseSpriteMesh = (Object)(object)_sourcePanelImage != (Object)null && _sourcePanelImage.useSpriteMesh;
		}

		private static ButtonVisual CreateButton(Transform parent, string name, string label, float fontSize, TextAlignmentOptions alignment = (TextAlignmentOptions)514)
		{
			//IL_0137: Unknown result type (might be due to invalid IL or missing references)
			//IL_0155: Unknown result type (might be due to invalid IL or missing references)
			//IL_015a: Unknown result type (might be due to invalid IL or missing references)
			//IL_015d: Unknown result type (might be due to invalid IL or missing references)
			//IL_017d: Unknown result type (might be due to invalid IL or missing references)
			//IL_019d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ab: 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_01e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0209: Unknown result type (might be due to invalid IL or missing references)
			//IL_0218: Unknown result type (might be due to invalid IL or missing references)
			//IL_0227: Unknown result type (might be due to invalid IL or missing references)
			//IL_0231: Expected O, but got Unknown
			//IL_0235: Unknown result type (might be due to invalid IL or missing references)
			//IL_023b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: 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_011c: Expected O, but got Unknown
			//IL_00c0: 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)
			if ((Object)(object)_buttonTemplate != (Object)null)
			{
				GameObject val = Object.Instantiate<GameObject>(((Component)_buttonTemplate).gameObject, parent, false);
				((Object)val).name = name;
				Localize[] componentsInChildren = val.GetComponentsInChildren<Localize>(true);
				for (int i = 0; i < componentsInChildren.Length; i++)
				{
					((Behaviour)componentsInChildren[i]).enabled = false;
				}
				Button val2 = val.GetComponent<Button>() ?? val.AddComponent<Button>();
				((UnityEventBase)val2.onClick).RemoveAllListeners();
				Image val3 = (Image)(object)(((Selectable)val2).targetGraphic = (Graphic)(((object)/*isinst with value type is only supported in some contexts*/) ?? ((object)(val.GetComponent<Image>() ?? val.AddComponent<Image>()))));
				TMP_Text val5 = val.GetComponentInChildren<TMP_Text>(true) ?? CreateText(val.transform, name + "Label", label, fontSize, _buttonLabelColor, alignment);
				val5.text = label;
				val5.fontSize = fontSize;
				val5.alignment = alignment;
				((Graphic)val5).raycastTarget = false;
				val.SetActive(true);
				return new ButtonVisual((RectTransform)val.transform, val3, val2, val5, ((Graphic)val3).color, ((Graphic)val5).color);
			}
			RectTransform obj = CreateRect(name, parent);
			Image val6 = ((Component)obj).gameObject.AddComponent<Image>();
			ApplyButtonSprite(val6);
			((Graphic)val6).color = _buttonImageColor;
			Button val7 = ((Component)obj).gameObject.AddComponent<Button>();
			((Selectable)val7).targetGraphic = (Graphic)(object)val6;
			ColorBlock colors = ((Selectable)val7).colors;
			((ColorBlock)(ref colors)).normalColor = Color.white;
			((ColorBlock)(ref colors)).highlightedColor = new Color(1.16f, 1.16f, 1.16f, 1f);
			((ColorBlock)(ref colors)).pressedColor = new Color(0.82f, 0.82f, 0.82f, 1f);
			((ColorBlock)(ref colors)).selectedColor = ((ColorBlock)(ref colors)).highlightedColor;
			((ColorBlock)(ref colors)).disabledColor = new Color(0.42f, 0.42f, 0.42f, 0.7f);
			((ColorBlock)(ref colors)).colorMultiplier = 1f;
			((Selectable)val7).colors = colors;
			TMP_Text val8 = CreateText((Transform)(object)obj, name + "Label", label, fontSize, _buttonLabelColor, alignment);
			Stretch((RectTransform)val8.transform, new Vector2(10f, 2f), new Vector2(-10f, -2f));
			return new ButtonVisual(obj, val6, val7, val8, ((Graphic)val6).color, ((Graphic)val8).color);
		}

		private static void ApplyButtonSprite(Image image)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			image.sprite = _buttonSprite;
			image.type = _buttonImageType;
		}

		private static void ApplyPanelStyle(Image image)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			image.sprite = _panelSprite;
			image.type = _panelImageType;
			((Graphic)image).color = _panelImageColor;
			((Graphic)image).material = _panelMaterial;
			image.fillCenter = _panelFillCenter;
			image.preserveAspect = _panelPreserveAspect;
			image.pixelsPerUnitMultiplier = _panelPixelsPerUnitMultiplier;
			image.useSpriteMesh = _panelUseSpriteMesh;
			((Graphic)image).raycastTarget = true;
		}

		private static Image? FindContainerBackground(InventoryGui gui, Container container)
		{
			Sprite bkg = container.m_bkg;
			IEnumerable<Image> enumerable = (((Object)(object)gui.m_container != (Object)null) ? ((IEnumerable<Image>)((Component)gui.m_container).GetComponentsInChildren<Image>(true)) : ((IEnumerable<Image>)Array.Empty<Image>()));
			Image val = FindLargestSpriteMatch(enumerable, bkg);
			if ((Object)(object)val != (Object)null)
			{
				return val;
			}
			val = FindLargestSpriteMatch(((Component)gui).GetComponentsInChildren<Image>(true), bkg);
			if ((Object)(object)val != (Object)null)
			{
				return val;
			}
			return enumerable.Where((Image candidate) => (Object)(object)candidate.sprite != (Object)null && (((Object)((Component)candidate).gameObject).name.IndexOf("bkg", StringComparison.OrdinalIgnoreCase) >= 0 || ((Object)((Component)candidate).gameObject).name.IndexOf("background", StringComparison.OrdinalIgnoreCase) >= 0)).OrderByDescending(ImageArea).FirstOrDefault();
		}

		private static Image? FindLargestSpriteMatch(IEnumerable<Image> images, Sprite? expected)
		{
			if ((Object)(object)expected == (Object)null)
			{
				return null;
			}
			return images.Where((Image candidate) => (Object)(object)candidate != (Object)null && (Object)(object)candidate.sprite == (Object)(object)expected).OrderByDescending(ImageArea).FirstOrDefault();
		}

		private static float ImageArea(Image image)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			Rect rect = ((Graphic)image).rectTransform.rect;
			float width = ((Rect)(ref rect)).width;
			rect = ((Graphic)image).rectTransform.rect;
			return Mathf.Abs(width * ((Rect)(ref rect)).height);
		}

		private static void RefreshPanelBackground()
		{
			//IL_003c: 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_00d2: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)_panelImage == (Object)null))
			{
				if ((Object)(object)_sourcePanelImage != (Object)null)
				{
					_panelImage.sprite = _sourcePanelImage.sprite;
					_panelImage.type = _sourcePanelImage.type;
					((Graphic)_panelImage).color = ((Graphic)_sourcePanelImage).color;
					((Graphic)_panelImage).material = ((Graphic)_sourcePanelImage).material;
					_panelImage.fillCenter = _sourcePanelImage.fillCenter;
					_panelImage.preserveAspect = _sourcePanelImage.preserveAspect;
					_panelImage.pixelsPerUnitMultiplier = _sourcePanelImage.pixelsPerUnitMultiplier;
					_panelImage.useSpriteMesh = _sourcePanelImage.useSpriteMesh;
					((Graphic)_panelImage).canvasRenderer.SetColor(((Graphic)_sourcePanelImage).canvasRenderer.GetColor());
				}
				else if ((Object)(object)_container != (Object)null && (Object)(object)_panelImage.sprite != (Object)(object)_container.m_bkg)
				{
					_panelImage.sprite = _container.m_bkg;
				}
			}
		}

		private static TMP_Text CreateVanillaTitle(Transform parent, string name, string content, float fontSize)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_titleTemplate == (Object)null)
			{
				return CreateText(parent, name, content, fontSize, Gold, (TextAlignmentOptions)514);
			}
			GameObject val = Object.Instantiate<GameObject>(((Component)_titleTemplate).gameObject, parent, false);
			((Object)val).name = name;
			Localize[] componentsInChildren = val.GetComponentsInChildren<Localize>(true);
			for (int i = 0; i < componentsInChildren.Length; i++)
			{
				((Behaviour)componentsInChildren[i]).enabled = false;
			}
			TMP_Text obj = val.GetComponent<TMP_Text>() ?? val.GetComponentInChildren<TMP_Text>(true);
			obj.text = content;
			obj.enableAutoSizing = false;
			obj.fontSize = fontSize;
			((Graphic)obj).raycastTarget = false;
			val.SetActive(true);
			return obj;
		}

		private static TMP_Text CreateText(Transform parent, string name, string content, float fontSize, Color color, TextAlignmentOptions alignment)
		{
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: 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)
			TextMeshProUGUI val = ((Component)CreateRect(name, parent)).gameObject.AddComponent<TextMeshProUGUI>();
			((TMP_Text)val).text = content;
			((TMP_Text)val).font = _bodyFont;
			if ((Object)(object)_bodyFontMaterial != (Object)null)
			{
				((TMP_Text)val).fontSharedMaterial = _bodyFontMaterial;
			}
			((TMP_Text)val).fontSize = fontSize;
			((TMP_Text)val).fontStyle = (FontStyles)0;
			((Graphic)val).color = color;
			((TMP_Text)val).alignment = alignment;
			((TMP_Text)val).textWrappingMode = (TextWrappingModes)0;
			((TMP_Text)val).outlineWidth = 0.08f;
			((TMP_Text)val).outlineColor = Color32.op_Implicit(new Color(0f, 0f, 0f, 0.85f));
			((Graphic)val).raycastTarget = false;
			return (TMP_Text)(object)val;
		}

		private static RectTransform CreateRect(string name, Transform parent)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Expected O, but got Unknown
			GameObject val = new GameObject(name, new Type[1] { typeof(RectTransform) });
			val.transform.SetParent(parent, false);
			return (RectTransform)val.transform;
		}

		private static void SetInsets(RectTransform rect, float left, float top, float right, float bottom)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			rect.anchorMin = Vector2.zero;
			rect.anchorMax = Vector2.one;
			rect.pivot = new Vector2(0.5f, 0.5f);
			rect.offsetMin = new Vector2(left, bottom);
			rect.offsetMax = new Vector2(0f - right, 0f - top);
		}

		private static void SetTopRect(RectTransform rect, float left, float top, float right, float height)
		{
			//IL_000b: 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_002b: 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_004b: Unknown result type (might be due to invalid IL or missing references)
			rect.anchorMin = new Vector2(0f, 1f);
			rect.anchorMax = Vector2.one;
			rect.pivot = new Vector2(0.5f, 1f);
			rect.offsetMin = new Vector2(left, 0f - top - height);
			rect.offsetMax = new Vector2(0f - right, 0f - top);
		}

		private static void SetRightFill(RectTransform rect, float width, float top, float right, float bottom)
		{
			//IL_000b: 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_002b: 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_004b: Unknown result type (might be due to invalid IL or missing references)
			rect.anchorMin = new Vector2(1f, 0f);
			rect.anchorMax = Vector2.one;
			rect.pivot = new Vector2(1f, 0.5f);
			rect.offsetMin = new Vector2(0f - right - width, bottom);
			rect.offsetMax = new Vector2(0f - right, 0f - top);
		}

		private static void Stretch(RectTransform rect, Vector2 offsetMin, Vector2 offsetMax)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			rect.anchorMin = Vector2.zero;
			rect.anchorMax = Vector2.one;
			rect.pivot = new Vector2(0.5f, 0.5f);
			rect.offsetMin = offsetMin;
			rect.offsetMax = offsetMax;
		}

		private static void ClearChildren(RectTransform parent)
		{
			for (int num = ((Transform)parent).childCount - 1; num >= 0; num--)
			{
				GameObject gameObject = ((Component)((Transform)parent).GetChild(num)).gameObject;
				gameObject.SetActive(false);
				Object.Destroy((Object)(object)gameObject);
			}
		}
	}
	internal static class ChestRuleStore
	{
		private const string RuleKey = "ChestFlow.StorageRule";

		internal static ChestStorageRule Read(Container container)
		{
			if ((Object)(object)container == (Object)null)
			{
				return ChestStorageRule.Automatic();
			}
			ZNetView component = ((Component)container).GetComponent<ZNetView>();
			ZDO val = (((Object)(object)component != (Object)null) ? component.GetZDO() : null);
			if (val == null)
			{
				return ChestStorageRule.Automatic();
			}
			if (ChestStorageRuleCodec.TryDeserialize(val.GetString("ChestFlow.StorageRule", string.Empty), out ChestStorageRule rule))
			{
				return rule;
			}
			Plugin.LogInstance.LogWarning((object)("Ignored an invalid ChestFlow storage rule on " + ((Object)container).name + "."));
			return ChestStorageRule.Automatic();
		}

		internal static bool TryWrite(Container container, ChestStorageRule rule, out string error)
		{
			error = string.Empty;
			if ((Object)(object)container == (Object)null)
			{
				error = "The chest is no longer available.";
				return false;
			}
			ZNetView component = ((Component)container).GetComponent<ZNetView>();
			ZDO val = (((Object)(object)component != (Object)null) ? component.GetZDO() : null);
			if ((Object)(object)component == (Object)null || val == null)
			{
				error = "This container cannot persist storage rules.";
				return false;
			}
			if (!component.IsOwner())
			{
				error = "Waiting for chest ownership. Try Save again.";
				return false;
			}
			val.Set("ChestFlow.StorageRule", ChestStorageRuleCodec.Serialize(rule));
			return true;
		}

		internal static string ShortSummary(ChestStorageRule rule)
		{
			switch (rule.Scope)
			{
			case ChestRuleScope.Group:
			{
				if (!ItemCategoryCatalog.TryGetGroup(rule.GroupId, out ItemCategoryGroupDefinition definition) || definition == null)
				{
					return "Group";
				}
				return definition.DisplayName;
			}
			case ChestRuleScope.Categories:
				if (rule.Categories.Count == 1)
				{
					using IEnumerator<ItemCategory> enumerator = rule.Categories.GetEnumerator();
					if (enumerator.MoveNext())
					{
						return ItemCategoryCatalog.Get(enumerator.Current).DisplayName;
					}
				}
				return rule.Categories.Count + " Categories";
			case ChestRuleScope.Items:
				return rule.ItemPrefabNames.Count + ((rule.ItemPrefabNames.Count == 1) ? " Item" : " Items");
			default:
				return "Auto";
			}
		}
	}
	internal static class ChestUpgradeService
	{
		private readonly struct ItemPosition
		{
			internal ItemData Item { get; }

			internal Vector2i Position { get; }

			internal ItemPosition(ItemData item, Vector2i position)
			{
				//IL_0008: Unknown result type (might be due to invalid IL or missing references)
				//IL_0009: Unknown result type (might be due to invalid IL or missing references)
				Item = item;
				Position = position;
			}
		}

		private sealed class TierDefinition
		{
			internal int Tier { get; }

			internal string DisplayName { get; }

			internal string PrefabName { get; }

			internal TierDefinition(int tier, string displayName, string prefabName)
			{
				Tier = tier;
				DisplayName = displayName;
				PrefabName = prefabName;
			}
		}

		private const string TierKey = "ChestFlow.ChestTier";

		internal const int ReinforcedTier = 1;

		internal const int BlackMetalTier = 2;

		internal const int GraustenTier = 3;

		private static readonly FieldInfo InventoryNameField = AccessTools.Field(typeof(Inventory), "m_name");

		private static readonly FieldInfo InventoryBackgroundField = AccessTools.Field(typeof(Inventory), "m_bkg");

		private static readonly FieldInfo InventoryWidthField = AccessTools.Field(typeof(Inventory), "m_width");

		private static readonly FieldInfo InventoryHeightField = AccessTools.Field(typeof(Inventory), "m_height");

		private static readonly MethodInfo GetPrefabNameMethod = AccessTools.Method(typeof(ZNetView), "GetPrefabName", (Type[])null, (Type[])null);

		private static readonly TierDefinition[] Tiers = new TierDefinition[4]
		{
			new TierDefinition(0, "Chest", "piece_chest_wood"),
			new TierDefinition(1, "Reinforced", "piece_chest"),
			new TierDefinition(2, "Black Metal", "piece_chest_blackmetal"),
			new TierDefinition(3, "Grausten", "piece_chest_grausten")
		};

		private static int _lastLegacyMigrationInstanceId = int.MinValue;

		internal static bool CanUpgradeTo(Container? container, int targetTier)
		{
			Player localPlayer = Player.m_localPlayer;
			int currentTier = ManagedTier(container);
			if ((Object)(object)localPlayer == (Object)null || !ChestUpgradePath.CanUpgrade(currentTier, targetTier))
			{
				return false;
			}
			if (!TryGetTierComponents(Tiers[targetTier], out Container _, out Piece piece) || (Object)(object)piece == (Object)null)
			{
				return false;
			}
			if (!localPlayer.NoCostCheat())
			{
				return localPlayer.IsRecipeKnown(piece.m_name);
			}
			return true;
		}

		internal static bool UpdateLegacyMigration()
		{
			if (!ModConfig.Enabled.Value || (Object)(object)InventoryGui.instance == (Object)null || (Object)(object)Player.m_localPlayer == (Object)null)
			{
				_lastLegacyMigrationInstanceId = int.MinValue;
				return false;
			}
			Container val = InventoryAccess.CurrentContainer(InventoryGui.instance);
			if ((Object)(object)val == (Object)null)
			{
				_lastLegacyMigrationInstanceId = int.MinValue;
				return false;
			}
			int num = ReadTierMarker(val);
			if (!ChestUpgradePath.IsLegacy(PrefabName(val), num))
			{
				return false;
			}
			int instanceID = ((Object)val).GetInstanceID();
			if (_lastLegacyMigrationInstanceId == instanceID)
			{
				return false;
			}
			ZNetView component = ((Component)val).GetComponent<ZNetView>();
			if ((Object)(object)component == (Object)null || !component.IsOwner())
			{
				return false;
			}
			_lastLegacyMigrationInstanceId = instanceID;
			Player localPlayer = Player.m_localPlayer;
			InventoryGui.instance.Hide();
			if (!TryReplaceChest(val, num, out Container replacement, out string error) || (Object)(object)replacement == (Object)null)
			{
				ShowMessage("Legacy chest migration failed: " + error);
				return true;
			}
			int[] array = ChestUpgradePath.ObsoleteLegacyTiers(num);
			foreach (int num2 in array)
			{
				if (TryGetTierComponents(Tiers[num2], out Container _, out Piece piece) && (Object)(object)piece != (Object)null)
				{
					RefundRequirements(localPlayer, piece.m_resources);
				}
			}
			PlayUpgradeEffect(num, replacement);
			ShowMessage("ChestFlow converted this legacy upgrade to a compact vanilla " + Tiers[num].DisplayName + " chest. Reopen it to continue.");
			return true;
		}

		internal static void UpgradeOpenChest(int targetTier)
		{
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_013c: Unknown result type (might be due to invalid IL or missing references)
			Player localPlayer = Player.m_localPlayer;
			Container val = InventoryAccess.CurrentContainer(InventoryGui.instance);
			if ((Object)(object)localPlayer == (Object)null || (Object)(object)val == (Object)null)
			{
				ShowMessage("Open a wooden, compact reinforced, or compact black-metal chest to upgrade it.");
				return;
			}
			int num = ManagedTier(val);
			if (num < 0)
			{
				ShowMessage("Only a standard wooden chest or ChestFlow compact chest can be upgraded in place.");
				return;
			}
			if (!ChestUpgradePath.CanUpgrade(num, targetTier))
			{
				ShowMessage("That chest tier is not an available upgrade from the current chest.");
				return;
			}
			ZNetView component = ((Component)val).GetComponent<ZNetView>();
			ZDO val2 = (((Object)(object)component != (Object)null) ? component.GetZDO() : null);
			if ((Object)(object)component == (Object)null || val2 == null)
			{
				ShowMessage("This chest cannot persist an upgrade.");
				return;
			}
			if (!component.IsOwner())
			{
				ShowMessage("Waiting for chest ownership. Try Upgrade again.");
				return;
			}
			if (!PrivateArea.CheckAccess(((Component)val).transform.position, 0f, true, false))
			{
				ShowMessage("You do not have access to upgrade this chest.");
				return;
			}
			TierDefinition tierDefinition = Tiers[targetTier];
			if (!TryGetTierComponents(tierDefinition, out Container container, out Piece piece) || (Object)(object)piece == (Object)null)
			{
				ShowMessage(tierDefinition.DisplayName + " chest assets are not available.");
				return;
			}
			if (!TryGetTierComponents(Tiers[num], out container, out Piece piece2) || (Object)(object)piece2 == (Object)null)
			{
				ShowMessage("The current chest recipe is not available.");
				return;
			}
			bool flag = localPlayer.NoCostCheat() || ((Object)(object)ZoneSystem.instance != (Object)null && ZoneSystem.instance.GetGlobalKey(piece.FreeBuildKey()));
			if (!flag && !localPlayer.IsRecipeKnown(piece.m_name))
			{
				ShowMessage(tierDefinition.DisplayName + " chest construction has not been unlocked yet.");
				return;
			}
			if (!flag && !localPlayer.HaveRequirements(piece, (RequirementMode)0))
			{
				ShowMessage("Upgrade requires " + DescribeRequirements(piece) + " and the appropriate crafting station.");
				return;
			}
			if (!flag)
			{
				localPlayer.ConsumeResources(piece.m_resources, 0, -1, 1);
			}
			InventoryGui instance = InventoryGui.instance;
			if (instance != null)
			{
				instance.Hide();
			}
			if (!TryReplaceChest(val, tierDefinition.Tier, out Container replacement, out string error) || (Object)(object)replacement == (Object)null)
			{
				if (!flag)
				{
					RefundRequirements(localPlayer, piece.m_resources);
				}
				ShowMessage("Chest upgrade failed: " + error);
			}
			else
			{
				DropRequirementsBesideChest(localPlayer, replacement, piece2.m_resources);
				PlayUpgradeEffect(tierDefinition.Tier, replacement);
				ShowMessage("Chest upgraded to compact " + tierDefinition.DisplayName + ". Reopen it to continue.");
			}
		}

		internal static void ApplyState(Container container)
		{
			if ((Object)(object)container == (Object)null)
			{
				return;
			}
			string prefabName = PrefabName(container);
			int markerTier = ReadTierMarker(container);
			int num = ChestUpgradePath.ResolveManagedTier(prefabName, markerTier);
			if (num <= 0)
			{
				return;
			}
			ChestUpgradeVisualState chestUpgradeVisualState = ((Component)container).GetComponent<ChestUpgradeVisualState>() ?? ((Component)container).gameObject.AddComponent<ChestUpgradeVisualState>();
			if (chestUpgradeVisualState.AppliedTier == num)
			{
				return;
			}
			Piece piece;
			bool flag;
			if (ChestUpgradePath.IsLegacy(prefabName, markerTier))
			{
				if (!TryGetTierComponents(Tiers[num], out Container container2, out piece) || (Object)(object)container2 == (Object)null)
				{
					return;
				}
				ApplyContainerDefinition(container, container2);
				flag = TryApplyLegacyVisual(container, container2, chestUpgradeVisualState);
			}
			else
			{
				if (!TryGetTierComponents(Tiers[0], out Container container3, out piece) || (Object)(object)container3 == (Object)null)
				{
					return;
				}
				flag = TryApplyCompactVisual(container, container3, chestUpgradeVisualState);
			}
			if (flag)
			{
				chestUpgradeVisualState.AppliedTier = num;
			}
		}

		internal static Requirement[]? AdditionalRefundRequirements(Piece piece)
		{
			Container val = (((Object)(object)piece != (Object)null) ? ((Component)piece).GetComponent<Container>() : null);
			if ((Object)(object)val == (Object)null)
			{
				return null;
			}
			int num = ReadTierMarker(val);
			if (!ChestUpgradePath.IsLegacy(PrefabName(val), num))
			{
				return null;
			}
			List<Requirement> list = new List<Requirement>();
			for (int i = 1; i <= num; i++)
			{
				if (TryGetTierComponents(Tiers[i], out Container _, out Piece piece2) && (Object)(object)piece2 != (Object)null)
				{
					list.AddRange(piece2.m_resources.Where((Requirement requirement) => requirement != null));
				}
			}
			if (list.Count <= 0)
			{
				return null;
			}
			return list.ToArray();
		}

		private static bool TryReplaceChest(Container source, int targetTier, out Container? replacement, out string error)
		{
			//IL_007c: 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_00f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_019a: Unknown result type (might be due to invalid IL or missing references)
			replacement = null;
			error = string.Empty;
			if ((Object)(object)ZNetScene.instance == (Object)null)
			{
				error = "the network scene is unavailable.";
				return false;
			}
			ZNetView component = ((Component)source).GetComponent<ZNetView>();
			Piece component2 = ((Component)source).GetComponent<Piece>();
			if ((Object)(object)component == (Object)null || component.GetZDO() == null || !component.IsOwner() || (Object)(object)component2 == (Object)null)
			{
				error = "the original chest is not locally owned.";
				return false;
			}
			GameObject prefab = ZNetScene.instance.GetPrefab(ChestUpgradePath.PrefabForTier(targetTier));
			if ((Object)(object)prefab == (Object)null)
			{
				error = "the target vanilla chest prefab is unavailable.";
				return false;
			}
			PlatformUserID val = PlatformUserID.None;
			int creatorPlatformUserIdIndex = component2.GetCreatorPlatformUserIdIndex();
			if (creatorPlatformUserIdIndex >= 0)
			{
				World val2 = (((Object)(object)ZNet.instance != (Object)null) ? ZNet.instance.GetWorld() : null);
				if (val2 == null || creatorPlatformUserIdIndex >= val2.m_playerHistory.Count)
				{
					error = "the original chest creator record is unavailable.";
					return false;
				}
				val = val2.m_playerHistory[creatorPlatformUserIdIndex].m_id;
			}
			ChestStorageRule rule = ChestRuleStore.Read(source);
			GameObject val3 = null;
			bool flag = false;
			try
			{
				val3 = Object.Instantiate<GameObject>(prefab, ((Component)source).transform.position, ((Component)source).transform.rotation);
				replacement = val3.GetComponent<Container>();
				ZNetView component3 = val3.GetComponent<ZNetView>();
				Piece component4 = val3.GetComponent<Piece>();
				ZDO val4 = (((Object)(object)component3 != (Object)null) ? component3.GetZDO() : null);
				if ((Object)(object)replacement == (Object)null || (Object)(object)component3 == (Object)null || (Object)(object)component4 == (Object)null || val4 == null)
				{
					error = "the replacement chest did not initialize.";
					return false;
				}
				if (!component3.IsOwner())
				{
					component3.ClaimOwnership();
				}
				if (!component3.IsOwner())
				{
					error = "the replacement chest could not be claimed.";
					return false;
				}
				component4.SetCreator(component2.GetCreator(), val);
				val4.Set("ChestFlow.ChestTier", targetTier);
				if (!ChestRuleStore.TryWrite(replacement, rule, out error))
				{
					return false;
				}
				ChestReserveStore.Write(replacement, ChestReserveStore.ReadRaw(source));
				if (!TryMoveInventory(source, replacement, out error))
				{
					return false;
				}
				flag = true;
				try
				{
					ApplyState(replacement);
				}
				catch (Exception ex)
				{
					Plugin.LogInstance.LogWarning((object)("The replacement chest is safe but could not be compacted: " + ex));
				}
				try
				{
					component.Destroy();
				}
				catch (Exception ex2)
				{
					Plugin.LogInstance.LogWarning((object)("The old chest was emptied but its shell could not be removed: " + ex2));
				}
				return true;
			}
			catch (Exception ex3)
			{
				error = ex3.GetBaseException().Message;
				Plugin.LogInstance.LogError((object)("Chest replacement failed: " + ex3));
				return false;
			}
			finally
			{
				if (!flag && (Object)(object)val3 != (Object)null)
				{
					ZNetView component5 = val3.GetComponent<ZNetView>();
					if ((Object)(object)component5 != (Object)null && component5.IsValid() && component5.IsOwner())
					{
						component5.Destroy();
					}
					else
					{
						Object.Destroy((Object)(object)val3);
					}
					replacement = null;
				}
			}
		}

		private static bool TryMoveInventory(Container source, Container target, out string error)
		{
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			error = string.Empty;
			Inventory inventory = source.GetInventory();
			Inventory targetInventory = target.GetInventory();
			List<ItemPosition> list = (from item in inventory.GetAllItems()
				select new ItemPosition(item, item.m_gridPos)).ToList();
			if (list.Any((ItemPosition entry) => entry.Position.x < 0 || entry.Position.y < 0 || entry.Position.x >= targetInventory.GetWidth() || entry.Position.y >= target.m_height))
			{
				error = "the target chest cannot contain every existing item position.";
				return false;
			}
			List<ItemPosition> list2 = new List<ItemPosition>();
			foreach (ItemPosition item in list)
			{
				int stack = item.Item.m_stack;
				if (!targetInventory.MoveItemToThis(inventory, item.Item, stack, item.Position.x, item.Position.y))
				{
					RollBackMovedItems(inventory, targetInventory, list2);
					error = "an inventory stack could not be transferred safely.";
					return false;
				}
				list2.Add(item);
			}
			if (inventory.GetAllItems().Count != 0)
			{
				RollBackMovedItems(inventory, targetInventory, list2);
				error = "the original chest was not empty after transfer.";
				return false;
			}
			return true;
		}

		private static void RollBackMovedItems(Inventory sourceInventory, Inventory targetInventory, IReadOnlyList<ItemPosition> moved)
		{
			//IL_002a: 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)
			for (int num = moved.Count - 1; num >= 0; num--)
			{
				ItemPosition itemPosition = moved[num];
				sourceInventory.MoveItemToThis(targetInventory, itemPosition.Item, itemPosition.Item.m_stack, itemPosition.Position.x, itemPosition.Position.y);
			}
		}

		private static void RefundRequirements(Player player, IEnumerable<Requirement> requirements)
		{
			foreach (Requirement requirement in requirements)
			{
				if (requirement != null && requirement.m_recover && requirement.m_amount > 0)
				{
					ItemDrop resItem = requirement.m_resItem;
					if (resItem?.m_itemData?.m_shared != null)
					{
						RefundResource(player, resItem, requirement.m_amount);
					}
				}
			}
		}

		private static void RefundResource(Player player, ItemDrop resource, int amountToRefund)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			Inventory inventory = ((Humanoid)player).GetInventory();
			Vector3 val = ((Component)player).transform.position + ((Component)player).transform.forward + Vector3.up;
			int num = amountToRefund;
			int num2 = Mathf.Max(1, resource.m_itemData.m_shared.m_maxStackSize);
			while (num > 0)
			{
				int num3 = Mathf.Min(num, num2);
				ItemData val2 = CreateResourceItem(resource, num3);
				if (!inventory.CanAddItem(val2, num3) || !inventory.AddItem(val2))
				{
					ItemDrop.DropItem(val2, num3, val, Quaternion.identity);
				}
				num -= num3;
			}
		}

		private static ItemData CreateResourceItem(ItemDrop resource, int amount)
		{
			ItemData val = resource.m_itemData.Clone();
			val.m_stack = amount;
			if ((Object)(object)val.m_dropPrefab == (Object)null)
			{
				val.m_dropPrefab = ((Component)resource).gameObject;
			}
			return val;
		}

		private static void DropRequirementsBesideChest(Player player, Container chest, IEnumerable<Requirement> requirements)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: 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_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: 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_0084: 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_0093: 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_005c: 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)
			//IL_0173: Unknown result type (might be due to invalid IL or missing references)
			//IL_0174: Unknown result type (might be due to invalid IL or missing references)
			//IL_0176: 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)
			Vector3 val = ((Component)player).transform.position - ((Component)chest).transform.position;
			val.y = 0f;
			if (((Vector3)(ref val)).sqrMagnitude < 0.01f)
			{
				val = ((Component)chest).transform.forward;
				val.y = 0f;
			}
			if (((Vector3)(ref val)).sqrMagnitude < 0.01f)
			{
				val = Vector3.forward;
			}
			((Vector3)(ref val)).Normalize();
			Vector3 val2 = ((Component)chest).transform.position + val * 0.9f + Vector3.up * 0.5f;
			int num = 0;
			Vector3 val3 = default(Vector3);
			foreach (Requirement requirement in requirements)
			{
				if (requirement == null || !requirement.m_recover || requirement.m_amount <= 0)
				{
					continue;
				}
				ItemDrop resItem = requirement.m_resItem;
				if (resItem?.m_itemData?.m_shared == null)
				{
					continue;
				}
				int num2 = requirement.m_amount;
				int num3 = Mathf.Max(1, resItem.m_itemData.m_shared.m_maxStackSize);
				while (num2 > 0)
				{
					int num4 = Mathf.Min(num2, num3);
					try
					{
						ItemData obj = CreateResourceItem(resItem, num4);
						float num5 = (float)num * 137.5f * ((float)Math.PI / 180f);
						float num6 = 0.08f * Mathf.Sqrt((float)num);
						((Vector3)(ref val3))..ctor(Mathf.Cos(num5) * num6, 0f, Mathf.Sin(num5) * num6);
						ItemDrop.DropItem(obj, num4, val2 + val3, Quaternion.identity);
						num2 -= num4;
						num++;
					}
					catch (Exception ex)
					{
						Plugin.LogInstance.LogError((object)("Could not drop the destroyed chest's " + resItem.m_itemData.m_shared.m_name + " refund; returning the remaining amount safely to the player instead: " + ex));
						try
						{
							RefundResource(player, resItem, num2);
						}
						catch (Exception ex2)
						{
							Plugin.LogInstance.LogError((object)($"Could not return {num2} of {resItem.m_itemData.m_shared.m_name} after the " + "ground refund failed: " + ex2));
						}
						break;
					}
				}
			}
		}

		private static void ApplyContainerDefinition(Container target, Container source)
		{
			target.m_name = source.m_name;
			target.m_bkg = source.m_bkg;
			target.m_width = source.m_width;
			target.m_height = source.m_height;
			target.m_openEffects = source.m_openEffects;
			target.m_closeEffects = source.m_closeEffects;
			Inventory inventory = target.GetInventory();
			if (inventory != null)
			{
				InventoryNameField.SetValue(inventory, source.m_name);
				InventoryBackgroundField.SetValue(inventory, source.m_bkg);
				InventoryWidthField.SetValue(inventory, source.m_width);
				InventoryHeightField.SetValue(inventory, source.m_height);
			}
		}

		private static bool TryApplyLegacyVisual(Container target, Container source, ChestUpgradeVisualState state)
		{
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)source.m_closed == (Object)null || (Object)(object)source.m_open == (Object)null || (Object)(object)target.m_closed == (Object)null || (Object)(object)target.m_open == (Object)null)
			{
				return false;
			}
			if (!state.HasBaseBounds)
			{
				state.OriginalClosed = target.m_closed;
				state.OriginalOpen = target.m_open;
				Transform val = FindCommonAncestor(((Component)target).transform, state.OriginalClosed.transform, state.OriginalOpen.transform);
				if ((Object)(object)val == (Object)null || !TryCalculateBounds(((Component)target).transform, ((Component)val).gameObject, state.OriginalOpen.transform, out var bounds))
				{
					return false;
				}
				state.OriginalVisualRoot = ((Component)val).gameObject;
				state.OriginalRenderers = ((Component)val).GetComponentsInChildren<Renderer>(true);
				state.BaseClosedBounds = bounds;
				state.HasBaseBounds = true;
			}
			return TryInstallFittedVisual(target, source, state, replaceColliders: false);
		}

		private static bool TryApplyCompactVisual(Container target, Container woodenTemplate, ChestUpgradeVisualState state)
		{
			//IL_0131: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)target.m_closed == (Object)null || (Object)(object)target.m_open == (Object)null || (Object)(object)woodenTemplate.m_closed == (Object)null || (Object)(object)woodenTemplate.m_open == (Object)null)
			{
				return false;
			}
			if (!state.HasBaseBounds)
			{
				Transform val = FindCommonAncestor(((Component)woodenTemplate).transform, woodenTemplate.m_closed.transform, woodenTemplate.m_open.transform);
				Transform val2 = FindCommonAncestor(((Component)target).transform, target.m_closed.transform, target.m_open.transform);
				if ((Object)(object)val == (Object)null || (Object)(object)val2 == (Object)null || !TryCalculateBounds(((Component)woodenTemplate).transform, ((Component)val).gameObject, woodenTemplate.m_open.transform, out var bounds))
				{
					return false;
				}
				state.OriginalClosed = target.m_closed;
				state.OriginalOpen = target.m_open;
				state.OriginalVisualRoot = ((Component)val2).gameObject;
				state.OriginalRenderers = ((Component)val2).GetComponentsInChildren<Renderer>(true);
				state.OriginalColliders = ((Component)target).GetComponentsInChildren<Collider>(true);
				state.OriginalColliderEnabled = state.OriginalColliders.Select((Collider collider) => (Object)(object)collider != (Object)null && collider.enabled).ToArray();
				state.BaseClosedBounds = bounds;
				state.HasBaseBounds = true;
			}
			return TryInstallFittedVisual(target, target, state, replaceColliders: true, woodenTemplate);
		}

		private static bool TryInstallFittedVisual(Container target, Container visualSource, ChestUpgradeVisualState state, bool replaceColliders, Container? colliderSource = null)
		{
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Expected O, but got Unknown
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_0106: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: 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_014c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0152: Unknown result type (might be due to invalid IL or missing references)
			//IL_0157: Unknown result type (might be due to invalid IL or missing references)
			//IL_015b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0162: Unknown result type (might be due to invalid IL or missing references)
			//IL_0167: Unknown result type (might be due to invalid IL or missing references)
			//IL_016c: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)state.VisualRoot != (Object)null)
			{
				state.VisualRoot.SetActive(false);
				Object.Destroy((Object)(object)state.VisualRoot);
			}
			if ((Object)(object)state.CollisionRoot != (Object)null)
			{
				Object.Destroy((Object)(object)state.CollisionRoot);
			}
			GameObject val = new GameObject("ChestFlow_CompactVisual");
			val.transform.SetParent(((Component)target).transform, false);
			if (!TryCloneVisualHierarchy(visualSource, val.transform, out GameObject hierarchy, out GameObject closed, out GameObject open) || (Object)(object)hierarchy == (Object)null || (Object)(object)closed == (Object)null || (Object)(object)open == (Object)null)
			{
				Object.Destroy((Object)(object)val);
				return false;
			}
			if (!TryCalculateBounds(((Component)target).transform, hierarchy, open.transform, out var bounds))
			{
				Object.Destroy((Object)(object)val);
				return false;
			}
			Transform transform = val.transform;
			Bounds baseClosedBounds = state.BaseClosedBounds;
			float num = SafeScale(((Bounds)(ref baseClosedBounds)).size.x, ((Bounds)(ref bounds)).size.x);
			baseClosedBounds = state.BaseClosedBounds;
			float num2 = SafeScale(((Bounds)(ref baseClosedBounds)).size.y, ((Bounds)(ref bounds)).size.y);
			baseClosedBounds = state.BaseClosedBounds;
			transform.localScale = new Vector3(num, num2, SafeScale(((Bounds)(ref baseClosedBounds)).size.z, ((Bounds)(ref bounds)).size.z));
			if (TryCalculateBounds(((Component)target).transform, hierarchy, open.transform, out var bounds2))
			{
				Transform transform2 = val.transform;
				Vector3 localPosition = transform2.localPosition;
				baseClosedBounds = state.BaseClosedBounds;
				transform2.localPosition = localPosition + (((Bounds)(ref baseClosedBounds)).center - ((Bounds)(ref bounds2)).center);
			}
			GameObject collisionRoot = null;
			if (replaceColliders)
			{
				if ((Object)(object)colliderSource == (Object)null || !TryCloneColliders(colliderSource, target, out collisionRoot))
				{
					Object.Destroy((Object)(object)val);
					return false;
				}
				Collider[] originalColliders = state.OriginalColliders;
				foreach (Collider val2 in originalColliders)
				{
					if ((Object)(object)val2 != (Object)null)
					{
						val2.enabled = false;
					}
				}
			}
			Renderer[] originalRenderers = state.OriginalRenderers;
			foreach (Renderer val3 in originalRenderers)
			{
				if ((Object)(object)val3 != (Object)null)
				{
					val3.enabled = false;
				}
			}
			target.m_closed = closed;
			target.m_open = open;
			state.VisualRoot = val;
			state.CollisionRoot = collisionRoot;
			bool flag = target.IsInUse();
			closed.SetActive(!flag);
			open.SetActive(flag);
			return true;
		}

		private static bool TryCloneVisualHierarchy(Container source, Transform parent, out GameObject? hierarchy, out GameObject? closed, out GameObject? open)
		{
			//IL_007c: 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)
			//IL_0087: 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_0090: 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_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: 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)
			hierarchy = null;
			closed = null;
			open = null;
			Transform val = FindCommonAncestor(((Component)source).transform, source.m_closed.transform, source.m_open.transform);
			if ((Object)(object)val == (Object)null)
			{
				return false;
			}
			int[] path = ChildPath(val, source.m_closed.transform);
			int[] path2 = ChildPath(val, source.m_open.transform);
			hierarchy = Object.Instantiate<GameObject>(((Component)val).gameObject, parent, false);
			((Object)hierarchy).name = "ChestFlow_Model";
			Matrix4x4 val2 = ((Component)source).transform.worldToLocalMatrix * val.localToWorldMatrix;
			Vector4 column = ((Matrix4x4)(ref val2)).GetColumn(3);
			hierarchy.transform.localPosition = new Vector3(column.x, column.y, column.z);
			hierarchy.transform.localRotation = ((Matrix4x4)(ref val2)).rotation;
			hierarchy.transform.localScale = ((Matrix4x4)(ref val2)).lossyScale;
			Collider[] componentsInChildren = hierarchy.GetComponentsInChildren<Collider>(true);
			for (int i = 0; i < componentsInChildren.Length; i++)
			{
				componentsInChildren[i].enabled = false;
			}
			MonoBehaviour[] componentsInChildren2 = hierarchy.GetComponentsInChildren<MonoBehaviour>(true);
			for (int i = 0; i < componentsInChildren2.Length; i++)
			{
				((Behaviour)componentsInChildren2[i]).enabled = false;
			}
			Transform? obj = FollowPath(hierarchy.transform, path);
			closed = ((obj != null) ? ((Component)obj).gameObject : null);
			Transform? obj2 = FollowPath(hierarchy.transform, path2);
			open = ((obj2 != null) ? ((Component)obj2).gameObject : null);
			if ((Object)(object)closed != (Object)null)
			{
				return (Object)(object)open != (Object)null;
			}
			return false;
		}

		private static bool TryCloneColliders(Container source, Container target, out GameObject? collisionRoot)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Expected O, but got Unknown
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: 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_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			collisionRoot = new GameObject("ChestFlow_CompactColliders");
			collisionRoot.transform.SetParent(((Component)target).transform, false);
			int num = 0;
			Collider[] componentsInChildren = ((Component)source).GetComponentsInChildren<Collider>(true);
			foreach (Collider val in componentsInChildren)
			{
				if (!((Object)(object)val == (Object)null))
				{
					GameObject val2 = new GameObject(((Object)((Component)val).gameObject).name + "_Collider");
					val2.layer = ((Component)val).gameObject.layer;
					val2.transform.SetParent(collisionRoot.transform, false);
					Matrix4x4 val3 = ((Component)source).transform.worldToLocalMatrix * ((Component)val).transform.localToWorldMatrix;
					Vector4 column = ((Matrix4x4)(ref val3)).GetColumn(3);
					val2.transform.localPosition = new Vector3(column.x, column.y, column.z);
					val2.transform.localRotation = ((Matrix4x4)(ref val3)).rotation;
					val2.transform.localScale = ((Matrix4x4)(ref val3)).lossyScale;
					Collider val4 = CloneCollider(val, val2);
					if ((Object)(object)val4 == (Object)null)
					{
						Object.Destroy((Object)(object)val2);
						continue;
					}
					val4.enabled = val.enabled;
					val4.isTrigger = val.isTrigger;
					val4.sharedMaterial = val.sharedMaterial;
					val4.contactOffset = val.contactOffset;
					num++;
				}
			}
			if (num > 0)
			{
				return true;
			}
			Object.Destroy((Object)(object)collisionRoot);
			collisionRoot = null;
			return false;
		}

		private static Collider? CloneCollider(Collider source, GameObject holder)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: 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)
			BoxCollider val = (BoxCollider)(object)((source is BoxCollider) ? source : null);
			if (val != null)
			{
				BoxCollider obj = holder.AddComponent<BoxCollider>();
				obj.center = val.center;
				obj.size = val.size;
				return (Collider?)(object)obj;
			}
			SphereCollider val2 = (SphereCollider)(object)((source is SphereCollider) ? source : null);
			if (val2 != null)
			{
				SphereCollider obj2 = holder.AddComponent<SphereCollider>();
				obj2.center = val2.center;
				obj2.radius = val2.radius;
				return (Collider?)(object)obj2;
			}
			CapsuleCollider val3 = (CapsuleCollider)(object)((source is CapsuleCollider) ? source : null);
			if (val3 != null)
			{
				CapsuleCollider obj3 = holder.AddComponent<CapsuleCollider>();
				obj3.center = val3.center;
				obj3.radius = val3.radius;
				obj3.height = val3.height;
				obj3.direction = val3.direction;
				return (Collider?)(object)obj3;
			}
			MeshCollider val4 = (MeshCollider)(object)((source is MeshCollider) ? source : null);
			if (val4 != null)
			{
				MeshCollider obj4 = holder.AddComponent<MeshCollider>();
				obj4.sharedMesh = val4.sharedMesh;
				obj4.convex = val4.convex;
				return (Collider?)(object)obj4;
			}
			return null;
		}

		private static Transform? FindCommonAncestor(Transform boundary, Transform first, Transform second)
		{
			HashSet<Transform> hashSet = new HashSet<Transform>();
			Transform val = first;
			while ((Object)(object)val != (Object)null)
			{
				hashSet.Add(val);
				if ((Object)(object)val == (Object)(object)boundary)
				{
					break;
				}
				val = val.parent;
			}
			Transform val2 = second;
			while ((Object)(object)val2 != (Object)null)
			{
				if (hashSet.Contains(val2))
				{
					if (!((Object)(object)val2 == (Object)(object)boundary))
					{
						return val2;
					}
					return null;
				}
				if ((Object)(object)val2 == (Object)(object)boundary)
				{
					break;
				}
				val2 = val2.parent;
			}
			return null;
		}

		private static int[] ChildPath(Transform ancestor, Transform descendant)
		{
			List<int> list = new List<int>();
			Transform val = descendant;
			while ((Object)(object)val != (Object)(object)ancestor)
			{
				list.Add(val.GetSiblingIndex());
				val = val.parent;
			}
			list.Reverse();
			return list.ToArray();
		}

		private static Transform? FollowPath(Transform root, IEnumerable<int> path)
		{
			Transform val = root;
			foreach (int item in path)
			{
				if (item < 0 || item >= val.childCount)
				{
					return null;
				}
				val = val.GetChild(item);
			}
			return val;
		}

		private static bool TryCalculateBounds(Transform coordinateSpace, GameObject visual, Transform? excludedBranch, out Bounds bounds)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_013a: Unknown result type (might be due to invalid IL or missing references)
			//IL_013f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: 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_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: 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_00d0: 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_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			bounds = default(Bounds);
			bool flag = false;
			Renderer[] componentsInChildren = visual.GetComponentsInChildren<Renderer>(true);
			foreach (Renderer val in componentsInChildren)
			{
				if ((Object)(object)excludedBranch != (Object)null && ((Object)(object)((Component)val).transform == (Object)(object)excludedBranch || ((Component)val).transform.IsChildOf(excludedBranch)))
				{
					continue;
				}
				SkinnedMeshRenderer val2 = (SkinnedMeshRenderer)(object)((val is SkinnedMeshRenderer) ? val : null);
				Bounds val3;
				if (val2 != null)
				{
					val3 = ((Renderer)val2).localBounds;
				}
				else
				{
					MeshFilter component = ((Component)val).GetComponent<MeshFilter>();
					if ((Object)(object)component == (Object)null || (Object)(object)component.sharedMesh == (Object)null)
					{
						continue;
					}
					val3 = component.sharedMesh.bounds;
				}
				Vector3 center = ((Bounds)(ref val3)).center;
				Vector3 extents = ((Bounds)(ref val3)).extents;
				for (int j = -1; j <= 1; j += 2)
				{
					for (int k = -1; k <= 1; k += 2)
					{
						for (int l = -1; l <= 1; l += 2)
						{
							Vector3 val4 = center + Vector3.Scale(extents, new Vector3((float)j, (float)k, (float)l));
							Vector3 val5 = coordinateSpace.InverseTransformPoint(((Component)val).transform.TransformPoint(val4));
							if (!flag)
							{
								bounds = new Bounds(val5, Vector3.zero);
								flag = true;
							}
							else
							{
								((Bounds)(ref bounds)).Encapsulate(val5);
							}
						}
					}
				}
			}
			if (flag)
			{
				Vector3 size = ((Bounds)(ref bounds)).size;
				return ((Vector3)(ref size)).sqrMagnitude > 1E-06f;
			}
			return false;
		}

		private static float SafeScale(float targetSize, float sourceSize)
		{
			if (!(sourceSize > 0.0001f))
			{
				return 1f;
			}
			return targetSize / sourceSize;
		}

		private static bool TryGetTierComponents(TierDefinition definition, out Container? container, out Piece? piece)
		{
			container = null;
			piece = null;
			if ((Object)(object)ZNetScene.instance == (Object)null)
			{
				return false;
			}
			GameObject prefab = ZNetScene.instance.GetPrefab(definition.PrefabName);
			if ((Object)(object)prefab == (Object)null)
			{
				return false;
			}
			container = prefab.GetComponent<Container>();
			piece = prefab.GetComponent<Piece>();
			if ((Object)(object)container != (Object)null)
			{
				return (Object)(object)piece != (Object)null;
			}
			return false;
		}

		private static int ManagedTier(Container? container)
		{
			if ((Object)(object)container == (Object)null)
			{
				return -1;
			}
			return ChestUpgradePath.ResolveManagedTier(PrefabName(container), ReadTierMarker(container));
		}

		private static string PrefabName(Container container)
		{
			ZNetView component = ((Component)container).GetComponent<ZNetView>();
			if (!((Object)(object)component != (Object)null))
			{
				return string.Empty;
			}
			return (GetPrefabNameMethod.Invoke(component, null) as string) ?? string.Empty;
		}

		private static int ReadTierMarker(Container? container)
		{
			if ((Object)(object)container == (Object)null)
			{
				return 0;
			}
			ZNetView component = ((Component)container).GetComponent<ZNetView>();
			ZDO val = (((Object)(object)component != (Object)null) ? component.GetZDO() : null);
			if (val != null)
			{
				return val.GetInt("ChestFlow.ChestTier", 0);
			}
			return 0;
		}

		private static void PlayUpgradeEffect(int tier, Container container)
		{
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: 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)
			if (TryGetTierComponents(Tiers[tier], out Container _, out Piece piece) && !((Object)(object)piece == (Object)null))
			{
				EffectList placeEffect = piece.m_placeEffect;
				if (placeEffect != null)
				{
					placeEffect.Create(((Component)container).transform.position, ((Component)container).transform.rotation, ((Component)container).transform, 1f, -1, default(ZDOID));
				}
			}
		}

		private static string DescribeRequirements(Piece piece)
		{
			IEnumerable<string> values = piece.m_resources.Where((Requirement requirement) => requirement?.m_resItem?.m_itemData?.m_shared != null && requirement.m_amount > 0).Select(delegate(Requirement requirement)
			{
				string name = requirement.m_resItem.m_itemData.m_shared.m_name;
				string text2 = ((Localization.instance != null) ? Localization.instance.Localize(name) : name);
				return requirement.m_amount + " " + text2;
			});
			string text = string.Join(", ", values);
			if (text.Length <= 0)
			{
				return "the next chest tier's materials";
			}
			return text;
		}

		private static void ShowMessage(string message)
		{
			Player localPlayer = Player.m_localPlayer;
			if (localPlayer != null)
			{
				((Character)localPlayer).Message((MessageType)2, message, 0, (Sprite)null, false);
			}
		}
	}
	internal sealed class ChestUpgradeVisualState : MonoBehaviour
	{
		internal int AppliedTier { get; set; }

		internal bool HasBaseBounds { get; set; }

		internal Bounds BaseClosedBounds { get; set; }

		internal GameObject? OriginalClosed { get; set; }

		internal GameObject? OriginalOpen { get; set; }

		internal GameObject? OriginalVisualRoot { get; set; }

		internal Renderer[] OriginalRenderers { get; set; } = Array.Empty<Renderer>();

		internal Collider[] OriginalColliders { get; set; } = Array.Empty<Collider>();

		internal bool[] OriginalColliderEnabled { get; set; } = Array.Empty<bool>();

		internal GameObject? VisualRoot { get; set; }

		internal GameObject? CollisionRoot { get; set; }
	}
	internal static class ConfigFileMigration
	{
		internal const string CurrentFileName = "jg224.chestflow.cfg";

		internal const string LegacyFileName = "com.jg224.chestflow.cfg";

		internal static ConfigFile Open(BaseUnityPlugin plugin, string configDirectory, ManualLogSource log)
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Expected O, but got Unknown
			if (MoveLegacy(configDirectory) && log != null)
			{
				log.LogInfo((object)"Renamed legacy config com.jg224.chestflow.cfg to jg224.chestflow.cfg.");
			}
			return PluginConfigFiles.Attach(plugin, new ConfigFile(Path.Combine(configDirectory, "jg224.chestflow.cfg"), true, plugin.Info.Metadata));
		}

		internal static bool MoveLegacy(string configDirectory)
		{
			Directory.CreateDirectory(configDirectory);
			if (ExactPath(configDirectory, "jg224.chestflow.cfg") != null)
			{
				return false;
			}
			string text = ExactPath(configDirectory, "com.jg224.chestflow.cfg");
			if (text == null)
			{
				return false;
			}
			string text2 = Path.Combine(configDirectory, "jg224.chestflow.cfg");
			if (!string.Equals(text, text2, StringComparison.OrdinalIgnoreCase))
			{
				File.Move(text, text2);
				return true;
			}
			string text3 = text2 + ".rename-" + Guid.NewGuid().ToString("N") + ".tmp";
			File.Move(text, text3);
			try
			{
				File.Move(text3, text2);
			}
			catch
			{
				if (File.Exists(text3) && !File.Exists(text))
				{
					File.Move(text3, text);
				}
				throw;
			}
			return true;
		}

		private static string? ExactPath(string directory, string fileName)
		{
			return Directory.EnumerateFiles(directory, "*.cfg", SearchOption.TopDirectoryOnly).FirstOrDefault((string path) => string.Equals(Path.GetFileName(path), fileName, StringComparison.Ordinal));
		}
	}
	internal static class GearSlotsBridge
	{
		internal const int AmmoSlotX = 5;

		private static Type? _managerType;

		private static FieldInfo? _gearInventoryField;

		private static FieldInfo? _quickInventoryField;

		private static MethodInfo? _markChangedMethod;

		private static bool _resolved;

		internal static bool TryClassify(Inventory inventory, Vector2i position, out RestockInventoryKind kind)
		{
			//IL_0044: 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_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer != (Object)null && inventory == ((Humanoid)localPlayer).GetInventory())
			{
				kind = RestockInventoryKind.Player;
				return true;
			}
			Resolve();
			object? obj = _quickInventoryField?.GetValue(null);
			Inventory val = (Inventory)((obj is Inventory) ? obj : null);
			if (val != null && inventory == val)
			{
				kind = RestockInventoryKind.GearSlotsQuick;
				if (position.y == 0 && position.x >= 0)
				{
					return position.x < val.GetWidth();
				}
				return false;
			}
			object? obj2 = _gearInventoryField?.GetValue(null);
			Inventory val2 = (Inventory)((obj2 is Inventory) ? obj2 : null);
			if (val2 != null && inventory == val2 && position.y == 0 && position.x == 5)
			{
				kind = RestockInventoryKind.GearSlotsAmmo;
				return true;
			}
			kind = RestockInventoryKind.Player;
			return false;
		}

		internal static Inventory? GetInventory(Player player, RestockInventoryKind kind)
		{
			if (kind == RestockInventoryKind.Player)
			{
				return ((Humanoid)player).GetInventory();
			}
			Resolve();
			if (kind != RestockInventoryKind.GearSlotsQuick)
			{
				object? obj = _gearInventoryField?.GetValue(null);
				return (Inventory?)((obj is Inventory) ? obj : null);
			}
			object? obj2 = _quickInventoryField?.GetValue(null);
			return (Inventory?)((obj2 is Inventory) ? obj2 : null);
		}

		internal static void NotifyChanged(Inventory inventory)
		{
			Resolve();
			object? obj = _gearInventoryField?.GetValue(null);
			Inventory val = (Inventory)((obj is Inventory) ? obj : null);
			object? obj2 = _quickInventoryField?.GetValue(null);
			Inventory val2 = (Inventory)((obj2 is Inventory) ? obj2 : null);
			if (inventory != val && inventory != val2)
			{
				return;
			}
			try
			{
				_markChangedMethod?.Invoke(null, Array.Empty<object>());
			}
			catch (Exception ex)
			{
				Plugin.LogInstance.LogWarning((object)("Could not notify GearSlots about a restock change: " + ex.Message));
			}
		}

		private static void Resolve()
		{
			if (!_resolved)
			{
				_managerType = AccessTools.TypeByName("GearSlots.Runtime.SlotStateManager");
				if (!(_managerType == null))
				{
					_gearInventoryField = AccessTools.Field(_managerType, "gearInventory");
					_quickInventoryField = AccessTools.Field(_managerType, "quickInventory");
					_markChangedMethod = AccessTools.Method(_managerType, "MarkChanged", (Type[])null, (Type[])null);
					_resolved = true;
				}
			}
		}
	}
	internal static class InventoryAccess
	{
		private static readonly FieldInfo CurrentContainerField = AccessTools.Field(typeof(InventoryGui), "m_currentContainer");

		internal static Container? CurrentContainer(InventoryGui? gui)
		{
			if (!((Object)(object)gui == (Object)null))
			{
				object? value = CurrentContainerField.GetValue(gui);
				return (Container?)((value is Container) ? value : null);
			}
			return null;
		}
	}
	internal static class InventoryButtons
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static UnityAction <0>__DestroyHeldItem;

			public static UnityAction <1>__OpenRuleEditor;

			public static Action <2>__OpenRuleEditor;
		}

		private static InventoryGui? _gui;

		private static Button? _template;

		private static Button? _quickStackButton;

		private static Button? _trashButton;

		private static Button? _sortButton;

		private static Button? _rulesButton;

		private static Button? _reinforcedUpgradeButton;

		private static Button? _blackMetalUpgradeButton;

		private static Button? _graustenUpgradeButton;

		private static TMP_Text? _rulesLabel;

		private static UITooltip? _rulesTooltip;

		private static Container? _labelContainer;

		private static readonly FieldInfo DragItemField = AccessTools.Field(typeof(InventoryGui), "m_dragItem");

		private static readonly FieldInfo DragInventoryField = AccessTools.Field(typeof(InventoryGui), "m_dragInventory");

		private static readonly FieldInfo DragAmountField = AccessTools.Field(typeof(InventoryGui), "m_dragAmount");

		private static readonly MethodInfo SetupDragItemMethod = AccessTools.Method(typeof(InventoryGui), "SetupDragItem", new Type[3]
		{
			typeof(ItemData),
			typeof(Inventory),
			typeof(int)
		}, (Type[])null);

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

		internal static void Attach(InventoryGui gui)
		{
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Expected O, but got Unknown
			//IL_00ba: 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_00c1: 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_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0103: Unknown result type (might be due to invalid IL or missing references)
			//IL_010d: Expected O, but got Unknown
			//IL_01a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c2: 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)
			//IL_01ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f6: Expected O, but got Unknown
			//IL_0216: Unknown result type (might be due to invalid IL or missing references)
			//IL_021b: Unknown result type (might be due to invalid IL or missing references)
			//IL_021d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0227: Unknown result type (might be due to invalid IL or missing references)
			//IL_0229: Unknown result type (might be due to invalid IL or missing references)
			//IL_0233: Unknown result type (might be due to invalid IL or missing references)
			//IL_0235: Unknown result type (might be due to invalid IL or missing references)
			//IL_0240: Unknown result type (might be due to invalid IL or missing references)
			//IL_0158: Unknown result type (might be due to invalid IL or missing references)
			//IL_015d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0163: Expected O, but got Unknown
			//IL_02be: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c9: Expected O, but got Unknown
			Detach(gui);
			_gui = gui;
			Button val = (((Object)(object)gui.m_stackAllButton != (Object)null) ? gui.m_stackAllButton : gui.m_takeAllButton);
			if ((Object)(object)val == (Object)null)
			{
				Plugin.LogInstance.LogWarning((object)"ChestFlow could not find a vanilla inventory button to clone.");
				return;
			}
			_template = val;
			Transform val2 = (((Object)(object)gui.m_container != (Object)null && (Object)(object)((Transform)gui.m_container).parent != (Object)null) ? ((Transform)gui.m_container).parent : ((Component)val).transform.parent);
			Transform parent = GetPlayerSideParent(gui) ?? val2;
			RectTransform val3 = (RectTransform)((Component)val).transform;
			_quickStackButton = CloneButton(val, parent, "ChestFlow_QuickStackNearby", "Stack");
			RectTransform val4 = (RectTransform)((Component)_quickStackButton).transform;
			val4.anchorMin = val3.anchorMin;
			val4.anchorMax = val3.anchorMax;
			val4.pivot = val3.pivot;
			val4.sizeDelta = val3.sizeDelta;
			((UnityEvent)_quickStackButton.onClick).AddListener(new UnityAction(Plugin.Instance.QuickStackNearby));
			VanillaTooltip.Attach(((Component)_quickStackButton).gameObject, (Component)(object)gui, "Stack", "Deposit eligible items, then refill Replenish targets from nearby chests.");
			_trashButton = CloneButton(val, parent, "ChestFlow_Trash", "Trash");
			ButtonClickedEvent onClick = _trashButton.onClick;
			object obj = <>O.<0>__DestroyHeldItem;
			if (obj == null)
			{
				UnityAction val5 = DestroyHeldItem;
				<>O.<0>__DestroyHeldItem = val5;
				obj = (object)val5;
			}
			((UnityEvent)onClick).AddListener((UnityAction)obj);
			VanillaTooltip.Attach(((Component)_trashButton).gameObject, (Component)(object)gui, "Trash", "Permanently destroy the item stack currently held by the cursor. This cannot be undone.");
			_sortButton = CloneButton(val, val2, "ChestFlow_SortChest", "Sort Chest");
			RectTransform val6 = (RectTransform)((Component)_sortButton).transform;
			val6.anchorMin = val3.anchorMin;
			val6.anchorMax = val3.anchorMax;
			val6.pivot = val3.pivot;
			val6.sizeDelta = val3.sizeDelta;
			((UnityEvent)_sortButton.onClick).AddListener(new UnityAction(Plugin.Instance.SortOpenChest));
			_rulesButton = CloneButton(val, val2, "ChestFlow_StorageRules", "Storage\nAuto");
			RectTransform val7 = (RectTransform)((Component)_rulesButton).transform;
			val7.anchorMin = val3.anchorMin;
			val7.anchorMax = val3.anchorMax;
			val7.pivot = val3.pivot;
			val7.sizeDelta = val3.sizeDelta;
			_rulesLabel = ((Component)_rulesButton).GetComponentInChildren<TMP_Text>(true);
			if ((Object)(object)_rulesLabel != (Object)null)
			{
				_rulesLabel.fontSize = Mathf.Min(_rulesLabel.fontSize, 13f);
			}
			_rulesTooltip = VanillaTooltip.Attach(((Component)_rulesButton).gameObject, (Component)(object)gui, "Storage", "Configure what this chest accepts.\nCurrent rule: Auto");
			ButtonClickedEvent onClick2 = _rulesButton.onClick;
			object obj2 = <>O.<1>__OpenRuleEditor;
			if (obj2 == null)
			{
				UnityAction val8 = OpenRuleEditor;
				<>O.<1>__OpenRuleEditor = val8;
				obj2 = (object)val8;
			}
			((UnityEvent)onClick2).AddListener((UnityAction)obj2);
			_reinforcedUpgradeButton = CloneButton(val, val2, "ChestFlow_UpgradeReinforced", "Upgrade:\nReinforced");
			ConfigureUpgradeButton(_reinforcedUpgradeButton, val3, 1);
			_blackMetalUpgradeButton = CloneButton(val, val2, "ChestFlow_UpgradeBlackMetal", "Upgrade:\nBlack Metal");
			ConfigureUpgradeButton(_blackMetalUpgradeButton, val3, 2);
			_graustenUpgradeButton = CloneButton(val, val2, "ChestFlow_UpgradeGrausten", "Upgrade:\nGrausten");
			ConfigureUpgradeButton(_graustenUpgradeButton, val3, 3);
			UpdateVisibility();
		}

		internal static void UpdateVisibility()
		{
			if ((Object)(object)_gui == (Object)null)
			{
				return;
			}
			bool flag = ModConfig.Enabled.Value && ModConfig.ShowButtons.Value && InventoryGui.IsVisible();
			Container val = InventoryAccess.CurrentContainer(_gui);
			bool flag2 = flag && ChestUpgradeService.CanUpgradeTo(val, 1);
			bool flag3 = flag && ChestUpgradeService.CanUpgradeTo(val, 2);
			bool flag4 = flag && ChestUpgradeService.CanUpgradeTo(val, 3);
			if (flag)
			{
				UpdatePlayerSideLayout();
				UpdateChestButtonLayout(flag2, flag3, flag4);
			}
			if ((Object)(object)_quickStackButton != (Object)null)
			{
				((Component)_quickStackButton).gameObject.SetActive(flag);
			}
			if ((Object)(object)_trashButton != (Object)null)
			{
				((Component)_trashButton).gameObject.SetActive(flag);
			}
			if ((Object)(object)_sortButton != (Object)null)
			{
				((Component)_sortButton).gameObject.SetActive(flag && (Object)(object)val != (Object)null);
			}
			if ((Object)(object)_rulesButton != (Object)null)
			{
				((Component)_rulesButton).gameObject.SetActive(flag && (Object)(object)val != (Object)null);
				if ((Object)(object)val != (Object)(object)_labelContainer)
				{
					RefreshRuleLabel();
				}
			}
			if ((Object)(object)_reinforcedUpgradeButton != (Object)null)
			{
				((Component)_reinforcedUpgradeButton).gameObject.SetActive(flag2);
			}
			if ((Object)(object)_blackMetalUpgradeButton != (Object)null)
			{
				((Component)_blackMetalUpgradeButton).gameObject.SetActive(flag3);
			}
			if ((Object)(object)_graustenUpgradeButton != (Object)null)
			{
				((Component)_graustenUpgradeButton).gameObject.SetActive(flag4);
			}
		}

		internal static void RefreshRuleLabel()
		{
			if (!((Object)(object)_gui == (Object)null) && !((Object)(object)_rulesLabel == (Object)null))
			{
				Container val = (_labelContainer = InventoryAccess.CurrentContainer(_gui));
				string text = (((Object)(object)val == (Object)null) ? "Auto" : ChestRuleStore.ShortSummary(ChestRuleStore.Read(val)));
				_rulesLabel.text = "Storage\n" + text;
				string text2 = "Configure what this chest accepts.\nCurrent rule: " + text;
				if ((Object)(object)_rulesTooltip == (Object)null && (Object)(object)_rulesButton != (Object)null)
				{
					_rulesTooltip = VanillaTooltip.Attach(((Component)_rulesButton).gameObject, (Component)(object)_gui, "Storage", text2);
				}
				else if ((Object)(object)_rulesTooltip != (Object)null)
				{
					_rulesTooltip.m_text = text2;
				}
			}
		}

		internal static void Detach(InventoryGui? gui = null)
		{
			if (!((Object)(object)gui != (Object)null) || !((Object)(object)_gui != (Object)null) || !((Object)(object)gui != (Object)(object)_gui))
			{
				if ((Object)(object)_quickStackButton != (Object)null)
				{
					Object.Destroy((Object)(object)((Component)_quickStackButton).gameObject);
				}
				if ((Object)(object)_trashButton != (Object)null)
				{
					Object.Destroy((Object)(object)((Component)_trashButton).gameObject);
				}
				if ((Object)(object)_sortButton != (Object)null)
				{
					Object.Destroy((Object)(object)((Component)_sortButton).gameObject);
				}
				if ((Object)(object)_rulesButton != (Object)null)
				{
					Object.Destroy((Object)(object)((Component)_rulesButton).gameObject);
				}
				if ((Object)(object)_reinforcedUpgradeButton != (Object)null)
				{
					Object.Destroy((Object)(object)((Component)_reinforcedUpgradeButton).gameObject);
				}
				if ((Object)(object)_blackMetalUpgradeButton != (Object)null)
				{
					Object.Destroy((Object)(object)((Component)_blackMetalUpgradeButton).gameObject);
				}
				if ((Object)(object)_graustenUpgradeButton != (Object)null)
				{
					Object.Destroy((Object)(object)((Component)_graustenUpgradeButton).gameObject);
				}
				ChestRuleEditor.Close(gui);
				_quickStackButton = null;
				_trashButton = null;
				_sortButton = null;
				_rulesButton = null;
				_reinforcedUpgradeButton = null;
				_blackMetalUpgradeButton = null;
				_graustenUpgradeButton = null;
				_rulesLabel = null;
				_rulesTooltip = null;
				_labelContainer = null;
				_template = null;
				_gui = null;
			}
		}

		private static void UpdateChestButtonLayout(bool includeReinforced, bool includeBlackMetal, bool includeGrausten)
		{
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Expected O, but got Unknown
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: 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_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: 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_011c: Expected O, but got Unknown
			//IL_0127: Unknown result type (might be due to invalid IL or missing references)
			//IL_0131: Expected O, but got Unknown
			//IL_0140: Unknown result type (might be due to invalid IL or missing references)
			//IL_014a: Expected O, but got Unknown
			//IL_0158: Unknown result type (might be due to invalid IL or missing references)
			//IL_0162: Expected O, but got Unknown
			//IL_0189: Unknown result type (might be due to invalid IL or missing references)
			//IL_01aa: 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_01b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0170: Unknown result type (might be due to invalid IL or missing references)
			//IL_017a: Expected O, but got Unknown
			//IL_01dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0205: Unknown result type (might be due to invalid IL or missing references)
			//IL_0211: Unknown result type (might be due to invalid IL or missing references)
			//IL_021e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0234: Unknown result type (might be due to invalid IL or missing references)
			//IL_023e: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)_gui == (Object)null) && !((Object)(object)_sortButton == (Object)null) && !((Object)(object)_rulesButton == (Object)null) && !((Object)(object)_reinforcedUpgradeButton == (Object)null) && !((Object)(object)_blackMetalUpgradeButton == (Object)null) && !((Object)(object)_graustenUpgradeButton == (Object)null) && !((Object)(object)_template == (Object)null) && !((Object)(object)_gui.m_container == (Object)null))
			{
				RectTransform val = (RectTransform)((Component)_template).transform;
				Rect rect = val.rect;
				float num;
				if (!(((Rect)(ref rect)).width > 0f))
				{
					num = Mathf.Max(120f, val.sizeDelta.x);
				}
				else
				{
					rect = val.rect;
					num = ((Rect)(ref rect)).width;
				}
				float num2 = Mathf.Min(145f, num);
				rect = val.rect;
				float num3;
				if (!(((Rect)(ref rect)).height > 0f))
				{
					num3 = Mathf.Max(34f, val.sizeDelta.y);
				}
				else
				{
					rect = val.rect;
					num3 = ((Rect)(ref rect)).height;
				}
				float num4 = num3;
				List<RectTransform> list = new List<RectTransform>
				{
					(RectTransform)((Component)_rulesButton).transform,
					(RectTransform)((Component)_sortButton).transform
				};
				if (includeReinforced)
				{
					list.Add((RectTransform)((Component)_reinforcedUpgradeButton).transform);
				}
				if (includeBlackMetal)
				{
					list.Add((RectTransform)((Component)_blackMetalUpgradeButton).transform);
				}
				if (includeGrausten)
				{
					list.Add((RectTransform)((Component)_graustenUpgradeButton).transform);
				}
				RectTransform val2 = (RectTransform)((Component)_rulesButton).transform.parent;
				Vector3[] array = (Vector3[])(object)new Vector3[4];
				_gui.m_container.GetWorldCorners(array);
				Vector3 val3 = ((Transform)val2).InverseTransformPoint(array[2]);
				Vector2 val5 = default(Vector2);
				for (int i = 0; i < list.Count; i++)
				{
					RectTransform val4 = list[i];
					((Vector2)(ref val5))..ctor(0.5f, 0.5f);
					val4.anchorMax = val5;
					val4.anchorMin = val5;
					val4.pivot = new Vector2(0f, 1f);
					val4.sizeDelta = new Vector2(num2, num4);
					((Transform)val4).localPosition = new Vector3(val3.x + 8f, ChestToolbarLayout.TopForButton(val3.y, i, num4, 8f), ((Transform)val4).localPosition.z);
				}
			}
		}

		private static void UpdatePlayerSideLayout()
		{
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Expected O, but got Unknown
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Expected O, but got Unknown
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: 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_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_012c: 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_0142: 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_0155: Unknown result type (might be due to invalid IL or missing references)
			//IL_015a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0172: Unknown result type (might be due to invalid IL or missing references)
			//IL_0177: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0204: Unknown result type (might be due to invalid IL or missing references)
			//IL_0223: Unknown result type (might be due to invalid IL or missing references)
			//IL_022a: Unknown result type (might be due to invalid IL or missing references)
			//IL_023d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0257: Unknown result type (might be due to invalid IL or missing references)
			//IL_0273: Unknown result type (might be due to invalid IL or missing references)
			//IL_027d: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_gui == (Object)null || (Object)(object)_quickStackButton == (Object)null || (Object)(object)_trashButton == (Object)null || !TryGetWeightPanel(_gui, out RectTransform weightPanel) || !TryGetArmorPanel(_gui, out RectTransform armorPanel))
			{
				return;
			}
			Transform parent = ((Transform)weightPanel).parent;
			RectTransform val = (RectTransform)(object)((parent is RectTransform) ? parent : null);
			if (val != null)
			{
				RectTransform val2 = (RectTransform)((Component)_quickStackButton).transform;
				RectTransform val3 = (RectTransform)((Component)_trashButton).transform;
				if ((Object)(object)((Transform)val2).parent != (Object)(object)val)
				{
					((Transform)val2).SetParent((Transform)(object)val, false);
				}
				if ((Object)(object)((Transform)val3).parent != (Object)(object)val)
				{
					((Transform)val3).SetParent((Transform)(object)val, false);
				}
				weightPanel.GetWorldCorners(UiCorners);
				Vector3 val4 = ((Transform)val).InverseTransformPoint(UiCorners[0]);
				Vector3 val5 = ((Transform)val).InverseTransformPoint(UiCorners[2]);
				armorPanel.GetWorldCorners(UiCorners);
				float y = ((Transform)val).InverseTransformPoint(UiCorners[0]).y;
				Transform obj = ((Transform)_gui.m_player).Find("Bkg");
				((RectTransform)(((object)((obj is RectTransform) ? obj : null)) ?? ((object)_gui.m_player))).GetWorldCorners(UiCorners);
				float y2 = ((Transform)val).InverseTransformPoint(UiCorners[0]).y;
				float x = val4.x;
				float x2 = val5.x;
				float y3 = val5.y;
				Rect rect = val2.rect;
				float preferredStackHeight;
				if (!(((Rect)(ref rect)).height > 0f))
				{
					preferredStackHeight = 38f;
				}
				else
				{
					rect = val2.rect;
					preferredStackHeight = ((Rect)(ref rect)).height;
				}
				PlayerSideControlPlacement playerSideControlPlacement = PlayerSideControlLayout.Calculate(x, x2, y3, y, y2, preferredStackHeight, 6f, 18f, ModConfig.PlayerSideControlsOffsetX.Value);
				Vector2 val6 = default(Vector2);
				((Vector2)(ref val6))..ctor(0.5f, 0.5f);
				val2.anchorMax = val6;
				val2.anchorMin = val6;
				val2.pivot = new Vector2(0.5f, 0f);
				val2.sizeDelta = new Vector2(playerSideControlPlacement.Width, playerSideControlPlacement.StackHeight);
				((Transform)val2).localPosition = new Vector3(playerSideControlPlacement.CenterX, playerSideControlPlacement.StackBottomY, ((Transform)val2).localPosition.z);
				((Vector2)(ref val6))..ctor(0.5f, 0.5f);
				val3.anchorMax = val6;
				val3.anchorMin = val6;
				val3.pivot = new Vector2(0.5f, 0f);
				val3.sizeDelta = new Vector2(playerSideControlPlacement.Width, playerSideControlPlacement.TrashHeight);
				((Transform)val3).localPosition = new Vector3(playerSideControlPlacement.CenterX, playerSideControlPlacement.TrashBottomY, ((Transform)val3).localPosition.z);
				((Transform)val2).SetAsFirstSibling();
				((Transform)val3).SetAsFirstSibling();
			}
		}

		private static Transform? GetPlayerSideParent(InventoryGui gui)
		{
			if (!TryGetWeightPanel(gui, out RectTransform weightPanel))
			{
				return null;
			}
			return ((Transform)weightPanel).parent;
		}

		private static bool TryGetWeightPanel(InventoryGui gui, out RectTransform weightPanel)
		{
			weightPanel = null;
			if ((Object)(object)gui.m_weight == (Object)null)
			{
				return false;
			}
			RectTransform rectTransform = gui.m_weight.rectTransform;
			Transform parent = ((Transform)rectTransform).parent;
			weightPanel = (RectTransform)(((object)((parent is RectTransform) ? parent : null)) ?? ((object)rectTransform));
			return ((Transform)weightPanel).parent is RectTransform;
		}

		private static bool TryGetArmorPanel(InventoryGui gui, out RectTransform armorPanel)
		{
			armorPanel = null;
			if ((Object)(object)gui.m_armor == (Object)null)
			{
				return false;
			}
			RectTransform rectTransform = gui.m_armor.rectTransform;
			Transform parent = ((Transform)rectTransform).parent;
			armorPanel = (RectTransform)(((object)((parent is RectTransform) ? parent : null)) ?? ((object)rectTransform));
			return ((Transform)armorPanel).parent is RectTransform;
		}

		private static void DestroyHeldItem()
		{
			if (!Plugin.IsActive || (Object)(object)_gui == (Object)null || (Object)(object)Player.m_localPlayer == (Object)null)
			{
				return;
			}
			object? value = DragItemField.GetValue(_gui);
			ItemData val = (ItemData)((value is ItemData) ? value : null);
			object? value2 = DragInventoryField.GetValue(_gui);
			Inventory val2 = (Inventory)((value2 is Inventory) ? value2 : null);
			int num = ((DragAmountField.GetValue(_gui) is int num2) ? num2 : 0);
			if (val == null || val2 == null || num <= 0)
			{
				((Character)Player.m_localPlayer).Message((MessageType)2, "Hold an item over Trash first.", 0, (Sprite)null, false);
				return;
			}
			if (!val2.ContainsItem(val))
			{
				SetupDragItemMethod.Invoke(_gui, new object[3] { null, null, 1 });
				return;
			}
			int destroyAmount = TrashOperationPlanner.GetDestroyAmount(val.m_stack, num, val.m_shared.m_questItem);
			if (val.m_shared.m_questItem)
			{
				((Character)Player.m_localPlayer).Message((MessageType)2, "Quest items cannot be destroyed.", 0, (Sprite)null, false);
			}
			else if (destroyAmount > 0)
			{
				((Humanoid)Player.m_localPlayer).RemoveEquipAction(val);
				((Humanoid)Player.m_localPlayer).UnequipItem(val, false);
				if (!val2.RemoveItem(val, destroyAmount))
				{
					((Character)Player.m_localPlayer).Message((MessageType)2, "The item could not be destroyed safely.", 0, (Sprite)null, false);
					return;
				}
				GearSlotsBridge.NotifyChanged(val2);
				SetupDragItemMethod.Invoke(_gui, new object[3] { null, null, 1 });
				((Character)Player.m_localPlayer).Message((MessageType)2, $"Destroyed {destroyAmount} × {Localization.instance.Localize(val.m_shared.m_name)}.", 0, (Sprite)null, false);
			}
		}

		private static void ConfigureUpgradeButton(Button button, RectTransform template, int targetTier)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: 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_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Expected O, but got Unknown
			RectTransform val = (RectTransform)((Component)button).transform;
			val.anchorMin = template.anchorMin;
			val.anchorMax = template.anchorMax;
			val.pivot = template.pivot;
			val.sizeDelta = template.sizeDelta;
			TMP_Text componentInChildren = ((Component)button).GetComponentInChildren<TMP_Text>(true);
			if ((Object)(object)componentInChildren != (Object)null)
			{
				componentInChildren.fontSize = Mathf.Min(componentInChildren.fontSize, 13f);
			}
			((UnityEvent)button.onClick).AddListener((UnityAction)delegate
			{
				Plugin.Instance.UpgradeOpenChest(targetTier);
			});
		}

		private static void OpenRuleEditor()
		{
			if (Plugin.IsActive && !((Object)(object)_gui == (Object)null))
			{
				Container val = InventoryAccess.CurrentContainer(_gui);
				if (!((Object)(object)val == (Object)null) && !MultiUserContainerService.TryDeferUntilOwned(val, OpenRuleEditor))
				{
					ChestRuleEditor.Open(_gui, val);
				}
			}
		}

		private static Button CloneButton(Button template, Transform parent, string name, string label)
		{
			GameObject val = Object.Instantiate<GameObject>(((Component)template).gameObject, parent, false);
			((Object)val).name = name;
			Button component = val.GetComponent<Button>();
			((UnityEventBase)component.onClick).RemoveAllListeners();
			Localize[] componentsInChildren = val.GetComponentsInChildren<Localize>(true);
			for (int i = 0; i < componentsInChildren.Length; i++)
			{
				((Behaviour)componentsInChildren[i]).enabled = false;
			}
			TMP_Text componentInChildren = val.GetComponentInChildren<TMP_Text>(true);
			if ((Object)(object)componentInChildren != (Object)null)
			{
				componentInChildren.text = label;
				componentInChildren.fontSize = Mathf.Min(componentInChildren.fontSize, 16f);
			}
			val.SetActive(true);
			return component;
		}
	}
	internal static class InventorySorter
	{
		internal static int Sort(Inventory inventory, SortMode mode, bool descending)
		{
			//IL_010f: 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 (inventory == null)
			{
				throw new ArgumentNullException("inventory");
			}
			List<ItemData> list = new List<ItemData>(inventory.GetAllItems());
			List<SortableItem> list2 = new List<SortableItem>(list.Count);
			for (int i = 0; i < list.Count; i++)
			{
				ItemData val = list[i];
				string text = val.m_shared.m_name ?? string.Empty;
				string localizedName = ((Localization.instance != null) ? Localization.instance.Localize(text) : text);
				list2.Add(new SortableItem
				{
					OriginalIndex = i,
					Category = ItemCategoryCatalog.SortRank(ValheimItemCategoryClassifier.Classify(val)),
					InternalName = text,
					LocalizedName = localizedName,
					Weight = val.GetNonStackedWeight(),
					Value = val.GetValue(),
					Quality = val.m_quality,
					Stack = val.m_stack
				});
			}
			IReadOnlyList<int> readOnlyList = InventoryOrdering.OrderIndices(list2, mode, descending);
			int width = inventory.GetWidth();
			for (int j = 0; j < readOnlyList.Count; j++)
			{
				list[readOnlyList[j]].m_gridPos = new Vector2i(j % width, j / width);
			}
			inventory.m_onChanged?.Invoke();
			return list.Count;
		}
	}
	internal static class ItemInteractionModeService
	{
		internal static bool TryCycle(InventoryGrid grid, ItemData? item)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			if (!ModConfig.Enabled.Value || item == null || !IsAltPressed())
			{
				return false;
			}
			Inventory inventory = grid.GetInventory();
			if (inventory == null || !GearSlotsBridge.TryClassify(inventory, item.m_gridPos, out var _))
			{
				return false;
			}
			bool num = RestockProfileService.IsTarget(item);
			bool flag = ItemLockService.IsLocked(item);
			int current = (num ? 2 : (flag ? 1 : 0));
			bool canReplenish = item.m_shared.m_maxStackSize > 1 && !string.IsNullOrWhiteSpace(ValheimItemCategoryClassifier.PrefabName(item));
			ItemInteractionMode itemInteractionMode = ItemInteractionModeCycle.Next((ItemInteractionMode)current, canReplenish);
			if (flag)
			{
				ItemLockService.TrySet(grid, item, locked: false);
			}
			if (num)
			{
				RestockProfileService.TrySet(grid, item, enabled: false);
			}
			switch (itemInteractionMode)
			{
			case ItemInteractionMode.Locked:
				ItemLockService.TrySet(grid, item, locked: true);
				break;
			case ItemInteractionMode.Replenish:
				RestockProfileService.TrySet(grid, item, enabled: true);
				break;
			}
			ItemLockService.RefreshHighlights(grid);
			RestockProfileService.RefreshHighlights(grid);
			Player localPlayer = Player.m_localPlayer;
			if (localPlayer != null)
			{
				((Character)localPlayer).Message((MessageType)2, itemInteractionMode switch
				{
					ItemInteractionMode.Locked => "Item mode: Locked", 
					ItemInteractionMode.Nothing => "Item mode: Nothing", 
					_ => $"Item mode: Replenish (target: {item.m_shared.m_maxStackSize})", 
				}, 0, (Sprite)null, false);
			}
			return true;
		}

		private static bool IsAltPressed()
		{
			if (!Input.GetKey((KeyCode)308))
			{
				return Input.GetKey((KeyCode)307);
			}
			return true;
		}
	}
	internal static class ItemLockService
	{
		private const string HighlightName = "ChestFlow_StackLockHighlight";

		private static readonly FieldInfo ElementsField = AccessTools.Field(typeof(InventoryGrid), "m_elements");

		internal static bool IsLocked(ItemData? item)
		{
			if (item != null)
			{
				return ItemStackLock.IsLocked(item.m_customData);
			}
			return false;
		}

		internal static bool TrySet(InventoryGrid grid, ItemData? item, bool locked)
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			if (!ModConfig.Enabled.Value || item == null)
			{
				return false;
			}
			Inventory inventory = grid.GetInventory();
			if (inventory == null || !GearSlotsBridge.TryClassify(inventory, item.m_gridPos, out var _))
			{
				return false;
			}
			ItemStackLock.SetLocked(item.m_customData, locked);
			inventory.m_onChanged?.Invoke();
			GearSlotsBridge.NotifyChanged(inventory);
			RefreshHighlights(grid);
			return true;
		}

		internal static void RefreshHighlights(InventoryGrid grid)
		{
			//IL_0041: 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_0054: 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_006b: Unknown result type (might be due to invalid IL or missing references)
			Inventory inventory = grid.GetInventory();
			if (inventory == null || !(ElementsField.GetValue(grid) is IList list))
			{
				return;
			}
			foreach (object item in list)
			{
				InventoryElement val = (InventoryElement)((item is InventoryElement) ? item : null);
				if (val != null && Object.op_Implicit((Object)(object)val))
				{
					Vector2i position = val.Position;
					GetOrCreateHighlight(((Component)val).gameObject).SetActive(GearSlotsBridge.TryClassify(inventory, position, out var _) && IsLocked(inventory.GetItemAt(position.x, position.y)));
				}
			}
		}

		internal static List<ItemData> HideLockedItems(Inventory inventory)
		{
			List<ItemData> allItems = inventory.GetAllItems();
			List<ItemData> list = allItems.FindAll(IsLocked);
			foreach (ItemData item in list)
			{
				allItems.Remove(item);
			}
			return list;
		}

		internal static void RestoreHiddenItems(Inventory inventory, IEnumerable<ItemData> hidden)
		{
			List<ItemData> allItems = inventory.GetAllItems();
			bool flag = false;
			foreach (ItemData item in hidden)
			{
				if (!allItems.Contains(item))
				{
					allItems.Add(item);
					flag = true;
				}
			}
			if (flag)
			{
				inventory.m_onChanged?.Invoke();
			}
		}

		private static GameObject GetOrCreateHighlight(GameObject slot)
		{
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: 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_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: 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_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0128: 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_0154: Unknown result type (might be due to invalid IL or missing references)
			//IL_0169: Unknown result type (might be due to invalid IL or missing references)
			//IL_017a: Expected O, but got Unknown
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			Transform val = slot.transform.Find("ChestFlow_StackLockHighlight");
			if ((Object)(object)val != (Object)null)
			{
				return ((Component)val).gameObject;
			}
			GameObject val2 = new GameObject("ChestFlow_StackLockHighlight", new Type[4]
			{
				typeof(RectTransform),
				typeof(CanvasRenderer),
				typeof(Image),
				typeof(Outline)
			})
			{
				layer = slot.layer
			};
			val2.transform.SetParent(slot.transform, false);
			val2.transform.SetAsFirstSibling();
			RectTransform val3 = (RectTransform)val2.transform;
			val3.anchorMin = Vector2.zero;
			val3.anchorMax = Vector2.one;
			val3.offsetMin = new Vector2(2f, 2f);
			val3.offsetMax = new Vector2(-2f, -2f);
			Image component = val2.GetComponent<Image>();
			Image component2 = slot.GetComponent<Image>();
			if ((Object)(object)component2 != (Object)null)
			{
				component.sprite = component2.sprite;
				component.type = component2.type;
				((Graphic)component).material = ((Graphic)component2).material;
			}
			((Graphic)component).color = new Color(1f, 0.58f, 0.08f, 0.28f);
			((Graphic)component).raycastTarget = false;
			Outline component3 = val2.GetComponent<Outline>();
			((Shadow)component3).effectColor = new Color(1f, 0.68f, 0.12f, 0.95f);
			((Shadow)component3).effectDistance = new Vector2(2f, -2f);
			((Shadow)component3).useGraphicAlpha = false;
			return val2;
		}
	}
	internal static class KilnWoodService
	{
		internal static bool IsCharcoalKiln(Smelter smelter)
		{
			return smelter.m_conversion.Any((ItemConversion conversion) => conversion?.m_from?.m_itemData?.m_shared != null && conversion.m_to?.m_itemData?.m_shared != null && conversion.m_from.m_itemData.m_shared.m_name == "$item_wood" && conversion.m_to.m_itemData.m_shared.m_name == "$item_coal");
		}

		internal static IReadOnlyList<string> AllowedPriority()
		{
			return KilnWoodPolicy.AllowedPriority(ModConfig.KilnAllowCoreWood.Value, ModConfig.KilnAllowFineWood.Value);
		}
	}
	internal static class ModConfig
	{
		internal static ConfigEntry<bool> Enabled { get; private set; }

		internal static ConfigEntry<KeyboardShortcut> QuickStackShortcut { get; private set; }

		internal static ConfigEntry<KeyboardShortcut> SortChestShortcut { get; private set; }

		internal static ConfigEntry<float> NearbyRange { get; private set; }

		internal static ConfigEntry<float> RequestSpacing { get; private set; }

		internal static ConfigEntry<bool> ProtectHotbar { get; private set; }

		internal static ConfigEntry<bool> SkipCustomData { get; private set; }

		internal static ConfigEntry<bool> IncludeVehicleContainers { get; private set; }

		internal static ConfigEntry<bool> IncludeWorldContainers { get; private set; }

		internal static ConfigEntry<StorageMatchMode> StorageMatchMode { get; private set; }

		internal static ConfigEntry<SortMode> ChestSortMode { get; private set; }

		internal static ConfigEntry<bool> SortDescending { get; private set; }

		internal static ConfigEntry<bool> ShowButtons { get; private set; }

		internal static ConfigEntry<float> PlayerSideControlsOffsetX { get; private set; }

		internal static ConfigEntry<bool> ShowTransferFlights { get; private set; }

		internal static ConfigEntry<int> MaxFlightsPerItem { get; private set; }

		internal static ConfigEntry<float> FlightDuration { get; private set; }

		internal static ConfigEntry<float> FlightArcHeight { get; private set; }

		internal static ConfigEntry<string> SignTextColor { get; private set; }

		internal static ConfigEntry<float> RuleEditorScrollSensitivity { get; private set; }

		internal static ConfigEntry<bool> CraftFromNearbyChests { get; private set; }

		internal static ConfigEntry<float> SharedResourceRange { get; private set; }

		internal static ConfigEntry<bool> AllowConcurrentChestUse { get; private set; }

		internal static ConfigEntry<bool> AutoFeedEnabled { get; private set; }

		internal static ConfigEntry<float> AutoFeedRange { get; private set; }

		internal static ConfigEntry<float> AutoFeedInterval { get; private set; }

		internal static ConfigEntry<string> AutoFeedContainerPrefix { get; private set; }

		internal static ConfigEntry<bool> KilnAllowCoreWood { get; private set; }

		internal static ConfigEntry<bool> KilnAllowFineWood { get; private set; }

		internal static void Bind(ConfigFile config)
		{
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Expected O, but got Unknown
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f2: Expected O, but got Unknown
			//IL_0220: Unknown result type (might be due to invalid IL or missing references)
			//IL_022a: Expected O, but got Unknown
			//IL_0267: Unknown result type (might be due to invalid IL or missing references)
			//IL_0271: Expected O, but got Unknown
			//IL_029f: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a9: Expected O, but got Unknown
			//IL_02d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e1: Expected O, but got Unknown
			//IL_0349: Unknown result type (might be due to invalid IL or missing references)
			//IL_0353: Expected O, but got Unknown
			//IL_03b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c1: Expected O, but got Unknown
			//IL_03ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f9: Expected O, but got Unknown
			//IL_047c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0486: Expected O, but got Unknown
			ConfigEntry<int> val = config.Bind<int>("Internal", "DefaultsMigrationVersion", 0, "Tracks one-time default migrations. Do not edit manually.");
			Enabled = config.Bind<bool>("General", "Enabled", true, "Master switch for ChestFlow.");
			QuickStackShortcut = config.Bind<KeyboardShortcut>("Input", "QuickStackNearby", new KeyboardShortcut((KeyCode)96, Array.Empty<KeyCode>()), "Quick-stack eligible player items into nearby chests that already contain that item type.");
			SortChestShortcut = config.Bind<KeyboardShortcut>("Input", "SortOpenChest", new KeyboardShortcut((KeyCode)115, (KeyCode[])(object)new KeyCode[1] { (KeyCode)308 }), "Sort the currently open chest.");
			NearbyRange = config.Bind<float>("Quick Stack", "NearbyRange", 20f, new ConfigDescription("Maximum quick-stack radius in metres.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(2f, 50f), Array.Empty<object>()));
			RequestSpacing = config.Bind<float>("Quick Stack", "RequestSpacing", 0.06f, new ConfigDescription("Delay between vanilla container ownership requests.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 0.5f), Array.Empty<object>()));
			ProtectHotbar = config.Bind<bool>("Quick Stack", "ProtectHotbar", true, "Never move items currently placed in the first player-inventory row.");
			SkipCustomData = config.Bind<bool>("Quick Stack", "SkipCustomData", true, "Skip items with custom data to avoid merging modded item state into an incompatible stack.");
			IncludeVehicleContainers = config.Bind<bool>("Quick Stack", "IncludeVehicleContainers", true, "Include player-built cart and ship containers. Enabled by default; normal range, access, and in-use checks still apply.");
			IncludeWorldContainers = config.Bind<bool>("Quick Stack", "IncludeWorldContainers", false, "Include loot chests and other physical containers not placed by a player.");
			StorageMatchMode = config.Bind<StorageMatchMode>("Quick Stack", "StorageMatchMode", ChestFlow.Core.StorageMatchMode.ExactItemOnly, "ExactItemOnly is the default and stores only exact items already present in an Auto chest. ExactItemOrCategory also treats every stored item as a seed for its detailed category.");
			if (val.Value < 1)
			{
				if (StorageMatchMode.Value == ChestFlow.Core.StorageMatchMode.ExactItemOrCategory)
				{
					StorageMatchMode.Value = ChestFlow.Core.StorageMatchMode.ExactItemOnly;
				}
				val.Value = 1;
			}
			ChestSortMode = config.Bind<SortMode>("Sorting", "ChestSortMode", SortMode.Category, "Primary criterion used by the chest sort button and shortcut.");
			SortDescending = config.Bind<bool>("Sorting", "SortDescending", false, "Reverse the configured primary sort criterion.");
			ShowButtons = config.Bind<bool>("Interface", "ShowButtons", true, "Add Trash, Stack, Sort Chest, Storage, and unlocked chest-tier Upgrade buttons to the inventory interface.");
			PlayerSideControlsOffsetX = config.Bind<float>("Interface", "PlayerSideControlsOffsetX", 12f, new ConfigDescription("Horizontal offset in Valheim UI canvas units for the Trash and Stack rail beside the vanilla player inventory.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(-100f, 100f), Array.Empty<object>()));
			ShowTransferFlights = config.Bind<bool>("Interface", "ShowTransferFlights", true, "Animate representative item icons from the player to each chest after the server-authorized transfer completes.");
			MaxFlightsPerItem = config.Bind<int>("Interface", "MaxFlightsPerItem", 3, new ConfigDescription("Maximum animated icons per transferred item type.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(1, 8), Array.Empty<object>()));
			FlightDuration = config.Bind<float>("Interface", "FlightDuration", 1.75f, new ConfigDescription("Seconds each item-flight animation lasts.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.1f, 4f), Array.Empty<object>()));
			FlightArcHeight = config.Bind<float>("Interface", "FlightArcHeight", 2.5f, new ConfigDescription("Height in metres of the item-flight arc.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 5f), Array.Empty<object>()));
			SignTextColor = config.Bind<string>("Interface", "SignTextColor", "white", "Default Valheim sign-text color. Accepts names such as white, yellow, red, orange, blue, green, purple, pink, cyan, gold, gray, lime, or teal, and hex values such as #4FC3F7. Use vanilla or none to disable automatic coloring. Existing custom color tags are preserved.");
			CraftFromNearbyChests = config.Bind<bool>("Shared Resources", "CraftFromNearbyChests", true, "Use eligible nearby chests for crafting, building, and manually filling torches, fires, kilns, furnaces, cooking stations, fermenters, and other supported production structures.");
			SharedResourceRange = config.Bind<float>("Shared Resources", "Range", 30f, new ConfigDescription("Maximum shared chest-resource range in metres for crafting, building, and operated production structures.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(2f, 100f), Array.Empty<object>()));
			AllowConcurrentChestUse = config.Bind<bool>("Multiplayer", "AllowConcurrentChestUse", true, "Allow players running the same ChestFlow version to use one stationary chest concurrently. ChestFlow serializes mutations by transferring authoritative chest control between users.");
			AutoFeedEnabled = config.Bind<bool>("Auto Feed", "Enabled", true, "Automatically feed hungry tameable creatures from eligible nearby chests on the peer that owns the creature.");
			AutoFeedRange = config.Bind<float>("Auto Feed", "Range", 25f, new ConfigDescription("Maximum distance in metres between a hungry creature and a feed chest.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(2f, 50f), Array.Empty<object>()));
			AutoFeedInterval = config.Bind<float>("Auto Feed", "ScanInterval", 5f, new ConfigDescription("Minimum seconds between nearby-chest scans for each hungry creature.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(1f, 60f), Array.Empty<object>()));
			AutoFeedContainerPrefix = config.Bind<string>("Auto Feed", "ContainerNamePrefix", "piece_chest", "Only use container prefab names beginning with this value. Leave empty to allow every otherwise eligible player-built container.");
			KilnAllowCoreWood = config.Bind<bool>("Production", "KilnAllowCoreWood", false, "Allow kilns to pull Core Wood from nearby chests after normal Wood. Does not restrict wood carried by the player.");
			KilnAllowFineWood = config.Bind<bool>("Production", "KilnAllowFineWood", false, "Allow kilns to pull Fine Wood from nearby chests after normal Wood and enabled Core Wood. Does not restrict wood carried by the player.");
			RuleEditorScrollSensitivity = config.Bind<float>("Interface", "RuleEditorScrollSensitivity", 210f, new ConfigDescription("Mouse-wheel scroll speed in the chest rule editor. 210 is 750% of the original speed.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(28f, 560f), Array.Empty<object>()));
			if (val.Value < 2)
			{
				if (Mathf.Abs(RuleEditorScrollSensitivity.Value - 140f) < 0.001f)
				{
					RuleEditorScrollSensitivity.Value = 210f;
				}
				val.Value = 2;
			}
			if (val.Value < 3)
			{
				if (Mathf.Abs(FlightDuration.Value - 1.1f) < 0.001f || Mathf.Abs(FlightDuration.Value - 0.55f) < 0.001f)
				{
					FlightDuration.Value = 0.275f;
				}
				val.Value = 3;
			}
			if (val.Value < 4)
			{
				if (!IncludeVehicleContainers.Value)
				{
					IncludeVehicleContainers.Value = true;
				}
				val.Value = 4;
			}
			if (val.Value < 5)
			{
				if (Mathf.Abs(FlightDuration.Value - 0.275f) < 0.001f)
				{
					FlightDuration.Value = 1f;
				}
				val.Value = 5;
			}
		}
	}
	internal static class MultiUserContainerService
	{
		private sealed class PendingAction
		{
			internal Container Container { get; }

			internal int ContainerId { get; }

			internal Action Action { get; }

			internal long ExpectedOwner { get; }

			internal bool ResponseAccepted { get; set; }

			internal float Deadline { get; }

			internal PendingAction(Container container, Action action, long expectedOwner, float deadline)
			{
				Container = container;
				ContainerId = ((Object)container).GetInstanceID();
				Action = action;
				ExpectedOwner = expectedOwner;
				Deadline = deadline;
			}
		}

		internal const string HelloRpc = "ChestFlow_MultiUserHello";

		internal const string RequestControlRpc = "ChestFlow_RequestContainerControl";

		internal const string ControlResponseRpc = "ChestFlow_ContainerControlResponse";

		private const float RequestTimeout = 3f;

		private const float HelloInterval = 10f;

		private static readonly FieldInfo ContainerNetViewField = AccessTools.Field(typeof(Container), "m_nview");

		private static readonly FieldInfo ContainerInUseField = AccessTools.Field(typeof(Container), "m_inUse");

		private static readonly MethodInfo CheckAccessMethod = AccessTools.Method(typeof(Container), "CheckAccess", (Type[])null, (Type[])null);

		private static readonly MethodInfo UpdateUseVisualMethod = AccessTools.Method(typeof(Container), "UpdateUseVisual", (Type[])null, (Type[])null);

		private static readonly MethodInfo SaveMethod = AccessTools.Method(typeof(Container), "Save", (Type[])null, (Type[])null);

		private static readonly MethodInfo LoadMethod = AccessTools.Method(typeof(Container), "Load", (Type[])null, (Type[])null);

		private static readonly Dictionary<int, PendingAction> Pending = new Dictionary<int, PendingAction>();

		private static readonly HashSet<long> CompatiblePeers = new HashSet<long>();

		private static ZRoutedRpc? _registeredRpc;

		private static float _nextHelloAt;

		private static bool _replaying;

		internal static bool IsReplaying => _replaying;

		internal static void Attach(Container container)
		{
			if ((Object)(object)container == (Object)null)
			{
				return;
			}
			ZNetView netView = GetNetView(container);
			if (!((Object)(object)netView == (Object)null) && netView.IsValid())
			{
				netView.Register<long>("ChestFlow_RequestContainerControl", (Action<long, long>)delegate(long sender, long playerId)
				{
					HandleControlRequest(container, sender, playerId);
				});
				netView.Register<bool>("ChestFlow_ContainerControlResponse", (Action<long, bool>)delegate(long sender, bool granted)
				{
					HandleControlResponse(container, sender, granted);
				});
				AutoFeedService.Attach(container);
			}
		}

		internal static void Update()
		{
			EnsureNetworkRegistration();
			if (_registeredRpc != null && Time.realtimeSinceStartup >= _nextHelloAt)
			{
				_nextHelloAt = Time.realtimeSinceStartup + 10f;
				_registeredRpc.InvokeRoutedRPC(0L, "ChestFlow_MultiUserHello", new object[1] { "0.5.2" });
			}
			if (Pending.Count == 0)
			{
				return;
			}
			float realtimeSinceStartup = Time.realtimeSinceStartup;
			PendingAction[] array = Pending.Values.ToArray();
			foreach (PendingAction pendingAction in array)
			{
				if ((Object)(object)pendingAction.Container == (Object)null || realtimeSinceStartup >= pendingAction.Deadline)
				{
					Pending.Remove(pendingAction.ContainerId);
					TellPlayer("Could not acquire shared chest control. Try again.");
				}
			}
		}

		internal static void Reset()
		{
			Pending.Clear();
			CompatiblePeers.Clear();
			_registeredRpc = null;
			_nextHelloAt = 0f;
			_replaying = false;
		}

		internal static bool TryHandleBusyOpen(Container container, long sender, long playerId)
		{
			if (!ModConfig.AllowConcurrentChestUse.Value || !Supports(container) || !container.IsOwner() || !container.IsInUse() || !CompatiblePeers.Contains(sender))
			{
				return false;
			}
			if (!ChestAuthority.CanUse(container, sender, playerId))
			{
				ZNetView? netView = GetNetView(container);
				if (netView != null)
				{
					netView.InvokeRPC(sender, "RPC_OpenResponse", new object[1] { false });
				}
				return true;
			}
			return TransferOwnership(container, sender, "RPC_OpenResponse");
		}

		internal static bool TryDeferUntilOwned(Container container, Action action)
		{
			if (AutoFeedService.IsLocked(container))
			{
				TellPlayer("Auto Feed is finishing a protected chest operation. Try again shortly.");
				return true;
			}
			if (!ModConfig.AllowConcurrentChestUse.Value || !Supports(container) || container.IsOwner())
			{
				return false;
			}
			ZNetView netView = GetNetView(container);
			ZDO val = ((netView != null) ? netView.GetZDO() : null);
			if ((Object)(object)netView == (Object)null || val == null || !netView.IsValid())
			{
				return false;
			}
			long owner = val.GetOwner();
			if (owner == 0L)
			{
				netView.ClaimOwnership();
				LoadContainer(container);
				return !container.IsOwner();
			}
			int instanceID = ((Object)container).GetInstanceID();
			if (Pending.ContainsKey(instanceID))
			{
				return true;
			}
			if (!CompatiblePeers.Contains(owner))
			{
				TellPlayer("The current chest user needs the same ChestFlow version.");
				return true;
			}
			Game instance = Game.instance;
			long? obj;
			if (instance == null)
			{
				obj = null;
			}
			else
			{
				PlayerProfile playerProfile = instance.GetPlayerProfile();
				obj = ((playerProfile != null) ? new long?(playerProfile.GetPlayerID()) : ((long?)null));
			}
			long? num = obj;
			long valueOrDefault = num.GetValueOrDefault();
			Pending.Add(instanceID, new PendingAction(container, action, owner, Time.realtimeSinceStartup + 3f));
			netView.InvokeRPC(owner, "ChestFlow_RequestContainerControl", new object[1] { valueOrDefault });
			return true;
		}

		internal static bool SetLocalUseState(Container container, bool inUse)
		{
			if (!ModConfig.AllowConcurrentChestUse.Value || !Supports(container) || container.IsOwner())
			{
				return false;
			}
			ContainerInUseField.SetValue(container, inUse);
			UpdateUseVisualMethod.Invoke(container, Array.Empty<object>());
			return true;
		}

		internal static bool Supports(Container container)
		{
			if ((Object)(object)container == (Object)null || !((Behaviour)container).isActiveAndEnabled)
			{
				return false;
			}
			if (AutoFeedService.IsLocked(container))
			{
				return false;
			}
			if ((Object)(object)container.m_wagon != (Object)null || (Object)(object)((Component)container).GetComponentInParent<Ship>() != (Object)null)
			{
				return false;
			}
			if ((Object)(object)((Component)container).GetComponent<Player>() != (Object)null || (Object)(object)((Component)container).GetComponent<TombStone>() != (Object)null)
			{
				return false;
			}
			ZNetView netView = GetNetView(container);
			if ((Object)(object)netView != (Object)null)
			{
				return netView.IsValid();
			}
			return false;
		}

		private static void EnsureNetworkRegistration()
		{
			ZRoutedRpc instance = ZRoutedRpc.instance;
			if (instance == null || instance == _registeredRpc)
			{
				return;
			}
			_registeredRpc = instance;
			CompatiblePeers.Clear();
			instance.Register<string>("ChestFlow_MultiUserHello", (Action<long, string>)delegate(long sender, string version)
			{
				if (Plugin.IsActive)
				{
					if (string.Equals(version, "0.5.2", StringComparison.Ordinal))
					{
						CompatiblePeers.Add(sender);
					}
					else
					{
						CompatiblePeers.Remove(sender);
					}
				}
			});
			_nextHelloAt = 0f;
		}

		private static void HandleControlRequest(Container container, long sender, long playerId)
		{
			if (!Plugin.IsActive)
			{
				return;
			}
			if (!ModConfig.AllowConcurrentChestUse.Value || !Supports(container) || !container.IsOwner() || !CompatiblePeers.Contains(sender) || !ChestAuthority.CanUse(container, sender, playerId))
			{
				ZNetView? netView = GetNetView(container);
				if (netView != null)
				{
					netView.InvokeRPC(sender, "ChestFlow_ContainerControlResponse", new object[1] { false });
				}
			}
			else
			{
				TransferOwnership(container, sender, "ChestFlow_ContainerControlResponse");
			}
		}

		private static void HandleControlResponse(Container container, long sender, bool granted)
		{
			if (!Plugin.IsActive)
			{
				return;
			}
			int instanceID = ((Object)container).GetInstanceID();
			if (Pending.TryGetValue(instanceID, out PendingAction value) && sender == value.ExpectedOwner && !value.ResponseAccepted)
			{
				if (!granted)
				{
					Pending.Remove(instanceID);
					TellPlayer("The shared chest rejected this action.");
				}
				else
				{
					value.ResponseAccepted = true;
					((MonoBehaviour)Plugin.Instance).StartCoroutine(CompleteAfterOwnership(value));
				}
			}
		}

		private static IEnumerator CompleteAfterOwnership(PendingAction pending)
		{
			yield return null;
			if (!Plugin.IsActive)
			{
				yield break;
			}
			float deadline = pending.Deadline;
			while (Plugin.IsActive && (Object)(object)pending.Container != (Object)null && !pending.Container.IsOwner() && Time.realtimeSinceStartup < deadline)
			{
				yield return null;
			}
			if ((Object)(object)pending.Container == (Object)null || !pending.Container.IsOwner())
			{
				yield break;
			}
			yield return (object)new WaitForSeconds(0.05f);
			if (!Plugin.IsActive)
			{
				yield break;
			}
			LoadContainer(pending.Container);
			Pending.Remove(pending.ContainerId);
			_replaying = true;
			try
			{
				pending.Action();
			}
			catch (Exception ex)
			{
				Plugin.LogInstance.LogError((object)("Shared chest action failed: " + ex));
			}
			finally
			{
				_replaying = false;
			}
		}

		private static bool TransferOwnership(Container container, long peer, string responseRpc)
		{
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			ZNetView netView = GetNetView(container);
			ZDO val = ((netView != null) ? netView.GetZDO() : null);
			if ((Object)(object)netView == (Object)null || val == null || !netView.IsValid())
			{
				return false;
			}
			SaveContainer(container);
			ZDOMan.instance.ForceSendZDO(peer, val.m_uid);
			val.SetOwner(peer);
			netView.InvokeRPC(peer, responseRpc, new object[1] { true });
			return true;
		}

		internal static bool HasAccess(Container container, long playerId)
		{
			object obj = CheckAccessMethod.Invoke(container, new object[1] { playerId });
			bool flag = default(bool);
			int num;
			if (obj is bool)
			{
				flag = (bool)obj;
				num = 1;
			}
			else
			{
				num = 0;
			}
			return (byte)((uint)num & (flag ? 1u : 0u)) != 0;
		}

		internal static bool IsCompatiblePeer(long peer)
		{
			return CompatiblePeers.Contains(peer);
		}

		internal static void SaveContainer(Container container)
		{
			SaveMethod.Invoke(container, Array.Empty<object>());
		}

		internal static void LoadContainer(Container container)
		{
			LoadMethod.Invoke(container, Array.Empty<object>());
		}

		private static ZNetView? GetNetView(Container container)
		{
			object? value = ContainerNetViewField.GetValue(container);
			return (ZNetView?)((value is ZNetView) ? value : null);
		}

		private static void TellPlayer(string message)
		{
			Player localPlayer = Player.m_localPlayer;
			if (localPlayer != null)
			{
				((Character)localPlayer).Message((MessageType)2, message, 0, (Sprite)null, false);
			}
		}
	}
	internal static class NativeContainerRpcNames
	{
		internal const string OpenResponse = "RPC_OpenResponse";

		internal const string TakeAllResponse = "RPC_TakeAllResponse";
	}
	internal static class NearbyResourceService
	{
		private const float CacheLifetime = 0.35f;

		private const float CacheOriginToleranceSquared = 0.25f;

		private static readonly MethodInfo ContainerCheckAccessMethod = AccessTools.Method(typeof(Container), "CheckAccess", (Type[])null, (Type[])null);

		private static readonly FieldInfo ContainerNetViewField = AccessTools.Field(typeof(Container), "m_nview");

		private static readonly List<Container> CachedContainers = new List<Container>();

		private static readonly Dictionary<int, float> LastProductionDiagnosticAt = new Dictionary<int, float>();

		private static Vector3 _cachedOrigin;

		private static float _cacheExpiresAt = -1f;

		private static int _inventoryRepairPlayerId = int.MinValue;

		[ThreadStatic]
		private static bool _internalRemoval;

		internal static bool InternalRemoval => _internalRemoval;

		internal static void RepairInvalidPlayerInventoryPositions()
		{
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: 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)
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null)
			{
				_inventoryRepairPlayerId = int.MinValue;
				return;
			}
			int instanceID = ((Object)localPlayer).GetInstanceID();
			if (_inventoryRepairPlayerId == instanceID)
			{
				return;
			}
			_inventoryRepairPlayerId = instanceID;
			Inventory inventory = ((Humanoid)localPlayer).GetInventory();
			List<ItemData> list = (from item in inventory.GetAllItems()
				where item.m_gridPos.x < 0 || item.m_gridPos.y < 0
				select item).ToList();
			if (list.Count == 0)
			{
				return;
			}
			int num = 0;
			int num2 = 0;
			foreach (ItemData item in list)
			{
				if (TryPlaceInFreePlayerSlot(inventory, item))
				{
					num++;
					continue;
				}
				int stack = item.m_stack;
				if (inventory.RemoveItem(item))
				{
					ItemDrop.DropItem(item, stack, ((Component)localPlayer).transform.position + ((Component)localPlayer).transform.forward + Vector3.up, Quaternion.identity);
					num2++;
				}
			}
			inventory.m_onChanged?.Invoke();
			Plugin.LogInstance.LogWarning((object)($"Recovered {list.Count} invalid production-loan item(s): " + $"{num} relocated, {num2} dropped safely beside the player."));
		}

		internal static bool HasRecipeRequirements(Player player, Recipe recipe, int qualityLevel, int craftMultiplier)
		{
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			if (!ModConfig.CraftFromNearbyChests.Value || (Object)(object)player != (Object)(object)Player.m_localPlayer)
			{
				return false;
			}
			CraftingStation currentCraftingStation = player.GetCurrentCraftingStation();
			bool result = false;
			Requirement[] resources = recipe.m_resources;
			foreach (Requirement val in resources)
			{
				if (!AppliesToStation(val, currentCraftingStation))
				{
					continue;
				}
				int num = val.GetAmount(qualityLevel) * craftMultiplier;
				if (num <= 0)
				{
					continue;
				}
				string name = val.m_resItem.m_itemData.m_shared.m_name;
				int maxQuality = val.m_resItem.m_itemData.m_shared.m_maxQuality;
				bool flag = false;
				for (int j = 1; j <= maxQuality; j++)
				{
					if (CountAvailable(player, name, j, ((Component)player).transform.position) >= num)
					{
						flag = true;
						break;
					}
				}
				if (recipe.m_requireOnlyOneIngredient)
				{
					if (flag)
					{
						result = true;
					}
				}
				else if (!flag)
				{
					return false;
				}
			}
			if (!recipe.m_requireOnlyOneIngredient)
			{
				return true;
			}
			return result;
		}

		private static bool AppliesToStation(Requirement requirement, CraftingStation? station)
		{
			if (requirement?.m_resItem?.m_itemData?.m_shared != null)
			{
				return requirement.m_upgraderResource == ((Object)(object)station != (Object)null && station.m_upgrader);
			}
			return false;
		}

		internal static bool HasPieceRequirements(Player player, Piece piece)
		{
			//IL_003a: 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)
			if (!ModConfig.CraftFromNearbyChests.Value || (Object)(object)player != (Object)(object)Player.m_localPlayer)
			{
				return false;
			}
			if ((Object)(object)piece.m_craftingStation != (Object)null && !Object.op_Implicit((Object)(object)CraftingStation.HaveBuildStationInRange(piece.m_craftingStation.m_name, ((Component)player).transform.position)) && !ZoneSystem.instance.GetGlobalKey((GlobalKeys)27))
			{
				return false;
			}
			if (!string.IsNullOrEmpty(piece.m_dlc) && !DLCMan.instance.IsDLCInstalled(piece.m_dlc))
			{
				return false;
			}
			Requirement[] resources = piece.m_resources;
			foreach (Requirement val in resources)
			{
				if (val?.m_resItem?.m_itemData?.m_shared != null && val.m_amount > 0)
				{
					string name = val.m_resItem.m_itemData.m_shared.m_name;
					if (CountAvailable(player, name, -1, ((Component)player).transform.position) < val.m_amount)
					{
						return false;
					}
				}
			}
			return true;
		}

		internal static ItemData? FindFirstRequiredItem(Player player, Recipe recipe, int qualityLevel, int craftMultiplier, out int amount, out int extraAmount)
		{
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			amount = 0;
			extraAmount = 0;
			if (!ModConfig.CraftFromNearbyChests.Value || (Object)(object)player != (Object)(object)Player.m_localPlayer)
			{
				return null;
			}
			CraftingStation currentCraftingStation = player.GetCurrentCraftingStation();
			Requirement[] resources = recipe.m_resources;
			foreach (Requirement val in resources)
			{
				if (!AppliesToStation(val, currentCraftingStation))
				{
					continue;
				}
				int num = val.GetAmount(qualityLevel) * craftMultiplier;
				if (num <= 0)
				{
					continue;
				}
				string name = val.m_resItem.m_itemData.m_shared.m_name;
				int maxQuality = val.m_resItem.m_itemData.m_shared.m_maxQuality;
				int quality;
				for (quality = 1; quality <= maxQuality; quality++)
				{
					if (CountAvailable(player, name, quality, ((Component)player).transform.position) >= num)
					{
						ItemData val2 = ((Humanoid)player).GetInventory().GetItem(name, quality, false) ?? FindItem(((Component)player).transform.position, (ItemData candidate) => candidate.m_shared.m_name == name && candidate.m_quality == quality);
						if (val2 != null)
						{
							amount = num;
							extraAmount = val.m_extraAmountOnlyOneIngredient;
							return val2;
						}
					}
				}
			}
			return null;
		}

		internal static void ConsumeRequirements(Player player, Requirement[] requirements, int qualityLevel, int itemQuality, int multiplier)
		{
			CraftingStation currentCraftingStation = player.GetCurrentCraftingStation();
			foreach (Requirement val in requirements)
			{
				if (AppliesToStation(val, currentCraftingStation))
				{
					int num = val.GetAmount(qualityLevel) * multiplier;
					if (num > 0)
					{
						ConsumeItem(player, val.m_resItem.m_itemData.m_shared.m_name, num, itemQuality);
					}
				}
			}
		}

		internal static int ConsumeItem(Player player, string name, int amount, int quality)
		{
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			if (amount <= 0)
			{
				return 0;
			}
			int num = RemoveFromInventory(((Humanoid)player).GetInventory(), name, amount, quality);
			int num2 = amount - num;
			if (num2 <= 0 || !ModConfig.CraftFromNearbyChests.Value)
			{
				return num;
			}
			foreach (Container eligibleContainer in GetEligibleContainers(((Component)player).transform.position))
			{
				if (EnsureOwnership(eligibleContainer))
				{
					int num3 = RemoveFromInventory(eligibleContainer.GetInventory(), name, num2, quality, eligibleContainer);
					num += num3;
					num2 -= num3;
					if (num2 <= 0)
					{
						break;
					}
				}
			}
			return num;
		}

		internal static bool PlayerHasMatchingItem(Player player, Func<ItemData, bool> predicate)
		{
			return ((Humanoid)player).GetInventory().GetAllItems().Any(predicate);
		}

		internal static bool TryBorrowProductionItem(Component production, Humanoid user, Func<ItemData, bool> predicate, out ProductionItemLoan? loan)
		{
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			loan = null;
			if (ModConfig.CraftFromNearbyChests.Value)
			{
				Player val = (Player)(object)((user is Player) ? user : null);
				if (val != null && !((Object)(object)val != (Object)(object)Player.m_localPlayer) && !PlayerHasMatchingItem(val, predicate))
				{
					Inventory inventory = ((Humanoid)val).GetInventory();
					IReadOnlyList<Container> eligibleContainers = GetEligibleContainers(production.transform.position);
					int num = 0;
					int num2 = 0;
					int num3 = 0;
					foreach (Container container in eligibleContainers)
					{
						ItemData val2 = ((IEnumerable<ItemData>)container.GetInventory().GetAllItems()).FirstOrDefault((Func<ItemData, bool>)((ItemData candidate) => !candidate.m_shared.m_questItem && predicate(candidate) && ChestReserveStore.Available(container, candidate) > 0));
						if (val2 == null)
						{
							continue;
						}
						num++;
						if (!EnsureOwnership(container))
						{
							num2++;
							continue;
						}
						string name = val2.m_shared.m_name;
						if (container.GetInventory().ContainsItem(val2) && ChestReserveStore.Available(container, val2) > 0)
						{
							int quality = val2.m_quality;
							int playerCountBefore = inventory.CountItems(name, quality, true);
							if (TryLoanOneItem(container.GetInventory(), inventory, val2, playerCountBefore, out ItemData loanedItem) && loanedItem != null)
							{
								loan = new ProductionItemLoan(container, val, loanedItem);
								LogProductionDiagnostic(production, "Pulled " + name + " from " + ((Object)container).name + " for " + ((Object)production).name + ".", warning: false);
								return true;
							}
							num3++;
						}
					}
					LogProductionDiagnostic(production, $"Could not pull an input for {((Object)production).name}: {eligibleContainers.Count} eligible chest(s), " + $"{num} matching stack(s), {num2} ownership failure(s), " + $"{num3} transfer failure(s).", warning: true);
					return false;
				}
			}
			return false;
		}

		internal static bool TryBorrowProductionItemInPriority(Component production, Humanoid user, Func<ItemData, bool> playerPredicate, IReadOnlyList<string> preferredNames, out ProductionItemLoan? loan)
		{
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			loan = null;
			if (ModConfig.CraftFromNearbyChests.Value)
			{
				Player val = (Player)(object)((user is Player) ? user : null);
				if (val != null && !((Object)(object)val != (Object)(object)Player.m_localPlayer) && !PlayerHasMatchingItem(val, playerPredicate))
				{
					Inventory inventory = ((Humanoid)val).GetInventory();
					IReadOnlyList<Container> eligibleContainers = GetEligibleContainers(production.transform.position);
					int num = 0;
					int num2 = 0;
					int num3 = 0;
					foreach (string preferredName in preferredNames)
					{
						foreach (Container container in eligibleContainers)
						{
							ItemData val2 = ((IEnumerable<ItemData>)container.GetInventory().GetAllItems()).FirstOrDefault((Func<ItemData, bool>)((ItemData candidate) => !candidate.m_shared.m_questItem && candidate.m_shared.m_name == preferredName && ChestReserveStore.Available(container, candidate) > 0));
							if (val2 == null)
							{
								continue;
							}
							num++;
							if (!EnsureOwnership(container))
							{
								num2++;
							}
							else if (container.GetInventory().ContainsItem(val2) && ChestReserveStore.Available(container, val2) > 0)
							{
								int quality = val2.m_quality;
								int playerCountBefore = inventory.CountItems(preferredName, quality, true);
								if (TryLoanOneItem(container.GetInventory(), inventory, val2, playerCountBefore, out ItemData loanedItem) && loanedItem != null)
								{
									loan = new ProductionItemLoan(container, val, loanedItem);
									LogProductionDiagnostic(production, "Pulled " + preferredName + " from " + ((Object)container).name + " for " + ((Object)production).name + ".", warning: false);
									return true;
								}
								num3++;
							}
						}
					}
					LogProductionDiagnostic(production, "Could not pull a prioritized input for " + ((Object)production).name + ": " + $"{eligibleContainers.Count} eligible chest(s), {num} matching stack(s), " + $"{num2} ownership failure(s), {num3} transfer failure(s).", warning: true);
					return false;
				}
			}
			return false;
		}

		private static void LogProductionDiagnostic(Component production, string message, bool warning)
		{
			int instanceID = ((Object)production).GetInstanceID();
			float realtimeSinceStartup = Time.realtimeSinceStartup;
			if (!LastProductionDiagnosticAt.TryGetValue(instanceID, out var value) || !(realtimeSinceStartup - value < 2f))
			{
				LastProductionDiagnosticAt[instanceID] = realtimeSinceStartup;
				if (warning)
				{
					Plugin.LogInstance.LogWarning((object)message);
				}
				else
				{
					Plugin.LogInstance.LogInfo((object)message);
				}
			}
		}

		private static bool TryLoanOneItem(Inventory source, Inventory playerInventory, ItemData sourceItem, int playerCountBefore, out ItemData? loanedItem)
		{
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			loanedItem = null;
			playerInventory.MoveItemToThis(source, sourceItem, 1, -1, -1);
			if (playerInventory.CountItems(sourceItem.m_shared.m_name, sourceItem.m_quality, true) > playerCountBefore)
			{
				loanedItem = playerInventory.GetItem(sourceItem.m_shared.m_name, sourceItem.m_quality, false);
				return loanedItem != null;
			}
			if (!source.GetAllItems().Contains(sourceItem))
			{
				return false;
			}
			ItemData val = sourceItem.Clone();
			val.m_stack = 1;
			val.m_gridPos = new Vector2i(0, 0);
			if (!source.RemoveItem(sourceItem, 1))
			{
				return false;
			}
			playerInventory.GetAllItems().Add(val);
			playerInventory.m_onChanged?.Invoke();
			loanedItem = val;
			return true;
		}

		internal static void KeepLoanedItemSafe(Player player, ItemData item)
		{
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_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)
			Inventory inventory = ((Humanoid)player).GetInventory();
			if (!inventory.GetAllItems().Contains(item) || IsValidUnoccupiedPosition(inventory, item))
			{
				return;
			}
			if (TryPlaceInFreePlayerSlot(inventory, item))
			{
				inventory.m_onChanged?.Invoke();
				return;
			}
			int stack = item.m_stack;
			if (inventory.RemoveItem(item))
			{
				ItemDrop.DropItem(item, stack, ((Component)player).transform.position + ((Component)player).transform.forward + Vector3.up, Quaternion.identity);
			}
		}

		private static bool TryPlaceInFreePlayerSlot(Inventory inventory, ItemData item)
		{
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			int width = inventory.GetWidth();
			int height = inventory.GetHeight();
			HashSet<int> hashSet = new HashSet<int>(from candidate in inventory.GetAllItems()
				where candidate != item && candidate.m_gridPos.x >= 0 && candidate.m_gridPos.x < width && candidate.m_gridPos.y >= 0 && candidate.m_gridPos.y < height
				select candidate.m_gridPos.y * width + candidate.m_gridPos.x);
			for (int num = 0; num < height; num++)
			{
				for (int num2 = 0; num2 < width; num2++)
				{
					if (!hashSet.Contains(num * width + num2))
					{
						item.m_gridPos = new Vector2i(num2, num);
						return true;
					}
				}
			}
			return false;
		}

		private static bool IsValidUnoccupiedPosition(Inventory inventory, ItemData item)
		{
			int x = item.m_gridPos.x;
			int y = item.m_gridPos.y;
			if (x < 0 || y < 0 || x >= inventory.GetWidth() || y >= inventory.GetHeight())
			{
				return false;
			}
			return !inventory.GetAllItems().Any((ItemData candidate) => candidate != item && candidate.m_gridPos.x == x && candidate.m_gridPos.y == y);
		}

		internal static bool MatchesAnyConversion(ItemData item, IEnumerable<ItemDrop> inputs)
		{
			return inputs.Any((ItemDrop input) => input?.m_itemData?.m_shared != null && input.m_itemData.m_shared.m_name == item.m_shared.m_name);
		}

		internal static int CountAvailable(Player player, string name, int quality, Vector3 origin)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			int num = ((Humanoid)player).GetInventory().CountItems(name, quality, true);
			foreach (Container eligibleContainer in GetEligibleContainers(origin))
			{
				if (!AutoFeedService.IsLocked(eligibleContainer))
				{
					num += ChestReserveStore.Count(eligibleContainer, name, quality);
				}
			}
			return num;
		}

		private static ItemData? FindItem(Vector3 origin, Func<ItemData, bool> predicate)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			foreach (Container container in GetEligibleContainers(origin))
			{
				if (!AutoFeedService.IsLocked(container))
				{
					ItemData val = ((IEnumerable<ItemData>)container.GetInventory().GetAllItems()).FirstOrDefault((Func<ItemData, bool>)((ItemData candidate) => predicate(candidate) && ChestReserveStore.Available(container, candidate) > 0));
					if (val != null)
					{
						return val;
					}
				}
			}
			return null;
		}

		private static int RemoveFromInventory(Inventory inventory, string name, int requested, int quality, Container? container = null)
		{
			if ((Object)(object)container != (Object)null)
			{
				int num = 0;
				ItemData[] array = inventory.GetAllItems().ToArray();
				foreach (ItemData val in array)
				{
					if (!(val.m_shared.m_name != name) && !val.m_shared.m_questItem && val.m_worldLevel >= Game.m_worldLevel && (quality < 0 || val.m_quality == quality))
					{
						int num2 = Math.Min(requested - num, ChestReserveStore.Available(container, val));
						if (num2 > 0 && inventory.RemoveItem(val, num2))
						{
							num += num2;
						}
						if (num == requested)
						{
							break;
						}
					}
				}
				return num;
			}
			int num3 = Mathf.Min(requested, inventory.CountItems(name, quality, true));
			if (num3 <= 0)
			{
				return 0;
			}
			try
			{
				_internalRemoval = true;
				inventory.RemoveItem(name, num3, quality, true);
				return num3;
			}
			finally
			{
				_internalRemoval = false;
			}
		}

		internal static IReadOnlyList<Container> GetEligibleContainersForTransfer(Vector3 origin)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			return GetEligibleContainers(origin);
		}

		private static IReadOnlyList<Container> GetEligibleContainers(Vector3 origin)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			if (Time.time <= _cacheExpiresAt)
			{
				Vector3 val = origin - _cachedOrigin;
				if (((Vector3)(ref val)).sqrMagnitude <= 0.25f)
				{
					return CachedContainers;
				}
			}
			CachedContainers.Clear();
			_cachedOrigin = origin;
			_cacheExpiresAt = Time.time + 0.35f;
			float rangeSquared = ModConfig.SharedResourceRange.Value * ModConfig.SharedResourceRange.Value;
			CachedContainers.AddRange((from container in Object.FindObjectsByType<Container>((FindObjectsSortMode)0)
				where IsEligible(container, origin, rangeSquared)
				select container).OrderBy(delegate(Container container)
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0011: Unknown result type (might be due to invalid IL or missing references)
				//IL_0016: Unknown result type (might be due to invalid IL or missing references)
				Vector3 val2 = ((Component)container).transform.position - origin;
				return ((Vector3)(ref val2)).sqrMagnitude;
			}));
			return CachedContainers;
		}

		private static bool IsEligible(Container container, Vector3 origin, float rangeSquared)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)container == (Object)null || !((Behaviour)container).isActiveAndEnabled)
			{
				return false;
			}
			Vector3 val = ((Component)container).transform.position - origin;
			if (((Vector3)(ref val)).sqrMagnitude > rangeSquared)
			{
				return false;
			}
			Container val2 = InventoryAccess.CurrentContainer(InventoryGui.instance);
			if (container.IsInUse() && (Object)(object)container != (Object)(object)val2)
			{
				return false;
			}
			if ((Object)(object)((Component)container).GetComponent<Player>() != (Object)null || (Object)(object)((Component)container).GetComponent<TombStone>() != (Object)null)
			{
				return false;
			}
			if (!ModConfig.IncludeVehicleContainers.Value && ((Object)(object)container.m_wagon != (Object)null || (Object)(object)((Component)container).GetComponentInParent<Ship>() != (Object)null))
			{
				return false;
			}
			if (container.m_checkGuardStone && !PrivateArea.CheckAccess(((Component)container).transform.position, 0f, false, false))
			{
				return false;
			}
			long playerID = Game.instance.GetPlayerProfile().GetPlayerID();
			if (!(bool)ContainerCheckAccessMethod.Invoke(container, new object[1] { playerID }))
			{
				return false;
			}
			Piece val3 = ((Component)container).GetComponent<Piece>() ?? ((Component)container).GetComponentInParent<Piece>();
			if (!ModConfig.IncludeWorldContainers.Value)
			{
				if ((Object)(object)val3 != (Object)null)
				{
					return val3.IsPlacedByPlayer();
				}
				return false;
			}
			return true;
		}

		internal static bool TryEnsureOwnership(Container container)
		{
			return EnsureOwnership(container);
		}

		private static bool EnsureOwnership(Container container)
		{
			if (AutoFeedService.IsLocked(container))
			{
				return false;
			}
			if (container.IsOwner())
			{
				return true;
			}
			object? value = ContainerNetViewField.GetValue(container);
			ZNetView val = (ZNetView)((value is ZNetView) ? value : null);
			if ((Object)(object)val == (Object)null || !val.IsValid())
			{
				return false;
			}
			val.ClaimOwnership();
			return container.IsOwner();
		}
	}
	internal sealed class ProductionItemLoan
	{
		private readonly Container _source;

		private readonly Player _player;

		private readonly ItemData _item;

		internal ProductionItemLoan(Container source, Player player, ItemData item)
		{
			_source = source;
			_player = player;
			_item = item;
		}

		internal void ReturnIfPresent()
		{
			if ((Object)(object)_player == (Object)null)
			{
				return;
			}
			Inventory inventory = ((Humanoid)_player).GetInventory();
			if (!inventory.GetAllItems().Contains(_item))
			{
				return;
			}
			if ((Object)(object)_source != (Object)null && _source.IsOwner())
			{
				_source.GetInventory().MoveItemToThis(inventory, _item, _item.m_stack, -1, -1);
				if (!inventory.GetAllItems().Contains(_item))
				{
					return;
				}
			}
			NearbyResourceService.KeepLoanedItemSafe(_player, _item);
		}
	}
	internal sealed class QuickStackService
	{
		private sealed class ItemMatchIndex
		{
			internal HashSet<string> Names { get; } = new HashSet<string>();

			internal HashSet<string> PrefabNames { get; } = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

			internal HashSet<ItemCategory> Categories { get; } = new HashSet<ItemCategory>();
		}

		private sealed class PendingRequest
		{
			internal Container Container { get; }

			internal int InstanceId { get; }

			internal int Session { get; }

			internal int Attempts { get; set; }

			internal float NextAttemptAt { get; set; }

			internal PendingRequest(Container container, int session)
			{
				Container = container;
				InstanceId = ((Object)container).GetInstanceID();
				Session = session;
			}
		}

		private const float ResponseTimeout = 5f;

		private const float RetryInterval = 0.6f;

		private const int MaxAttemptsPerChest = 8;

		private readonly Plugin _plugin;

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

		private Coroutine? _routine;

		private int _session;

		private Action? _onCompleted;

		internal QuickStackService(Plugin plugin)
		{
			_plugin = plugin;
		}

		internal void BeginNearbyQuickStack(Action? onCompleted = null)
		{
			Player localPlayer = Player.m_localPlayer;
			if (!ModConfig.Enabled.Value || (Object)(object)localPlayer == (Object)null || _routine != null)
			{
				return;
			}
			_session++;
			_pending.Clear();
			_onCompleted = onCompleted;
			List<Container> list = FindEligibleContainers(localPlayer);
			bool flag = StackIntoOpenContainer(localPlayer, list);
			if (list.Count == 0)
			{
				if (flag || !HasMovablePlayerItems(localPlayer) || RestockProfileService.HasProfiles(localPlayer))
				{
					CompleteSession();
					return;
				}
				TellPlayer("No eligible nearby chests contain matching items or category seeds.");
				CompleteSession();
				return;
			}
			foreach (Container item in list)
			{
				_pending[((Object)item).GetInstanceID()] = new PendingRequest(item, _session);
			}
			_routine = ((MonoBehaviour)_plugin).StartCoroutine(RequestStacking(_session));
		}

		internal bool TryBeginResponse(Container container, bool granted)
		{
			int instanceID = ((Object)container).GetInstanceID();
			if (!_pending.TryGetValue(instanceID, out PendingRequest value) || value.Session != _session)
			{
				return false;
			}
			if (granted)
			{
				_pending.Remove(instanceID);
			}
			return true;
		}

		internal void Reset()
		{
			if (_routine != null)
			{
				((MonoBehaviour)_plugin).StopCoroutine(_routine);
			}
			_routine = null;
			_pending.Clear();
			_onCompleted = null;
		}

		private IEnumerator RequestStacking(int session)
		{
			WaitForSeconds spacing = ((!(ModConfig.RequestSpacing.Value > 0f)) ? ((WaitForSeconds)null) : new WaitForSeconds(ModConfig.RequestSpacing.Value));
			WaitForSeconds retryPoll = new WaitForSeconds(0.05f);
			float deadline = Time.realtimeSinceStartup + 5f;
			while (session == _session && _pending.Count > 0 && Time.realtimeSinceStartup < deadline)
			{
				bool sentRequest = false;
				PendingRequest[] array = _pending.Values.ToArray();
				PendingRequest[] array2 = array;
				foreach (PendingRequest pendingRequest in array2)
				{
					if (session != _session)
					{
						yield break;
					}
					if (!_pending.TryGetValue(pendingRequest.InstanceId, out PendingRequest value) || value != pendingRequest)
					{
						continue;
					}
					if ((Object)(object)pendingRequest.Container == (Object)null)
					{
						_pending.Remove(pendingRequest.InstanceId);
						continue;
					}
					float realtimeSinceStartup = Time.realtimeSinceStartup;
					if (pendingRequest.Attempts < 8 && !(realtimeSinceStartup < pendingRequest.NextAttemptAt))
					{
						pendingRequest.Attempts++;
						pendingRequest.NextAttemptAt = realtimeSinceStartup + 0.6f;
						pendingRequest.Container.StackAll();
						sentRequest = true;
						if (spacing != null)
						{
							yield return spacing;
						}
					}
				}
				if (!sentRequest)
				{
					yield return retryPoll;
				}
			}
			if (session == _session)
			{
				int count = _pending.Count;
				_pending.Clear();
				_routine = null;
				if (count > 0)
				{
					TellPlayer("One or more chest requests timed out.");
				}
				CompleteSession();
			}
		}

		private static bool StackIntoOpenContainer(Player player, ICollection<Container> containers)
		{
			Container openContainer = InventoryAccess.CurrentContainer(InventoryGui.instance);
			if ((Object)(object)openContainer == (Object)null || !containers.Remove(openContainer))
			{
				return false;
			}
			if (!openContainer.IsOwner())
			{
				if (MultiUserContainerService.TryDeferUntilOwned(openContainer, delegate
				{
					Player localPlayer = Player.m_localPlayer;
					if (!((Object)(object)localPlayer == (Object)null) && !((Object)(object)InventoryAccess.CurrentContainer(InventoryGui.instance) != (Object)(object)openContainer))
					{
						List<TransferRecord> records2 = new List<TransferRecord>();
						QuickStackTransfer.MoveMatching(openContainer, ((Humanoid)localPlayer).GetInventory(), records2);
						TransferVisuals.Play(records2, openContainer);
						RestockProfileService.RestockNearby();
					}
				}))
				{
					return true;
				}
				containers.Add(openContainer);
				return false;
			}
			List<TransferRecord> records = new List<TransferRecord>();
			QuickStackTransfer.MoveMatching(openContainer, ((Humanoid)player).GetInventory(), records);
			TransferVisuals.Play(records, openContainer);
			return true;
		}

		private static bool HasMovablePlayerItems(Player player)
		{
			foreach (ItemData allItem in ((Humanoid)player).GetInventory().GetAllItems())
			{
				if (!allItem.m_shared.m_questItem && allItem.m_shared.m_autoStack && !((Humanoid)player).IsItemEquiped(allItem) && (!ModConfig.ProtectHotbar.Value || allItem.m_gridPos.y != 0) && !ItemLockService.IsLocked(allItem) && !RestockProfileService.IsTarget(allItem) && (!ModConfig.SkipCustomData.Value || allItem.m_customData.Count <= 0))
				{
					return true;
				}
			}
			return false;
		}

		private static List<Container> FindEligibleContainers(Player player)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			Vector3 playerPosition = ((Component)player).transform.position;
			float rangeSquared = ModConfig.NearbyRange.Value * ModConfig.NearbyRange.Value;
			ItemMatchIndex movableItems = FindMovablePlayerItems(player);
			return (from container in Object.FindObjectsByType<Container>((FindObjectsSortMode)0)
				where IsEligible(container, player, movableItems, playerPosition, rangeSquared)
				select container).OrderBy(delegate(Container container)
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0011: Unknown result type (might be due to invalid IL or missing references)
				//IL_0016: Unknown result type (might be due to invalid IL or missing references)
				Vector3 val = ((Component)container).transform.position - playerPosition;
				return ((Vector3)(ref val)).sqrMagnitude;
			}).ToList();
		}

		internal static IEnumerable<string> Preview(Player player)
		{
			HashSet<Container> eligible = new HashSet<Container>(FindEligibleContainers(player));
			Inventory source = CloneInventory(((Humanoid)player).GetInventory());
			int total = 0;
			foreach (Container item in (from container in Object.FindObjectsByType<Container>((FindObjectsSortMode)0).Where(delegate(Container container)
				{
					//IL_000f: Unknown result type (might be due to invalid IL or missing references)
					//IL_001f: Unknown result type (might be due to invalid IL or missing references)
					//IL_0024: Unknown result type (might be due to invalid IL or missing references)
					//IL_0029: Unknown result type (might be due to invalid IL or missing references)
					if ((Object)(object)container != (Object)null)
					{
						Vector3 val2 = ((Component)container).transform.position - ((Component)player).transform.position;
						return ((Vector3)(ref val2)).sqrMagnitude <= ModConfig.NearbyRange.Value * ModConfig.NearbyRange.Value;
					}
					return false;
				})
				orderby (!((Object)(object)container == (Object)(object)InventoryAccess.CurrentContainer(InventoryGui.instance))) ? 1 : 0
				select container).ThenBy(delegate(Container container)
			{
				//IL_0006: 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_001b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0020: Unknown result type (might be due to invalid IL or missing references)
				Vector3 val2 = ((Component)container).transform.position - ((Component)player).transform.position;
				return ((Vector3)(ref val2)).sqrMagnitude;
			}))
			{
				string name = ((Object)item).name;
				Vector3 val = ((Component)item).transform.position - ((Component)player).transform.position;
				string text = name + " (" + Math.Round(((Vector3)(ref val)).magnitude, 1) + "m)";
				if (!eligible.Contains(item))
				{
					string text2 = (AutoFeedService.IsLocked(item) ? "Auto Feed operation in progress" : ((item.IsInUse() && (Object)(object)item != (Object)(object)InventoryAccess.CurrentContainer(InventoryGui.instance)) ? "busy" : ((!HasPrivacyAccess(item)) ? "private" : ((!ChestAuthority.WardAccess(item, player.GetPlayerID())) ? "ward access denied" : ((!ModConfig.IncludeVehicleContainers.Value && ((Object)(object)item.m_wagon != (Object)null || (Object)(object)((Component)item).GetComponentInParent<Ship>() != (Object)null)) ? "vehicle policy" : ((!ModConfig.IncludeWorldContainers.Value && ((Object)(object)((Component)item).GetComponent<Piece>() == (Object)null || !((Component)item).GetComponent<Piece>().IsPlacedByPlayer())) ? "world-container policy" : "protected container or no movable items match its rule/seeds"))))));
					yield return text + ": skipped — " + text2;
					continue;
				}
				List<TransferRecord> records = new List<TransferRecord>();
				int num = QuickStackTransfer.MoveMatchingInventory(CloneInventory(item.GetInventory()), ChestRuleStore.Read(item), source, records);
				total += num;
				yield return text + ": " + num + " item(s)" + ((num == 0) ? " — full or earlier destinations accepted them" : "");
			}
			yield return "Preview total: " + total + " item(s). No inventories changed; availability can change before quick stack runs.";
		}

		private static Inventory CloneInventory(Inventory original)
		{
			//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_0052: Expected O, but got Unknown
			Inventory val = new Inventory("ChestFlow preview", original.GetBkg(), original.GetWidth(), original.GetHeight());
			val.GetAllItems().AddRange(from item in original.GetAllItems()
				select item.Clone());
			return val;
		}

		private static ItemMatchIndex FindMovablePlayerItems(Player player)
		{
			ItemMatchIndex itemMatchIndex = new ItemMatchIndex();
			foreach (ItemData allItem in ((Humanoid)player).GetInventory().GetAllItems())
			{
				if (!allItem.m_shared.m_questItem && allItem.m_shared.m_autoStack && !((Humanoid)player).IsItemEquiped(allItem) && (!ModConfig.ProtectHotbar.Value || allItem.m_gridPos.y != 0) && !ItemLockService.IsLocked(allItem) && !RestockProfileService.IsTarget(allItem) && (!ModConfig.SkipCustomData.Value || allItem.m_customData.Count <= 0))
				{
					itemMatchIndex.Names.Add(allItem.m_shared.m_name);
					itemMatchIndex.PrefabNames.Add(ValheimItemCategoryClassifier.PrefabName(allItem));
					itemMatchIndex.Categories.Add(ValheimItemCategoryClassifier.Classify(allItem));
				}
			}
			return itemMatchIndex;
		}

		private static bool IsEligible(Container container, Player player, ItemMatchIndex movableItems, Vector3 playerPosition, float rangeSquared)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)container == (Object)null || !((Behaviour)container).isActiveAndEnabled)
			{
				return false;
			}
			if (AutoFeedService.IsLocked(container))
			{
				return false;
			}
			Vector3 val = ((Component)container).transform.position - playerPosition;
			if (((Vector3)(ref val)).sqrMagnitude > rangeSquared)
			{
				return false;
			}
			Container val2 = InventoryAccess.CurrentContainer(InventoryGui.instance);
			if (container.IsInUse() && (Object)(object)container != (Object)(object)val2)
			{
				return false;
			}
			if ((Object)(object)((Component)container).GetComponent<Player>() != (Object)null)
			{
				return false;
			}
			if ((Object)(object)((Component)container).GetComponent<TombStone>() != (Object)null)
			{
				return false;
			}
			if (!ModConfig.IncludeVehicleContainers.Value && ((Object)(object)container.m_wagon != (Object)null || (Object)(object)((Component)container).GetComponentInParent<Ship>() != (Object)null))
			{
				return false;
			}
			if (container.m_checkGuardStone && !PrivateArea.CheckAccess(((Component)container).transform.position, 0f, false, false))
			{
				return false;
			}
			if (!HasPrivacyAccess(container))
			{
				return false;
			}
			Piece val3 = ((Component)container).GetComponent<Piece>() ?? ((Component)container).GetComponentInParent<Piece>();
			if (!ModConfig.IncludeWorldContainers.Value && ((Object)(object)val3 == (Object)null || !val3.IsPlacedByPlayer()))
			{
				return false;
			}
			ChestStorageRule chestStorageRule = ChestRuleStore.Read(container);
			if (!chestStorageRule.IsAutomatic)
			{
				return MatchesExplicitRule(movableItems, chestStorageRule);
			}
			foreach (ItemData allItem in container.GetInventory().GetAllItems())
			{
				if (movableItems.Names.Contains(allItem.m_shared.m_name))
				{
					return true;
				}
				if (ModConfig.StorageMatchMode.Value == StorageMatchMode.ExactItemOrCategory && movableItems.Categories.Contains(ValheimItemCategoryClassifier.Classify(allItem)))
				{
					return true;
				}
			}
			return false;
		}

		private static bool MatchesExplicitRule(ItemMatchIndex movableItems, ChestStorageRule rule)
		{
			if (rule.Scope == ChestRuleScope.Items)
			{
				foreach (string prefabName in movableItems.PrefabNames)
				{
					if (rule.Matches(prefabName, ItemCategory.Miscellaneous))
					{
						return true;
					}
				}
				return false;
			}
			foreach (ItemCategory category in movableItems.Categories)
			{
				if (rule.Matches(string.Empty, category))
				{
					return true;
				}
			}
			return false;
		}

		private static bool HasPrivacyAccess(Container container)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Invalid comparison between Unknown and I4
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Invalid comparison between Unknown and I4
			if ((int)container.m_privacy == 2)
			{
				return true;
			}
			if ((int)container.m_privacy == 1)
			{
				return false;
			}
			Piece val = ((Component)container).GetComponent<Piece>() ?? ((Component)container).GetComponentInParent<Piece>();
			long playerID = Game.instance.GetPlayerProfile().GetPlayerID();
			if ((Object)(object)val != (Object)null)
			{
				return val.GetCreator() == playerID;
			}
			return false;
		}

		private static void TellPlayer(string message)
		{
			Player localPlayer = Player.m_localPlayer;
			if (localPlayer != null)
			{
				((Character)localPlayer).Message((MessageType)2, message, 0, (Sprite)null, false);
			}
		}

		private void CompleteSession()
		{
			Action onCompleted = _onCompleted;
			_onCompleted = null;
			if (onCompleted == null)
			{
				return;
			}
			try
			{
				onCompleted();
			}
			catch (Exception ex)
			{
				Plugin.LogInstance.LogError((object)("Restock after nearby Stack failed: " + ex));
			}
		}
	}
	internal static class QuickStackTransfer
	{
		internal static int MoveMatching(Container destinationContainer, Inventory source, ICollection<TransferRecord> records)
		{
			Inventory inventory = destinationContainer.GetInventory();
			ChestStorageRule rule = ChestRuleStore.Read(destinationContainer);
			return MoveMatchingInventory(inventory, rule, source, records);
		}

		internal static int MoveMatchingInventory(Inventory destination, ChestStorageRule rule, Inventory source, ICollection<TransferRecord> records)
		{
			HashSet<string> hashSet = new HashSet<string>();
			HashSet<ItemCategory> hashSet2 = new HashSet<ItemCategory>();
			foreach (ItemData allItem in destination.GetAllItems())
			{
				hashSet.Add(allItem.m_shared.m_name);
				hashSet2.Add(ValheimItemCategoryClassifier.Classify(allItem));
			}
			int num = 0;
			bool flag = false;
			foreach (ItemData item in new List<ItemData>(source.GetAllItems()))
			{
				if (!CanMove(item, rule, hashSet, hashSet2))
				{
					continue;
				}
				int stack = item.m_stack;
				bool flag2 = destination.AddItem(item);
				int num2 = (flag2 ? stack : (stack - item.m_stack));
				if (num2 > 0)
				{
					if (flag2)
					{
						source.RemoveItem(item);
					}
					else
					{
						flag = true;
					}
					num += num2;
					records.Add(new TransferRecord(item.m_shared.m_name, item.GetIcon(), num2, item.m_shared.m_maxStackSize));
				}
			}
			if (flag)
			{
				source.m_onChanged?.Invoke();
			}
			return num;
		}

		private static bool CanMove(ItemData item, ChestStorageRule rule, ISet<string> destinationTypes, ISet<ItemCategory> destinationCategories)
		{
			if (item == null || item.m_shared == null)
			{
				return false;
			}
			ItemCategory itemCategory = ValheimItemCategoryClassifier.Classify(item);
			if (rule.IsAutomatic)
			{
				bool num = destinationTypes.Contains(item.m_shared.m_name);
				bool flag = ModConfig.StorageMatchMode.Value == StorageMatchMode.ExactItemOrCategory && destinationCategories.Contains(itemCategory);
				if (!num && !flag)
				{
					return false;
				}
			}
			else if (!rule.Matches(ValheimItemCategoryClassifier.PrefabName(item), itemCategory))
			{
				return false;
			}
			if (item.m_shared.m_questItem || !item.m_shared.m_autoStack)
			{
				return false;
			}
			if (item.m_equipped || ((Object)(object)Player.m_localPlayer != (Object)null && ((Humanoid)Player.m_localPlayer).IsItemEquiped(item)))
			{
				return false;
			}
			if (ModConfig.ProtectHotbar.Value && item.m_gridPos.y == 0)
			{
				return false;
			}
			if (ItemLockService.IsLocked(item))
			{
				return false;
			}
			if (RestockProfileService.IsTarget(item))
			{
				return false;
			}
			if (ModConfig.SkipCustomData.Value && item.m_customData.Count > 0)
			{
				return false;
			}
			return true;
		}
	}
	internal static class RestockProfileService
	{
		private sealed class TrackedItem
		{
			internal Inventory Inventory { get; }

			internal RestockInventoryKind Kind { get; }

			internal ItemData Item { get; }

			internal TrackedItem(Inventory inventory, RestockInventoryKind kind, ItemData item)
			{
				Inventory = inventory;
				Kind = kind;
				Item = item;
			}
		}

		private sealed class CustomDataComparer : IEqualityComparer<KeyValuePair<string, string>>
		{
			internal static readonly CustomDataComparer Instance = new CustomDataComparer();

			public bool Equals(KeyValuePair<string, string> x, KeyValuePair<string, string> y)
			{
				if (string.Equals(x.Key, y.Key, StringComparison.Ordinal))
				{
					return string.Equals(x.Value, y.Value, StringComparison.Ordinal);
				}
				return false;
			}

			public int GetHashCode(KeyValuePair<string, string> pair)
			{
				return (StringComparer.Ordinal.GetHashCode(pair.Key) * 397) ^ StringComparer.Ordinal.GetHashCode(pair.Value);
			}
		}

		private const string PlayerDataKey = "com.jg224.chestflow.restock-profiles";

		private const string GearSlotsIdentityKey = "com.jg224.gearslots.item-id";

		private const string HighlightName = "ChestFlow_RestockHighlight";

		private static readonly FieldInfo ElementsField = AccessTools.Field(typeof(InventoryGrid), "m_elements");

		private static bool _reportedInvalidData;

		internal static bool IsTarget(ItemData? item)
		{
			string id;
			int target;
			if (item != null)
			{
				return RestockMarker.TryRead(item.m_customData, out id, out target);
			}
			return false;
		}

		internal static bool HasProfiles(Player player)
		{
			return LoadProfiles(player).Count > 0;
		}

		internal static bool TrySet(InventoryGrid grid, ItemData? item, bool enabled)
		{
			if (!TrySet(grid.GetInventory(), item, enabled))
			{
				return false;
			}
			RefreshHighlights(grid);
			return true;
		}

		internal static bool TryEnableGearSlotsAmmoTarget()
		{
			Player localPlayer = Player.m_localPlayer;
			Inventory? obj = (((Object)(object)localPlayer == (Object)null) ? null : GearSlotsBridge.GetInventory(localPlayer, RestockInventoryKind.GearSlotsAmmo));
			ItemData item = ((obj != null) ? obj.GetItemAt(5, 0) : null);
			return TrySet(obj, item, enabled: true);
		}

		private static bool TrySet(Inventory? inventory, ItemData? item, bool enabled)
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			if (!ModConfig.Enabled.Value || item == null)
			{
				return false;
			}
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null || inventory == null || !GearSlotsBridge.TryClassify(inventory, item.m_gridPos, out var kind))
			{
				return false;
			}
			if (string.IsNullOrWhiteSpace(ValheimItemCategoryClassifier.PrefabName(item)) || item.m_shared.m_maxStackSize <= 1)
			{
				return false;
			}
			List<RestockProfile> list = LoadProfiles(localPlayer);
			if (enabled)
			{
				ItemStackLock.SetLocked(item.m_customData, locked: false);
			}
			string id;
			if (!enabled && RestockMarker.TryRead(item.m_customData, out string existingId, out int target))
			{
				RestockMarker.Clear(item.m_customData);
				list.RemoveAll((RestockProfile profile) => string.Equals(profile.Id, existingId, StringComparison.Ordinal));
			}
			else if (enabled && !RestockMarker.TryRead(item.m_customData, out id, out target))
			{
				string id2 = Guid.NewGuid().ToString("N");
				int target2 = RestockTargetPolicy.GetTarget(item.m_shared.m_maxStackSize);
				RestockMarker.Set(item.m_customData, id2, target2);
				list.Add(CreateProfile(id2, kind, item, target2));
			}
			if (enabled && RestockMarker.TryRead(item.m_customData, out string id3, out target))
			{
				RestockProfileSlotPolicy.RemoveConflicts(list, kind, item.m_gridPos.x, item.m_gridPos.y, id3);
			}
			SynchronizeLiveTargets(localPlayer, list);
			SaveProfiles(localPlayer, list);
			inventory.m_onChanged?.Invoke();
			GearSlotsBridge.NotifyChanged(inventory);
			return true;
		}

		internal static void RefreshHighlights(InventoryGrid grid)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: 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_0088: Unknown result type (might be due to invalid IL or missing references)
			Inventory inventory = grid.GetInventory();
			if (inventory == null || (!GearSlotsBridge.TryClassify(inventory, new Vector2i(0, 0), out var kind) && !IsGearAmmoInventory(inventory)) || !(ElementsField.GetValue(grid) is IList list))
			{
				return;
			}
			foreach (object item in list)
			{
				InventoryElement val = (InventoryElement)((item is InventoryElement) ? item : null);
				if (val != null && Object.op_Implicit((Object)(object)val))
				{
					Vector2i position = val.Position;
					GameObject orCreateHighlight = GetOrCreateHighlight(((Component)val).gameObject);
					ItemData itemAt = inventory.GetItemAt(position.x, position.y);
					orCreateHighlight.SetActive(GearSlotsBridge.TryClassify(inventory, position, out kind) && IsTarget(itemAt));
				}
			}
		}

		internal static List<ItemData> HideTargets(Inventory inventory)
		{
			List<ItemData> allItems = inventory.GetAllItems();
			List<ItemData> list = allItems.FindAll(IsTarget);
			foreach (ItemData item in list)
			{
				allItems.Remove(item);
			}
			return list;
		}

		internal static void RestockNearby()
		{
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			Player localPlayer = Player.m_localPlayer;
			if (!ModConfig.Enabled.Value || (Object)(object)localPlayer == (Object)null)
			{
				return;
			}
			List<RestockProfile> list = LoadProfiles(localPlayer);
			SynchronizeLiveTargets(localPlayer, list);
			if (list.Count == 0)
			{
				SaveProfiles(localPlayer, list);
				return;
			}
			IReadOnlyList<Container> eligibleContainersForTransfer = NearbyResourceService.GetEligibleContainersForTransfer(((Component)localPlayer).transform.position);
			Dictionary<Container, List<TransferRecord>> dictionary = new Dictionary<Container, List<TransferRecord>>();
			foreach (RestockProfile item in list.ToList())
			{
				Inventory inventory = GearSlotsBridge.GetInventory(localPlayer, item.InventoryKind);
				if (inventory == null || item.X < 0 || item.Y < 0 || item.X >= inventory.GetWidth() || item.Y >= inventory.GetHeight())
				{
					continue;
				}
				ItemData itemAt = inventory.GetItemAt(item.X, item.Y);
				if (itemAt != null && (!RestockMarker.TryRead(itemAt.m_customData, out string id, out int _) || !string.Equals(id, item.Id, StringComparison.Ordinal)))
				{
					continue;
				}
				int num;
				if (itemAt == null)
				{
					num = int.MaxValue;
				}
				else
				{
					item.Target = RestockTargetPolicy.GetTarget(itemAt.m_shared.m_maxStackSize);
					num = Mathf.Max(0, item.Target - itemAt.m_stack);
				}
				if (num == 0)
				{
					continue;
				}
				foreach (Container item2 in eligibleContainersForTransfer)
				{
					if (num == 0)
					{
						break;
					}
					if (!NearbyResourceService.TryEnsureOwnership(item2))
					{
						continue;
					}
					Inventory inventory2 = item2.GetInventory();
					foreach (ItemData item3 in new List<ItemData>(inventory2.GetAllItems()))
					{
						if (num == 0)
						{
							break;
						}
						if (!MatchesProfile(item3, item) || IsDifferentRestockTarget(item3, item) || !HasCompatibleCustomData(item3, itemAt))
						{
							continue;
						}
						if (itemAt == null)
						{
							item.Target = RestockTargetPolicy.GetTarget(item3.m_shared.m_maxStackSize);
							num = item.Target;
						}
						int num2 = MoveToTarget(inventory2, item3, inventory, item, itemAt, Mathf.Min(num, ChestReserveStore.Available(item2, item3)));
						if (num2 > 0)
						{
							itemAt = inventory.GetItemAt(item.X, item.Y);
							num = ((itemAt != null) ? Mathf.Max(0, itemAt.m_shared.m_maxStackSize - itemAt.m_stack) : 0);
							if (!dictionary.TryGetValue(item2, out var value))
							{
								value = new List<TransferRecord>();
								dictionary.Add(item2, value);
							}
							value.Add(new TransferRecord(item3.m_shared.m_name, item3.GetIcon(), num2, item3.m_shared.m_maxStackSize));
						}
					}
				}
			}
			SaveProfiles(localPlayer, list);
			foreach (KeyValuePair<Container, List<TransferRecord>> item4 in dictionary)
			{
				TransferVisuals.PlayToPlayer(item4.Value, item4.Key);
			}
		}

		internal static void PersistLiveProfiles(Player player)
		{
			if (!((Object)(object)player != (Object)(object)Player.m_localPlayer))
			{
				List<RestockProfile> profiles = LoadProfiles(player);
				SynchronizeLiveTargets(player, profiles);
				SaveProfiles(player, profiles);
			}
		}

		private static int MoveToTarget(Inventory source, ItemData sourceItem, Inventory destination, RestockProfile profile, ItemData? targetItem, int requested)
		{
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			int num = Mathf.Min(requested, sourceItem.m_stack);
			if (targetItem != null)
			{
				num = Mathf.Min(num, targetItem.m_shared.m_maxStackSize - targetItem.m_stack);
				if (num <= 0)
				{
					return 0;
				}
				targetItem.m_stack += num;
				RemoveFromSource(source, sourceItem, num, profile.Id);
				destination.m_onChanged?.Invoke();
				GearSlotsBridge.NotifyChanged(destination);
				return num;
			}
			ItemData val = sourceItem.Clone();
			val.m_stack = num;
			val.m_gridPos = new Vector2i(profile.X, profile.Y);
			val.m_customData.Remove("com.jg224.gearslots.item-id");
			RestockMarker.Clear(val.m_customData);
			RestockMarker.Set(val.m_customData, profile.Id, profile.Target);
			if (!destination.AddItem(val, new Vector2i(profile.X, profile.Y)))
			{
				return 0;
			}
			RemoveFromSource(source, sourceItem, num, profile.Id);
			GearSlotsBridge.NotifyChanged(destination);
			return num;
		}

		private static void RemoveFromSource(Inventory source, ItemData item, int amount, string fulfilledProfileId)
		{
			item.m_stack -= amount;
			if (item.m_stack <= 0)
			{
				source.RemoveItem(item);
				return;
			}
			if (RestockMarker.TryRead(item.m_customData, out string id, out int _) && string.Equals(id, fulfilledProfileId, StringComparison.Ordinal))
			{
				RestockMarker.Clear(item.m_customData);
			}
			source.m_onChanged?.Invoke();
		}

		private static bool MatchesProfile(ItemData item, RestockProfile profile)
		{
			if (item != null && !item.m_shared.m_questItem && item.m_shared.m_maxStackSize > 1 && string.Equals(ValheimItemCategoryClassifier.PrefabName(item), profile.PrefabName, StringComparison.OrdinalIgnoreCase) && item.m_quality == profile.Quality)
			{
				return item.m_variant == profile.Variant;
			}
			return false;
		}

		private static bool IsDifferentRestockTarget(ItemData item, RestockProfile profile)
		{
			if (RestockMarker.TryRead(item.m_customData, out string id, out int _))
			{
				return !string.Equals(id, profile.Id, StringComparison.Ordinal);
			}
			return false;
		}

		private static bool HasCompatibleCustomData(ItemData source, ItemData? target)
		{
			if (target == null)
			{
				return !FilteredCustomData(source).Any();
			}
			return FilteredCustomData(source).OrderBy<KeyValuePair<string, string>, string>((KeyValuePair<string, string> pair) => pair.Key, StringComparer.Ordinal).SequenceEqual<KeyValuePair<string, string>>(FilteredCustomData(target).OrderBy<KeyValuePair<string, string>, string>((KeyValuePair<string, string> pair) => pair.Key, StringComparer.Ordinal), CustomDataComparer.Instance);
		}

		private static IEnumerable<KeyValuePair<string, string>> FilteredCustomData(ItemData item)
		{
			return item.m_customData.Where((KeyValuePair<string, string> pair) => !string.Equals(pair.Key, "ChestFlow.RestockId", StringComparison.Ordinal) && !string.Equals(pair.Key, "ChestFlow.RestockTarget", StringComparison.Ordinal) && !string.Equals(pair.Key, "ChestFlow.StackLocked", StringComparison.Ordinal) && !string.Equals(pair.Key, "com.jg224.gearslots.item-id", StringComparison.Ordinal));
		}

		private static void SynchronizeLiveTargets(Player player, List<RestockProfile> profiles)
		{
			Dictionary<string, RestockProfile> dictionary = profiles.ToDictionary<RestockProfile, string>((RestockProfile profile) => profile.Id, StringComparer.Ordinal);
			HashSet<string> hashSet = new HashSet<string>(StringComparer.Ordinal);
			foreach (TrackedItem item in EnumerateTrackedItems(player))
			{
				if (!RestockMarker.TryRead(item.Item.m_customData, out string id, out int target))
				{
					continue;
				}
				if (!hashSet.Add(id))
				{
					RestockMarker.Clear(item.Item.m_customData);
					item.Inventory.m_onChanged?.Invoke();
					GearSlotsBridge.NotifyChanged(item.Inventory);
					continue;
				}
				int target2 = RestockTargetPolicy.GetTarget(item.Item.m_shared.m_maxStackSize);
				if (target != target2)
				{
					target = target2;
					RestockMarker.Set(item.Item.m_customData, id, target);
					item.Inventory.m_onChanged?.Invoke();
					GearSlotsBridge.NotifyChanged(item.Inventory);
				}
				RestockProfile restockProfile = CreateProfile(id, item.Kind, item.Item, target);
				if (dictionary.TryGetValue(id, out var value))
				{
					CopyProfile(restockProfile, value);
					continue;
				}
				profiles.Add(restockProfile);
				dictionary.Add(id, restockProfile);
			}
		}

		private static IEnumerable<TrackedItem> EnumerateTrackedItems(Player player)
		{
			Inventory main = ((Humanoid)player).GetInventory();
			foreach (ItemData allItem in main.GetAllItems())
			{
				yield return new TrackedItem(main, RestockInventoryKind.Player, allItem);
			}
			Inventory quick = GearSlotsBridge.GetInventory(player, RestockInventoryKind.GearSlotsQuick);
			if (quick != null)
			{
				foreach (ItemData allItem2 in quick.GetAllItems())
				{
					yield return new TrackedItem(quick, RestockInventoryKind.GearSlotsQuick, allItem2);
				}
			}
			Inventory inventory = GearSlotsBridge.GetInventory(player, RestockInventoryKind.GearSlotsAmmo);
			ItemData val = ((inventory != null) ? inventory.GetItemAt(5, 0) : null);
			if (inventory != null && val != null)
			{
				yield return new TrackedItem(inventory, RestockInventoryKind.GearSlotsAmmo, val);
			}
		}

		private static RestockProfile CreateProfile(string id, RestockInventoryKind kind, ItemData item, int target)
		{
			return new RestockProfile(id, kind, item.m_gridPos.x, item.m_gridPos.y, ValheimItemCategoryClassifier.PrefabName(item), item.m_quality, item.m_variant, target);
		}

		private static void CopyProfile(RestockProfile source, RestockProfile destination)
		{
			destination.InventoryKind = source.InventoryKind;
			destination.X = source.X;
			destination.Y = source.Y;
			destination.PrefabName = source.PrefabName;
			destination.Quality = source.Quality;
			destination.Variant = source.Variant;
			destination.Target = source.Target;
		}

		private static List<RestockProfile> LoadProfiles(Player player)
		{
			if (!player.m_customData.TryGetValue("com.jg224.chestflow.restock-profiles", out var value))
			{
				return new List<RestockProfile>();
			}
			if (RestockProfileCodec.TryDeserialize(value, out List<RestockProfile> profiles))
			{
				return profiles;
			}
			if (!_reportedInvalidData)
			{
				_reportedInvalidData = true;
				Plugin.LogInstance.LogWarning((object)"Ignored invalid saved ChestFlow restock profile data.");
			}
			return new List<RestockProfile>();
		}

		private static void SaveProfiles(Player player, List<RestockProfile> profiles)
		{
			if (profiles.Count == 0)
			{
				player.m_customData.Remove("com.jg224.chestflow.restock-profiles");
			}
			else
			{
				player.m_customData["com.jg224.chestflow.restock-profiles"] = RestockProfileCodec.Serialize(profiles);
			}
		}

		private static bool IsGearAmmoInventory(Inventory inventory)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			if (GearSlotsBridge.TryClassify(inventory, new Vector2i(5, 0), out var kind))
			{
				return kind == RestockInventoryKind.GearSlotsAmmo;
			}
			return false;
		}

		private static GameObject GetOrCreateHighlight(GameObject slot)
		{
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: 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_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: 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_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0128: 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_0154: Unknown result type (might be due to invalid IL or missing references)
			//IL_0169: Unknown result type (might be due to invalid IL or missing references)
			//IL_017a: Expected O, but got Unknown
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			Transform val = slot.transform.Find("ChestFlow_RestockHighlight");
			if ((Object)(object)val != (Object)null)
			{
				return ((Component)val).gameObject;
			}
			GameObject val2 = new GameObject("ChestFlow_RestockHighlight", new Type[4]
			{
				typeof(RectTransform),
				typeof(CanvasRenderer),
				typeof(Image),
				typeof(Outline)
			})
			{
				layer = slot.layer
			};
			val2.transform.SetParent(slot.transform, false);
			val2.transform.SetAsFirstSibling();
			RectTransform val3 = (RectTransform)val2.transform;
			val3.anchorMin = Vector2.zero;
			val3.anchorMax = Vector2.one;
			val3.offsetMin = new Vector2(2f, 2f);
			val3.offsetMax = new Vector2(-2f, -2f);
			Image component = val2.GetComponent<Image>();
			Image component2 = slot.GetComponent<Image>();
			if ((Object)(object)component2 != (Object)null)
			{
				component.sprite = component2.sprite;
				component.type = component2.type;
				((Graphic)component).material = ((Graphic)component2).material;
			}
			((Graphic)component).color = new Color(0.08f, 0.72f, 1f, 0.28f);
			((Graphic)component).raycastTarget = false;
			Outline component3 = val2.GetComponent<Outline>();
			((Shadow)component3).effectColor = new Color(0.15f, 0.85f, 1f, 0.98f);
			((Shadow)component3).effectDistance = new Vector2(2f, -2f);
			((Shadow)component3).useGraphicAlpha = false;
			return val2;
		}
	}
	internal static class StorageCommands
	{
		[Serializable]
		[CompilerGenerated]
		private sealed class <>c
		{
			public static readonly <>c <>9 = new <>c();

			public static Func<KeyValuePair<string, int>, string> <>9__1_1;

			public static ConsoleEvent <>9__1_0;

			internal void <Register>b__1_0(ConsoleEventArgs args)
			{
				if (!Plugin.IsActive)
				{
					return;
				}
				try
				{
					Player localPlayer = Player.m_localPlayer;
					if ((Object)(object)localPlayer == (Object)null)
					{
						throw new InvalidOperationException("Join a world first.");
					}
					string[] args2 = args.Args;
					if (args2.Length > 1 && args2[1] == "preview")
					{
						foreach (string item in QuickStackService.Preview(localPlayer))
						{
							args.Context.AddString(item);
						}
						return;
					}
					if (args2.Length < 3)
					{
						throw new InvalidOperationException("Use chestflow preview, reserve list/set/clear, or preset list/save/apply/delete.");
					}
					string text = args2[2];
					if (args2[1] == "preset")
					{
						localPlayer.m_customData.TryGetValue("ChestFlow.StoragePresets.v1", out var value);
						Dictionary<string, StoragePreset> dictionary = StoragePresetCodec.Decode(value);
						if (text == "list")
						{
							args.Context.AddString("Storage presets: " + string.Join(", ", dictionary.Keys));
							return;
						}
						string text2 = string.Join(" ", args2.Skip(3)).Trim();
						if (!StoragePresetCodec.ValidName(text2))
						{
							throw new InvalidOperationException("Use a preset name of 1–32 letters, digits, spaces, underscores or dashes.");
						}
						if (text == "delete")
						{
							if (!dictionary.Remove(text2))
							{
								throw new InvalidOperationException("Preset not found.");
							}
						}
						else
						{
							Container container = OpenChest(localPlayer);
							if (!(text == "save"))
							{
								if (text == "apply")
								{
									if (!dictionary.TryGetValue(text2, out var value2))
									{
										throw new InvalidOperationException("Preset not found.");
									}
									if (!ChestStorageRuleCodec.TryDeserialize(value2.Rule, out ChestStorageRule rule))
									{
										throw new InvalidOperationException("Preset rule is invalid.");
									}
									StorageReserves.Decode(value2.Reserves);
									if (!ChestRuleStore.TryWrite(container, rule, out string error))
									{
										throw new InvalidOperationException(error);
									}
									ChestReserveStore.Write(container, value2.Reserves);
									args.Context.AddString("Applied storage rule and reserves from " + text2 + ".");
									return;
								}
								throw new InvalidOperationException("Use preset save, apply, delete or list.");
							}
							dictionary[text2] = new StoragePreset(ChestStorageRuleCodec.Serialize(ChestRuleStore.Read(container)), ChestReserveStore.ReadRaw(container));
						}
						localPlayer.m_customData["ChestFlow.StoragePresets.v1"] = StoragePresetCodec.Encode(dictionary);
						args.Context.AddString("Updated preset " + text2 + ".");
						return;
					}
					if (args2[1] != "reserve")
					{
						throw new InvalidOperationException("Unknown ChestFlow command.");
					}
					Container container2 = OpenChest(localPlayer);
					Dictionary<string, int> dictionary2 = StorageReserves.Decode(ChestReserveStore.ReadRaw(container2));
					if (text == "list")
					{
						args.Context.AddString("Chest reserves: " + string.Join(", ", dictionary2.Select((KeyValuePair<string, int> pair) => pair.Key + "=" + pair.Value)));
						return;
					}
					if (args2.Length < 4)
					{
						throw new InvalidOperationException("A prefab name is required.");
					}
					string key = ChestStorageRule.NormalizePrefabName(args2[3]);
					if (text == "clear")
					{
						dictionary2.Remove(key);
					}
					else
					{
						if (!(text == "set") || args2.Length != 5 || !int.TryParse(args2[4], out var result) || result < 0)
						{
							throw new InvalidOperationException("Use reserve set <prefab> <minimum> or reserve clear <prefab>.");
						}
						dictionary2[key] = result;
					}
					ChestReserveStore.Write(container2, StorageReserves.Encode(dictionary2));
					args.Context.AddString("Updated reserves for the open chest.");
				}
				catch (Exception ex)
				{
					args.Context.AddString("ChestFlow: " + ex.Message);
				}
			}

			internal string <Register>b__1_1(KeyValuePair<string, int> pair)
			{
				return pair.Key + "=" + pair.Value;
			}
		}

		private const string PresetsKey = "ChestFlow.StoragePresets.v1";

		internal static void Register()
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Expected O, but got Unknown
			object obj = <>c.<>9__1_0;
			if (obj == null)
			{
				ConsoleEvent val = delegate(ConsoleEventArgs args)
				{
					if (!Plugin.IsActive)
					{
						return;
					}
					try
					{
						Player localPlayer = Player.m_localPlayer;
						if ((Object)(object)localPlayer == (Object)null)
						{
							throw new InvalidOperationException("Join a world first.");
						}
						string[] args2 = args.Args;
						if (args2.Length > 1 && args2[1] == "preview")
						{
							foreach (string item in QuickStackService.Preview(localPlayer))
							{
								args.Context.AddString(item);
							}
							return;
						}
						if (args2.Length < 3)
						{
							throw new InvalidOperationException("Use chestflow preview, reserve list/set/clear, or preset list/save/apply/delete.");
						}
						string text = args2[2];
						if (args2[1] == "preset")
						{
							localPlayer.m_customData.TryGetValue("ChestFlow.StoragePresets.v1", out var value);
							Dictionary<string, StoragePreset> dictionary = StoragePresetCodec.Decode(value);
							if (text == "list")
							{
								args.Context.AddString("Storage presets: " + string.Join(", ", dictionary.Keys));
							}
							else
							{
								string text2 = string.Join(" ", args2.Skip(3)).Trim();
								if (!StoragePresetCodec.ValidName(text2))
								{
									throw new InvalidOperationException("Use a preset name of 1–32 letters, digits, spaces, underscores or dashes.");
								}
								if (text == "delete")
								{
									if (!dictionary.Remove(text2))
									{
										throw new InvalidOperationException("Preset not found.");
									}
								}
								else
								{
									Container container = OpenChest(localPlayer);
									if (!(text == "save"))
									{
										if (text == "apply")
										{
											if (!dictionary.TryGetValue(text2, out var value2))
											{
												throw new InvalidOperationException("Preset not found.");
											}
											if (!ChestStorageRuleCodec.TryDeserialize(value2.Rule, out ChestStorageRule rule))
											{
												throw new InvalidOperationException("Preset rule is invalid.");
											}
											StorageReserves.Decode(value2.Reserves);
											if (!ChestRuleStore.TryWrite(container, rule, out string error))
											{
												throw new InvalidOperationException(error);
											}
											ChestReserveStore.Write(container, value2.Reserves);
											args.Context.AddString("Applied storage rule and reserves from " + text2 + ".");
											return;
										}
										throw new InvalidOperationException("Use preset save, apply, delete or list.");
									}
									dictionary[text2] = new StoragePreset(ChestStorageRuleCodec.Serialize(ChestRuleStore.Read(container)), ChestReserveStore.ReadRaw(container));
								}
								localPlayer.m_customData["ChestFlow.StoragePresets.v1"] = StoragePresetCodec.Encode(dictionary);
								args.Context.AddString("Updated preset " + text2 + ".");
							}
						}
						else
						{
							if (args2[1] != "reserve")
							{
								throw new InvalidOperationException("Unknown ChestFlow command.");
							}
							Container container2 = OpenChest(localPlayer);
							Dictionary<string, int> dictionary2 = StorageReserves.Decode(ChestReserveStore.ReadRaw(container2));
							if (text == "list")
							{
								args.Context.AddString("Chest reserves: " + string.Join(", ", dictionary2.Select((KeyValuePair<string, int> pair) => pair.Key + "=" + pair.Value)));
							}
							else
							{
								if (args2.Length < 4)
								{
									throw new InvalidOperationException("A prefab name is required.");
								}
								string key = ChestStorageRule.NormalizePrefabName(args2[3]);
								if (text == "clear")
								{
									dictionary2.Remove(key);
								}
								else
								{
									if (!(text == "set") || args2.Length != 5 || !int.TryParse(args2[4], out var result) || result < 0)
									{
										throw new InvalidOperationException("Use reserve set <prefab> <minimum> or reserve clear <prefab>.");
									}
									dictionary2[key] = result;
								}
								ChestReserveStore.Write(container2, StorageReserves.Encode(dictionary2));
								args.Context.AddString("Updated reserves for the open chest.");
							}
						}
					}
					catch (Exception ex)
					{
						args.Context.AddString("ChestFlow: " + ex.Message);
					}
				};
				<>c.<>9__1_0 = val;
				obj = (object)val;
			}
			new ConsoleCommand("chestflow", "preview; reserve list/set <prefab> <minimum>/clear <prefab>; preset list/save/apply/delete <name>", (ConsoleEvent)obj, false, false, false, false, false, false, (ConsoleOptionsFetcher)null, false, false, false);
		}

		private static Container OpenChest(Player player)
		{
			Container val = InventoryAccess.CurrentContainer(InventoryGui.instance);
			if ((Object)(object)val == (Object)null || AutoFeedService.IsLocked(val) || !val.IsOwner() || !MultiUserContainerService.HasAccess(val, player.GetPlayerID()) || !ChestAuthority.WardAccess(val, player.GetPlayerID()))
			{
				throw new InvalidOperationException("Open an accessible chest and wait for ownership first.");
			}
			return val;
		}
	}
	internal static class TransferContext
	{
		internal static Container? Container { get; private set; }

		internal static List<TransferRecord>? Records { get; private set; }

		internal static bool Active
		{
			get
			{
				if ((Object)(object)Container != (Object)null)
				{
					return Records != null;
				}
				return false;
			}
		}

		internal static void Begin(Container container, List<TransferRecord> records)
		{
			Container = container;
			Records = records;
		}

		internal static void End()
		{
			Container = null;
			Records = null;
		}
	}
	internal sealed class TransferRecord
	{
		internal string ItemName { get; }

		internal Sprite? Icon { get; }

		internal int Amount { get; }

		internal int MaxStackSize { get; }

		internal TransferRecord(string itemName, Sprite? icon, int amount, int maxStackSize)
		{
			ItemName = itemName;
			Icon = icon;
			Amount = amount;
			MaxStackSize = maxStackSize;
		}
	}
	internal static class TransferVisuals
	{
		private sealed class FlightGroup
		{
			internal Sprite? Icon;

			internal int Amount;

			internal int MaxStackSize;
		}

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

		private static int _nextDestinationAnimationToken;

		internal static void Play(IReadOnlyCollection<TransferRecord> records, Container container)
		{
			Play(records, container, toPlayer: false);
		}

		internal static void PlayToPlayer(IReadOnlyCollection<TransferRecord> records, Container container)
		{
			Play(records, container, toPlayer: true);
		}

		private static void Play(IReadOnlyCollection<TransferRecord> records, Container container, bool toPlayer)
		{
			if (!ModConfig.ShowTransferFlights.Value || records.Count == 0 || (Object)(object)container == (Object)null)
			{
				return;
			}
			Dictionary<string, FlightGroup> dictionary = new Dictionary<string, FlightGroup>();
			foreach (TransferRecord record in records)
			{
				if (!dictionary.TryGetValue(record.ItemName, out var value))
				{
					value = new FlightGroup
					{
						Icon = record.Icon,
						MaxStackSize = record.MaxStackSize
					};
					dictionary.Add(record.ItemName, value);
				}
				value.Amount += record.Amount;
			}
			int num = 0;
			float num2 = 0f;
			bool flag = false;
			foreach (FlightGroup value2 in dictionary.Values)
			{
				if (!((Object)(object)value2.Icon == (Object)null))
				{
					int num3 = Mathf.Max(1, Mathf.CeilToInt((float)value2.Amount / (float)Mathf.Max(1, value2.MaxStackSize)));
					int num4 = Mathf.Min(ModConfig.MaxFlightsPerItem.Value, num3);
					for (int i = 0; i < num4; i++)
					{
						float num5 = (float)num * 0.035f + (float)i * 0.055f;
						num2 = Mathf.Max(num2, num5);
						flag = true;
						((MonoBehaviour)Plugin.Instance).StartCoroutine(Fly(value2.Icon, container, num5, toPlayer));
					}
					num++;
				}
			}
			if (flag)
			{
				StartDestinationAnimation(container, num2 + ModConfig.FlightDuration.Value + 0.2f);
			}
		}

		private static void StartDestinationAnimation(Container container, float duration)
		{
			if (!((Object)(object)container == (Object)null) && !container.IsInUse())
			{
				int instanceID = ((Object)container).GetInstanceID();
				int num = ++_nextDestinationAnimationToken;
				DestinationAnimationTokens[instanceID] = num;
				((MonoBehaviour)Plugin.Instance).StartCoroutine(AnimateDestination(container, instanceID, num, duration));
			}
		}

		private static IEnumerator AnimateDestination(Container container, int id, int token, float duration)
		{
			SetDestinationVisual(container, open: true);
			yield return (object)new WaitForSeconds(Mathf.Max(0.2f, duration));
			if (DestinationAnimationTokens.TryGetValue(id, out var value) && value == token)
			{
				DestinationAnimationTokens.Remove(id);
				if ((Object)(object)container != (Object)null && !container.IsInUse())
				{
					SetDestinationVisual(container, open: false);
				}
			}
		}

		private static void SetDestinationVisual(Container container, bool open)
		{
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: 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)
			if ((Object)(object)container.m_open != (Object)null)
			{
				container.m_open.SetActive(open);
			}
			if ((Object)(object)container.m_closed != (Object)null)
			{
				container.m_closed.SetActive(!open);
			}
			EffectList obj = (open ? container.m_openEffects : container.m_closeEffects);
			if (obj != null)
			{
				obj.Create(((Component)container).transform.position, ((Component)container).transform.rotation, (Transform)null, 1f, -1, default(ZDOID));
			}
		}

		private static IEnumerator Fly(Sprite icon, Container container, float delay, bool toPlayer)
		{
			if (delay > 0f)
			{
				yield return (object)new WaitForSeconds(delay);
			}
			if ((Object)(object)Player.m_localPlayer == (Object)null || (Object)(object)container == (Object)null)
			{
				yield break;
			}
			Vector3 val = ((Component)Player.m_localPlayer).transform.position + Vector3.up * 1.25f;
			Vector3 val2 = ((Component)container).transform.position + Vector3.up * 0.8f;
			Vector3 start = (toPlayer ? val2 : val);
			Vector3 end = (toPlayer ? val : val2);
			Vector3 val3 = Vector3.Cross(Vector3.up, end - start);
			Vector3 sideways = ((Vector3)(ref val3)).normalized * Random.Range(-0.35f, 0.35f);
			GameObject flight = new GameObject("ChestFlow_ItemFlight");
			SpriteRenderer renderer = flight.AddComponent<SpriteRenderer>();
			renderer.sprite = icon;
			((Renderer)renderer).sortingOrder = 32767;
			Bounds bounds = icon.bounds;
			float x = ((Bounds)(ref bounds)).size.x;
			bounds = icon.bounds;
			float num = Mathf.Max(x, ((Bounds)(ref bounds)).size.y);
			float num2 = 0.42f;
			float num3 = ((num > 0f) ? (num2 / num) : num2);
			flight.transform.localScale = Vector3.one * num3;
			float duration = ModConfig.FlightDuration.Value;
			float elapsed = 0f;
			Color baseColor = renderer.color;
			try
			{
				while (elapsed < duration && (Object)(object)container != (Object)null)
				{
					elapsed += Time.deltaTime;
					float num4 = Mathf.Clamp01(elapsed / duration);
					float num5 = num4 * num4 * (3f - 2f * num4);
					Vector3 val4 = Vector3.up * (Mathf.Sin((float)Math.PI * num5) * ModConfig.FlightArcHeight.Value);
					flight.transform.position = Vector3.Lerp(start, end, num5) + val4 + sideways * Mathf.Sin((float)Math.PI * num5);
					Camera main = Camera.main;
					if ((Object)(object)main != (Object)null)
					{
						flight.transform.rotation = ((Component)main).transform.rotation;
					}
					if (num4 > 0.75f)
					{
						baseColor.a = 1f - (num4 - 0.75f) / 0.25f;
						renderer.color = baseColor;
					}
					yield return null;
				}
			}
			finally
			{
				Object.Destroy((Object)(object)flight);
			}
		}
	}
	internal static class ValheimItemCategoryClassifier
	{
		internal static string PrefabName(ItemData item)
		{
			return ChestStorageRule.NormalizePrefabName((item != null && (Object)(object)item.m_dropPrefab != (Object)null) ? ((Object)item.m_dropPrefab).name : string.Empty);
		}

		internal static ItemCategory Classify(ItemData item)
		{
			SharedData shared = item.m_shared;
			return ItemCategoryClassifier.Classify(new ItemClassificationInput
			{
				PrefabName = PrefabName(item),
				SharedName = (shared.m_name ?? string.Empty),
				ItemType = ((object)Unsafe.As<ItemType, ItemType>(ref shared.m_itemType)/*cast due to .constrained prefix*/).ToString(),
				AttachOverrideType = ((object)Unsafe.As<ItemType, ItemType>(ref shared.m_attachOverride)/*cast due to .constrained prefix*/).ToString(),
				SkillType = ((object)Unsafe.As<SkillType, SkillType>(ref shared.m_skillType)/*cast due to .constrained prefix*/).ToString(),
				AmmoType = (shared.m_ammoType ?? string.Empty),
				IsQuestItem = shared.m_questItem,
				HasBuildPieces = ((Object)(object)shared.m_buildPieces != (Object)null),
				HasConsumeStatusEffect = ((Object)(object)shared.m_consumeStatusEffect != (Object)null),
				Value = shared.m_value,
				FoodHealth = shared.m_food,
				FoodStamina = shared.m_foodStamina,
				FoodEitr = shared.m_foodEitr
			});
		}
	}
	internal static class VanillaTooltip
	{
		internal static UITooltip? Attach(GameObject target, Component templateRoot, string topic, string text)
		{
			UITooltip tooltip = target.GetComponent<UITooltip>();
			if ((Object)(object)tooltip == (Object)null || (Object)(object)tooltip.m_tooltipPrefab == (Object)null)
			{
				UITooltip val = ((IEnumerable<UITooltip>)templateRoot.GetComponentsInChildren<UITooltip>(true)).FirstOrDefault((Func<UITooltip, bool>)((UITooltip candidate) => (Object)(object)candidate != (Object)null && (Object)(object)candidate != (Object)(object)tooltip && (Object)(object)candidate.m_tooltipPrefab != (Object)null));
				if ((Object)(object)val == (Object)null)
				{
					if ((Object)(object)tooltip != (Object)null)
					{
						((Behaviour)tooltip).enabled = false;
					}
					return null;
				}
				if (tooltip == null)
				{
					tooltip = target.AddComponent<UITooltip>();
				}
				tooltip.m_tooltipPrefab = val.m_tooltipPrefab;
			}
			((Behaviour)tooltip).enabled = true;
			tooltip.m_topic = topic;
			tooltip.m_text = text;
			return tooltip;
		}
	}
}
namespace ChestFlow.Patches
{
	[HarmonyPatch(typeof(Tameable), "TamingUpdate")]
	internal static class AutoFeedTamingUpdatePatch
	{
		private static void Postfix(Tameable __instance)
		{
			AutoFeedService.TryFeed(__instance);
		}
	}
	[HarmonyPatch(typeof(Container), "Awake")]
	internal static class ContainerUpgradeAwakePatch
	{
		private static void Postfix(Container __instance)
		{
			ChestUpgradeService.ApplyState(__instance);
		}
	}
	[HarmonyPatch(typeof(Container), "Load")]
	internal static class ContainerUpgradeLoadPatch
	{
		private static void Postfix(Container __instance, bool __result)
		{
			if (__result)
			{
				ChestUpgradeService.ApplyState(__instance);
			}
		}
	}
	[HarmonyPatch(typeof(Piece), "DropResources", new Type[] { typeof(HitData) })]
	internal static class UpgradedChestRefundPatch
	{
		private static void Prefix(Piece __instance, out Requirement[]? __state)
		{
			__state = null;
			Requirement[] array = ChestUpgradeService.AdditionalRefundRequirements(__instance);
			if (array != null && array.Length != 0)
			{
				__state = __instance.m_resources;
				__instance.m_resources = __state.Concat(array).ToArray();
			}
		}

		private static void Postfix(Piece __instance, Requirement[]? __state)
		{
			Restore(__instance, __state);
		}

		private static Exception? Finalizer(Exception? __exception, Piece __instance, Requirement[]? __state)
		{
			Restore(__instance, __state);
			return __exception;
		}

		private static void Restore(Piece piece, Requirement[]? original)
		{
			if (original != null)
			{
				piece.m_resources = original;
			}
		}
	}
	[HarmonyPatch(typeof(Container), "RPC_RequestTakeAll")]
	internal static class AutoFeedContainerTakeAllLeasePatch
	{
		private static bool Prefix(Container __instance, long uid)
		{
			if (!AutoFeedService.IsLocked(__instance))
			{
				return true;
			}
			ZNetView component = ((Component)__instance).GetComponent<ZNetView>();
			if (component != null)
			{
				component.InvokeRPC(uid, "RPC_TakeAllResponse", new object[1] { false });
			}
			return false;
		}
	}
	[HarmonyPatch(typeof(Container), "RPC_RequestStack")]
	internal static class AutoFeedContainerStackLeasePatch
	{
		private static bool Prefix(Container __instance, long uid)
		{
			if (!AutoFeedService.IsLocked(__instance))
			{
				return true;
			}
			ZNetView component = ((Component)__instance).GetComponent<ZNetView>();
			if (component != null)
			{
				component.InvokeRPC(uid, "RPC_StackResponse", new object[1] { false });
			}
			return false;
		}
	}
	[HarmonyPatch(typeof(Container), "RPC_StackResponse")]
	internal static class ContainerStackResponsePatch
	{
		private sealed class ResponseState
		{
			internal bool IsChestFlowRequest;

			internal bool Completed;

			internal Container Container;

			internal List<TransferRecord> Records = new List<TransferRecord>();
		}

		private static bool Prefix(Container __instance, bool granted, out ResponseState __state)
		{
			__state = new ResponseState
			{
				Container = __instance,
				IsChestFlowRequest = Plugin.Instance.QuickStackService.TryBeginResponse(__instance, granted)
			};
			if (__state.IsChestFlowRequest && granted)
			{
				TransferContext.Begin(__instance, __state.Records);
			}
			return !__state.IsChestFlowRequest || granted;
		}

		private static void Postfix(ResponseState __state)
		{
			Complete(__state);
		}

		private static Exception? Finalizer(Exception? __exception, ResponseState __state)
		{
			Complete(__state);
			return __exception;
		}

		private static void Complete(ResponseState state)
		{
			if (!state.Completed)
			{
				state.Completed = true;
				if (state.IsChestFlowRequest)
				{
					TransferVisuals.Play(state.Records, state.Container);
				}
				if ((Object)(object)TransferContext.Container == (Object)(object)state.Container)
				{
					TransferContext.End();
				}
			}
		}
	}
	[HarmonyPatch(typeof(Inventory), "StackAll")]
	internal static class InventoryStackAllPatch
	{
		private sealed class LockedItemState
		{
			internal Inventory Inventory;

			internal List<ItemData> Hidden = new List<ItemData>();

			internal bool Restored;
		}

		private static bool Prefix(Inventory __instance, Inventory fromInventory, ref int __result, out LockedItemState? __state)
		{
			__state = null;
			if (TransferContext.Active && (Object)(object)TransferContext.Container != (Object)null && TransferContext.Records != null && __instance == TransferContext.Container.GetInventory() && (Object)(object)Player.m_localPlayer != (Object)null && fromInventory == ((Humanoid)Player.m_localPlayer).GetInventory())
			{
				__result = QuickStackTransfer.MoveMatching(TransferContext.Container, fromInventory, TransferContext.Records);
				return false;
			}
			if ((Object)(object)Player.m_localPlayer != (Object)null && fromInventory == ((Humanoid)Player.m_localPlayer).GetInventory())
			{
				List<ItemData> list = ItemLockService.HideLockedItems(fromInventory);
				list.AddRange(RestockProfileService.HideTargets(fromInventory));
				if (list.Count > 0)
				{
					__state = new LockedItemState
					{
						Inventory = fromInventory,
						Hidden = list
					};
				}
			}
			return true;
		}

		private static void Postfix(LockedItemState? __state)
		{
			Restore(__state);
		}

		private static Exception? Finalizer(Exception? __exception, LockedItemState? __state)
		{
			Restore(__state);
			return __exception;
		}

		private static void Restore(LockedItemState? state)
		{
			if (state != null && !state.Restored)
			{
				state.Restored = true;
				ItemLockService.RestoreHiddenItems(state.Inventory, state.Hidden);
			}
		}
	}
	internal static class CraftingFromChestsContext
	{
		private static readonly FieldInfo CraftRecipeField = AccessTools.Field(typeof(InventoryGui), "m_craftRecipe");

		internal static Player? Player { get; private set; }

		internal static Recipe? Recipe { get; private set; }

		internal static bool Active
		{
			get
			{
				if ((Object)(object)Player != (Object)null)
				{
					return (Object)(object)Recipe != (Object)null;
				}
				return false;
			}
		}

		internal static void Begin(InventoryGui gui, Player player)
		{
			Player = player;
			object? value = CraftRecipeField.GetValue(gui);
			Recipe = (Recipe?)((value is Recipe) ? value : null);
		}

		internal static void End()
		{
			Player = null;
			Recipe = null;
		}
	}
	internal static class BuildingFromChestsContext
	{
		internal static Player? Player { get; private set; }

		internal static bool Active => (Object)(object)Player != (Object)null;

		internal static void Begin(Player player)
		{
			Player = player;
		}

		internal static void End()
		{
			Player = null;
		}
	}
	internal sealed class RequirementNameLayoutState : MonoBehaviour
	{
		internal bool Initialized;

		internal Vector2 BaseSizeDelta;

		internal Vector2 BaseAnchoredPosition;

		internal float BaseWidth;
	}
	[HarmonyPatch(typeof(Player), "HaveRequirementItems")]
	internal static class NearbyRecipeRequirementsPatch
	{
		private static void Postfix(Player __instance, Recipe piece, bool discover, int qualityLevel, int amount, ref bool __result)
		{
			if (!(__result || discover))
			{
				__result = NearbyResourceService.HasRecipeRequirements(__instance, piece, qualityLevel, amount);
			}
		}
	}
	[HarmonyPatch(typeof(Player), "HaveRequirements", new Type[]
	{
		typeof(Piece),
		typeof(RequirementMode)
	})]
	internal static class NearbyBuildRequirementsPatch
	{
		private static void Postfix(Player __instance, Piece piece, RequirementMode mode, ref bool __result)
		{
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			if (!__result && (int)mode == 0)
			{
				__result = NearbyResourceService.HasPieceRequirements(__instance, piece);
			}
		}
	}
	[HarmonyPatch(typeof(InventoryGui), "SetupRequirement", new Type[]
	{
		typeof(Transform),
		typeof(Requirement),
		typeof(Player),
		typeof(bool),
		typeof(int),
		typeof(int)
	})]
	internal static class NearbyRequirementDisplayPatch
	{
		private static readonly MethodInfo VanillaCountItems = AccessTools.Method(typeof(Inventory), "CountItems", new Type[3]
		{
			typeof(string),
			typeof(int),
			typeof(bool)
		}, (Type[])null);

		private static readonly MethodInfo NearbyCountItems = AccessTools.Method(typeof(NearbyRequirementDisplayPatch), "CountItemsIncludingNearbyChests", (Type[])null, (Type[])null);

		private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions)
		{
			foreach (CodeInstruction instruction in instructions)
			{
				if (CodeInstructionExtensions.Calls(instruction, VanillaCountItems))
				{
					instruction.opcode = OpCodes.Call;
					instruction.operand = NearbyCountItems;
				}
				yield return instruction;
			}
		}

		private static int CountItemsIncludingNearbyChests(Inventory inventory, string name, int quality, bool worldLevelBased)
		{
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			int result = inventory.CountItems(name, quality, worldLevelBased);
			Player localPlayer = Player.m_localPlayer;
			if (!ModConfig.CraftFromNearbyChests.Value || (Object)(object)localPlayer == (Object)null || inventory != ((Humanoid)localPlayer).GetInventory())
			{
				return result;
			}
			return NearbyResourceService.CountAvailable(localPlayer, name, quality, ((Component)localPlayer).transform.position);
		}

		private static void Postfix(Transform elementRoot, Requirement req, Player player, bool craft, int quality, int craftMultiplier, ref bool __result)
		{
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			if (!ModConfig.CraftFromNearbyChests.Value || (Object)(object)player != (Object)(object)Player.m_localPlayer || req?.m_resItem?.m_itemData?.m_shared == null)
			{
				return;
			}
			int num = req.GetAmount(quality) * craftMultiplier;
			if (num <= 0)
			{
				return;
			}
			string name = req.m_resItem.m_itemData.m_shared.m_name;
			int num2 = NearbyResourceService.CountAvailable(player, name, -1, ((Component)player).transform.position);
			Transform val = elementRoot.Find("res_amount");
			TMP_Text val2 = (((Object)(object)val != (Object)null) ? ((Component)val).GetComponent<TMP_Text>() : null);
			if ((Object)(object)val2 != (Object)null)
			{
				val2.text = $"{num} ({num2})";
				if (num2 >= num)
				{
					((Graphic)val2).color = Color.white;
				}
			}
			FitRequirementName(elementRoot);
			if (num2 >= num)
			{
				__result = true;
			}
		}

		private static void FitRequirementName(Transform elementRoot)
		{
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: 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_0087: 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_0094: 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_00f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0110: Unknown result type (might be due to invalid IL or missing references)
			//IL_0115: Unknown result type (might be due to invalid IL or missing references)
			//IL_015b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0167: Unknown result type (might be due to invalid IL or missing references)
			//IL_016c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0170: Unknown result type (might be due to invalid IL or missing references)
			//IL_0175: Unknown result type (might be due to invalid IL or missing references)
			//IL_017a: Unknown result type (might be due to invalid IL or missing references)
			//IL_017f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0183: Unknown result type (might be due to invalid IL or missing references)
			//IL_0185: 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_01a3: 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_01bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cc: Unknown result type (might be due to invalid IL or missing references)
			Transform val = elementRoot.Find("res_name");
			TMP_Text val2 = (((Object)(object)val != (Object)null) ? ((Component)val).GetComponent<TMP_Text>() : null);
			RectTransform val3 = ((val2 != null) ? val2.rectTransform : null);
			RectTransform val4 = (RectTransform)(object)((elementRoot is RectTransform) ? elementRoot : null);
			if ((Object)(object)val2 == (Object)null || (Object)(object)val3 == (Object)null || (Object)(object)val4 == (Object)null)
			{
				return;
			}
			RequirementNameLayoutState requirementNameLayoutState = ((Component)val2).GetComponent<RequirementNameLayoutState>() ?? ((Component)val2).gameObject.AddComponent<RequirementNameLayoutState>();
			Rect rect;
			if (!requirementNameLayoutState.Initialized)
			{
				requirementNameLayoutState.Initialized = true;
				requirementNameLayoutState.BaseSizeDelta = val3.sizeDelta;
				requirementNameLayoutState.BaseAnchoredPosition = val3.anchoredPosition;
				rect = val3.rect;
				requirementNameLayoutState.BaseWidth = ((Rect)(ref rect)).width;
			}
			else
			{
				val3.sizeDelta = requirementNameLayoutState.BaseSizeDelta;
				val3.anchoredPosition = requirementNameLayoutState.BaseAnchoredPosition;
			}
			val2.enableAutoSizing = false;
			val2.textWrappingMode = (TextWrappingModes)0;
			val2.overflowMode = (TextOverflowModes)0;
			RectTransform val5 = FindRequirementRow(val4, requirementNameLayoutState.BaseWidth);
			if (!((Object)(object)val5 == (Object)null))
			{
				float x = val2.GetPreferredValues(val2.text).x;
				float baseWidth = requirementNameLayoutState.BaseWidth;
				rect = val5.rect;
				float num = RequirementLabelLayout.ExpandedWidth(baseWidth, x, ((Rect)(ref rect)).width);
				if (!(num <= requirementNameLayoutState.BaseWidth + 0.5f))
				{
					val3.sizeDelta = new Vector2(requirementNameLayoutState.BaseSizeDelta.x + num - requirementNameLayoutState.BaseWidth, requirementNameLayoutState.BaseSizeDelta.y);
					rect = val4.rect;
					Vector3 val6 = ((Transform)val4).TransformPoint(Vector2.op_Implicit(((Rect)(ref rect)).center));
					float x2 = ((Transform)val5).InverseTransformPoint(val6).x;
					float baseWidth2 = requirementNameLayoutState.BaseWidth;
					rect = val5.rect;
					float num2 = RequirementLabelLayout.OffsetTowardCenter(baseWidth2, num, x2, ((Rect)(ref rect)).center.x);
					val3.anchoredPosition = requirementNameLayoutState.BaseAnchoredPosition + new Vector2(num2, 0f);
				}
			}
		}

		private static RectTransform? FindRequirementRow(RectTransform element, float baseWidth)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			Transform parent = ((Transform)element).parent;
			int num = 0;
			while (num < 4 && (Object)(object)parent != (Object)null)
			{
				RectTransform val = (RectTransform)(object)((parent is RectTransform) ? parent : null);
				if (val != null)
				{
					Rect rect = val.rect;
					if (((Rect)(ref rect)).width >= baseWidth * 2f)
					{
						return val;
					}
				}
				num++;
				parent = parent.parent;
			}
			return null;
		}
	}
	[HarmonyPatch(typeof(Player), "GetFirstRequiredItem")]
	internal static class NearbySingleIngredientSelectionPatch
	{
		private static void Postfix(Player __instance, Inventory inventory, Recipe recipe, int qualityLevel, ref int amount, ref int extraAmount, int craftMultiplier, ref ItemData? __result)
		{
			if (__result == null && inventory == ((Humanoid)__instance).GetInventory() && recipe.m_requireOnlyOneIngredient)
			{
				__result = NearbyResourceService.FindFirstRequiredItem(__instance, recipe, qualityLevel, craftMultiplier, out amount, out extraAmount);
			}
		}
	}
	[HarmonyPatch(typeof(InventoryGui), "DoCrafting")]
	internal static class NearbyCraftingContextPatch
	{
		private static void Prefix(InventoryGui __instance, Player player)
		{
			CraftingFromChestsContext.Begin(__instance, player);
		}

		private static void Postfix()
		{
			CraftingFromChestsContext.End();
		}

		private static Exception? Finalizer(Exception? __exception)
		{
			CraftingFromChestsContext.End();
			return __exception;
		}
	}
	[HarmonyPatch(typeof(Player), "UpdatePlacement", new Type[]
	{
		typeof(bool),
		typeof(float)
	})]
	internal static class NearbyBuildingContextPatch
	{
		private static void Prefix(Player __instance)
		{
			if ((Object)(object)__instance == (Object)(object)Player.m_localPlayer && ModConfig.CraftFromNearbyChests.Value)
			{
				BuildingFromChestsContext.Begin(__instance);
			}
		}

		private static void Postfix()
		{
			BuildingFromChestsContext.End();
		}

		private static Exception? Finalizer(Exception? __exception)
		{
			BuildingFromChestsContext.End();
			return __exception;
		}
	}
	[HarmonyPatch(typeof(Player), "ConsumeResources")]
	internal static class NearbyCraftingConsumptionPatch
	{
		private static bool Prefix(Player __instance, Requirement[] requirements, int qualityLevel, int itemQuality, int multiplier)
		{
			bool num = CraftingFromChestsContext.Active && (Object)(object)CraftingFromChestsContext.Player == (Object)(object)__instance;
			bool flag = BuildingFromChestsContext.Active && (Object)(object)BuildingFromChestsContext.Player == (Object)(object)__instance;
			if ((!num && !flag) || !ModConfig.CraftFromNearbyChests.Value)
			{
				return true;
			}
			NearbyResourceService.ConsumeRequirements(__instance, requirements, qualityLevel, itemQuality, multiplier);
			return false;
		}
	}
	[HarmonyPatch(typeof(Inventory), "RemoveItem", new Type[]
	{
		typeof(string),
		typeof(int),
		typeof(int),
		typeof(bool)
	})]
	internal static class NearbySingleIngredientConsumptionPatch
	{
		private static bool Prefix(Inventory __instance, string name, int amount, int itemQuality)
		{
			if (NearbyResourceService.InternalRemoval)
			{
				return true;
			}
			Player player = CraftingFromChestsContext.Player;
			Recipe recipe = CraftingFromChestsContext.Recipe;
			if ((Object)(object)player == (Object)null || (Object)(object)recipe == (Object)null || !recipe.m_requireOnlyOneIngredient || __instance != ((Humanoid)player).GetInventory() || !ModConfig.CraftFromNearbyChests.Value)
			{
				return true;
			}
			NearbyResourceService.ConsumeItem(player, name, amount, itemQuality);
			return false;
		}
	}
	[HarmonyPatch]
	internal static class GearSlotsAmmoPlacementPatch
	{
		private const string PlacementMethodName = "GearSlots.Runtime.SlotTransferService:TryPlaceInSlot";

		private static bool Prepare()
		{
			return TargetMethod() != null;
		}

		private static MethodBase? TargetMethod()
		{
			return AccessTools.Method("GearSlots.Runtime.SlotTransferService:TryPlaceInSlot", (Type[])null, (Type[])null);
		}

		private static void Postfix(bool __result, object[] __args)
		{
			string slotName = ((__args.Length <= 2) ? null : __args[2]?.ToString());
			if (!GearSlotsAmmoReplenishPolicy.ShouldEnable(__result, slotName))
			{
				return;
			}
			try
			{
				RestockProfileService.TryEnableGearSlotsAmmoTarget();
			}
			catch (Exception ex)
			{
				Plugin.LogInstance.LogWarning((object)("Could not enable Replenish for the GearSlots Ammo stack: " + ex.Message));
			}
		}
	}
	[HarmonyPatch(typeof(InventoryGui), "Awake")]
	internal static class InventoryGuiAwakePatch
	{
		private static void Postfix(InventoryGui __instance)
		{
			InventoryButtons.Attach(__instance);
		}
	}
	[HarmonyPatch(typeof(InventoryGui), "OnDestroy")]
	internal static class InventoryGuiDestroyPatch
	{
		private static void Prefix(InventoryGui __instance)
		{
			InventoryButtons.Detach(__instance);
		}
	}
	[HarmonyPatch(typeof(InventoryGui), "OnSelectedItem", new Type[]
	{
		typeof(InventoryGrid),
		typeof(ItemData),
		typeof(Vector2i),
		typeof(Modifier)
	})]
	[HarmonyPriority(800)]
	internal static class InventoryGuiItemModePatch
	{
		private static bool Prefix(InventoryGrid grid, ItemData? item, Modifier mod, ItemData? ___m_dragItem)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			if ((int)mod != 0 || ___m_dragItem != null)
			{
				return true;
			}
			return !ItemInteractionModeService.TryCycle(grid, item);
		}
	}
	[HarmonyPatch(typeof(InventoryGrid), "UpdateInventory", new Type[]
	{
		typeof(Inventory),
		typeof(Player),
		typeof(ItemData)
	})]
	internal static class InventoryGridItemLockHighlightPatch
	{
		private static void Postfix(InventoryGrid __instance)
		{
			ItemLockService.RefreshHighlights(__instance);
			RestockProfileService.RefreshHighlights(__instance);
		}
	}
	[HarmonyPatch(typeof(Player), "Save")]
	internal static class PlayerRestockProfileSavePatch
	{
		private static void Prefix(Player __instance)
		{
			RestockProfileService.PersistLiveProfiles(__instance);
		}
	}
	[HarmonyPatch(typeof(Container), "Awake")]
	internal static class MultiUserContainerAwakePatch
	{
		private static void Postfix(Container __instance)
		{
			MultiUserContainerService.Attach(__instance);
		}
	}
	[HarmonyPatch(typeof(Container), "RPC_RequestOpen")]
	internal static class MultiUserContainerOpenPatch
	{
		private static bool Prefix(Container __instance, long uid, long playerID)
		{
			if (AutoFeedService.IsLocked(__instance))
			{
				ZNetView component = ((Component)__instance).GetComponent<ZNetView>();
				if (component != null)
				{
					component.InvokeRPC(uid, "RPC_OpenResponse", new object[1] { false });
				}
				return false;
			}
			return !MultiUserContainerService.TryHandleBusyOpen(__instance, uid, playerID);
		}
	}
	[HarmonyPatch(typeof(Container), "SetInUse")]
	internal static class MultiUserContainerUseStatePatch
	{
		private static bool Prefix(Container __instance, bool inUse)
		{
			return !MultiUserContainerService.SetLocalUseState(__instance, inUse);
		}
	}
	[HarmonyPatch(typeof(InventoryGui), "OnSelectedItem")]
	[HarmonyPriority(0)]
	internal static class MultiUserSelectedItemPatch
	{
		private static readonly FieldInfo DragInventoryField = AccessTools.Field(typeof(InventoryGui), "m_dragInventory");

		private static readonly FieldInfo DragItemField = AccessTools.Field(typeof(InventoryGui), "m_dragItem");

		private static readonly MethodInfo SelectedItemMethod = AccessTools.Method(typeof(InventoryGui), "OnSelectedItem", (Type[])null, (Type[])null);

		private static readonly MethodInfo SetupDragItemMethod = AccessTools.Method(typeof(InventoryGui), "SetupDragItem", (Type[])null, (Type[])null);

		private static bool Prefix(InventoryGui __instance, InventoryGrid grid, ItemData? item, Vector2i pos, Modifier mod)
		{
			//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_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			if (MultiUserContainerService.IsReplaying)
			{
				return true;
			}
			Container container = InventoryAccess.CurrentContainer(__instance);
			if ((Object)(object)container == (Object)null)
			{
				return true;
			}
			Inventory gridInventory = grid.GetInventory();
			Inventory dragInventory = default(Inventory);
			ref Inventory reference = ref dragInventory;
			object? value = DragInventoryField.GetValue(__instance);
			reference = (Inventory)((value is Inventory) ? value : null);
			ItemData draggedItem = default(ItemData);
			ref ItemData reference2 = ref draggedItem;
			object? value2 = DragItemField.GetValue(__instance);
			reference2 = (ItemData)((value2 is ItemData) ? value2 : null);
			Inventory chestInventory = container.GetInventory();
			if (gridInventory != chestInventory && dragInventory != chestInventory)
			{
				return true;
			}
			ItemData selectedBeforeRequest = item;
			Vector2i draggedPosition = (Vector2i)(((??)draggedItem?.m_gridPos) ?? new Vector2i(-1, -1));
			return !MultiUserContainerService.TryDeferUntilOwned(container, delegate
			{
				//IL_0111: 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)
				if (!((Object)(object)InventoryAccess.CurrentContainer(__instance) != (Object)(object)container))
				{
					Inventory inventory = grid.GetInventory();
					ItemData val = ((inventory != null) ? inventory.GetItemAt(pos.x, pos.y) : null);
					if (gridInventory == chestInventory && !SameItemIdentity(selectedBeforeRequest, val))
					{
						TellPlayer("The shared chest changed. Try that item move again.");
					}
					else
					{
						if (dragInventory == chestInventory && draggedItem != null)
						{
							ItemData itemAt = chestInventory.GetItemAt(draggedPosition.x, draggedPosition.y);
							if (!SameItemIdentity(draggedItem, itemAt))
							{
								SetupDragItemMethod.Invoke(__instance, new object[3] { null, null, 1 });
								TellPlayer("The shared chest changed, so the held item was released safely.");
								return;
							}
							DragItemField.SetValue(__instance, itemAt);
						}
						SelectedItemMethod.Invoke(__instance, new object[4] { grid, val, pos, mod });
					}
				}
			});
		}

		private static bool SameItemIdentity(ItemData? before, ItemData? current)
		{
			if (before == null || current == null)
			{
				return before == current;
			}
			if (string.Equals(before.m_shared.m_name, current.m_shared.m_name, StringComparison.Ordinal) && before.m_quality == current.m_quality)
			{
				return before.m_variant == current.m_variant;
			}
			return false;
		}

		private static void TellPlayer(string message)
		{
			Player localPlayer = Player.m_localPlayer;
			if (localPlayer != null)
			{
				((Character)localPlayer).Message((MessageType)2, message, 0, (Sprite)null, false);
			}
		}
	}
	[HarmonyPatch(typeof(InventoryGui), "OnRightClickItem")]
	internal static class MultiUserRightClickItemPatch
	{
		private static readonly MethodInfo RightClickMethod = AccessTools.Method(typeof(InventoryGui), "OnRightClickItem", (Type[])null, (Type[])null);

		private static bool Prefix(InventoryGui __instance, InventoryGrid grid, ItemData? item, Vector2i pos)
		{
			//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)
			if (MultiUserContainerService.IsReplaying)
			{
				return true;
			}
			Container container = InventoryAccess.CurrentContainer(__instance);
			if ((Object)(object)container == (Object)null || grid.GetInventory() != container.GetInventory())
			{
				return true;
			}
			return !MultiUserContainerService.TryDeferUntilOwned(container, delegate
			{
				//IL_0068: Unknown result type (might be due to invalid IL or missing references)
				if (!((Object)(object)InventoryAccess.CurrentContainer(__instance) != (Object)(object)container))
				{
					Inventory inventory = grid.GetInventory();
					ItemData val = ((inventory != null) ? inventory.GetItemAt(pos.x, pos.y) : null);
					RightClickMethod.Invoke(__instance, new object[3] { grid, val, pos });
				}
			});
		}
	}
	[HarmonyPatch(typeof(InventoryGui), "OnTakeAll")]
	internal static class MultiUserTakeAllPatch
	{
		private static readonly MethodInfo TakeAllMethod = AccessTools.Method(typeof(InventoryGui), "OnTakeAll", (Type[])null, (Type[])null);

		private static bool Prefix(InventoryGui __instance)
		{
			if (MultiUserContainerService.IsReplaying)
			{
				return true;
			}
			Container container = InventoryAccess.CurrentContainer(__instance);
			if ((Object)(object)container == (Object)null)
			{
				return true;
			}
			return !MultiUserContainerService.TryDeferUntilOwned(container, delegate
			{
				if ((Object)(object)InventoryAccess.CurrentContainer(__instance) == (Object)(object)container)
				{
					TakeAllMethod.Invoke(__instance, Array.Empty<object>());
				}
			});
		}
	}
	[HarmonyPatch(typeof(InventoryGui), "OnStackAll")]
	internal static class MultiUserStackAllPatch
	{
		private static readonly MethodInfo StackAllMethod = AccessTools.Method(typeof(InventoryGui), "OnStackAll", (Type[])null, (Type[])null);

		private static bool Prefix(InventoryGui __instance)
		{
			if (MultiUserContainerService.IsReplaying)
			{
				return true;
			}
			Container container = InventoryAccess.CurrentContainer(__instance);
			if ((Object)(object)container == (Object)null)
			{
				return true;
			}
			return !MultiUserContainerService.TryDeferUntilOwned(container, delegate
			{
				if ((Object)(object)InventoryAccess.CurrentContainer(__instance) == (Object)(object)container)
				{
					StackAllMethod.Invoke(__instance, Array.Empty<object>());
				}
			});
		}
	}
	internal static class ProductionLoanCompletion
	{
		internal static void Complete(ProductionItemLoan? loan)
		{
			loan?.ReturnIfPresent();
		}
	}
	[HarmonyPatch(typeof(Smelter), "OnAddOre")]
	internal static class SmelterOreFromChestsPatch
	{
		private static void Prefix(Smelter __instance, Humanoid user, ItemData? item, out ProductionItemLoan? __state)
		{
			__state = null;
			if (item != null)
			{
				return;
			}
			if (KilnWoodService.IsCharcoalKiln(__instance))
			{
				NearbyResourceService.TryBorrowProductionItemInPriority((Component)(object)__instance, user, (ItemData candidate) => NearbyResourceService.MatchesAnyConversion(candidate, __instance.m_conversion.Select((ItemConversion conversion) => conversion.m_from)), KilnWoodService.AllowedPriority(), out __state);
				return;
			}
			NearbyResourceService.TryBorrowProductionItem((Component)(object)__instance, user, (ItemData candidate) => NearbyResourceService.MatchesAnyConversion(candidate, __instance.m_conversion.Select((ItemConversion conversion) => conversion.m_from)), out __state);
		}

		private static void Postfix(ProductionItemLoan? __state)
		{
			ProductionLoanCompletion.Complete(__state);
		}

		private static Exception? Finalizer(Exception? __exception, ProductionItemLoan? __state)
		{
			ProductionLoanCompletion.Complete(__state);
			return __exception;
		}
	}
	[HarmonyPatch(typeof(Smelter), "OnAddFuel")]
	internal static class SmelterFuelFromChestsPatch
	{
		private static void Prefix(Smelter __instance, Humanoid user, ItemData? item, out ProductionItemLoan? __state)
		{
			__state = null;
			if (item == null && !((Object)(object)__instance.m_fuelItem == (Object)null))
			{
				string fuelName = __instance.m_fuelItem.m_itemData.m_shared.m_name;
				NearbyResourceService.TryBorrowProductionItem((Component)(object)__instance, user, (ItemData candidate) => candidate.m_shared.m_name == fuelName, out __state);
			}
		}

		private static void Postfix(ProductionItemLoan? __state)
		{
			ProductionLoanCompletion.Complete(__state);
		}

		private static Exception? Finalizer(Exception? __exception, ProductionItemLoan? __state)
		{
			ProductionLoanCompletion.Complete(__state);
			return __exception;
		}
	}
	[HarmonyPatch(typeof(CookingStation), "OnAddFoodSwitch")]
	internal static class CookingFoodFromChestsPatch
	{
		private static void Prefix(CookingStation __instance, Humanoid user, ItemData? item, out ProductionItemLoan? __state)
		{
			__state = null;
			if (item != null)
			{
				return;
			}
			NearbyResourceService.TryBorrowProductionItem((Component)(object)__instance, user, (ItemData candidate) => NearbyResourceService.MatchesAnyConversion(candidate, __instance.m_conversion.Select((ItemConversion conversion) => conversion.m_from)), out __state);
		}

		private static void Postfix(ProductionItemLoan? __state)
		{
			ProductionLoanCompletion.Complete(__state);
		}

		private static Exception? Finalizer(Exception? __exception, ProductionItemLoan? __state)
		{
			ProductionLoanCompletion.Complete(__state);
			return __exception;
		}
	}
	[HarmonyPatch(typeof(CookingStation), "OnAddFuelSwitch")]
	internal static class CookingFuelFromChestsPatch
	{
		private static void Prefix(CookingStation __instance, Humanoid user, ItemData? item, out ProductionItemLoan? __state)
		{
			__state = null;
			if (item == null && !((Object)(object)__instance.m_fuelItem == (Object)null))
			{
				string fuelName = __instance.m_fuelItem.m_itemData.m_shared.m_name;
				NearbyResourceService.TryBorrowProductionItem((Component)(object)__instance, user, (ItemData candidate) => candidate.m_shared.m_name == fuelName, out __state);
			}
		}

		private static void Postfix(ProductionItemLoan? __state)
		{
			ProductionLoanCompletion.Complete(__state);
		}

		private static Exception? Finalizer(Exception? __exception, ProductionItemLoan? __state)
		{
			ProductionLoanCompletion.Complete(__state);
			return __exception;
		}
	}
	[HarmonyPatch(typeof(Fermenter), "Interact")]
	internal static class FermenterInputFromChestsPatch
	{
		private static readonly MethodInfo GetStatusMethod = AccessTools.Method(typeof(Fermenter), "GetStatus", (Type[])null, (Type[])null);

		private static void Prefix(Fermenter __instance, Humanoid user, out ProductionItemLoan? __state)
		{
			__state = null;
			object obj = GetStatusMethod.Invoke(__instance, null);
			if (obj == null || Convert.ToInt32(obj) != 0)
			{
				return;
			}
			NearbyResourceService.TryBorrowProductionItem((Component)(object)__instance, user, (ItemData candidate) => NearbyResourceService.MatchesAnyConversion(candidate, __instance.m_conversion.Select((ItemConversion conversion) => conversion.m_from)), out __state);
		}

		private static void Postfix(ProductionItemLoan? __state)
		{
			ProductionLoanCompletion.Complete(__state);
		}

		private static Exception? Finalizer(Exception? __exception, ProductionItemLoan? __state)
		{
			ProductionLoanCompletion.Complete(__state);
			return __exception;
		}
	}
	[HarmonyPatch(typeof(Fireplace), "Interact")]
	internal static class FireplaceFuelFromChestsPatch
	{
		private static void Prefix(Fireplace __instance, Humanoid user, out ProductionItemLoan? __state)
		{
			__state = null;
			if (!__instance.m_infiniteFuel && !((Object)(object)__instance.m_fuelItem == (Object)null))
			{
				string fuelName = __instance.m_fuelItem.m_itemData.m_shared.m_name;
				NearbyResourceService.TryBorrowProductionItem((Component)(object)__instance, user, (ItemData candidate) => candidate.m_shared.m_name == fuelName, out __state);
			}
		}

		private static void Postfix(ProductionItemLoan? __state)
		{
			ProductionLoanCompletion.Complete(__state);
		}

		private static Exception? Finalizer(Exception? __exception, ProductionItemLoan? __state)
		{
			ProductionLoanCompletion.Complete(__state);
			return __exception;
		}
	}
	[HarmonyPatch(typeof(Sign), "SetText")]
	internal static class SignSetTextPatch
	{
		private const string AutomaticColorKey = "ChestFlow.SignAutomaticColor";

		private static void Prefix(ref string text, out string __state)
		{
			text = SignTextColorMarkup.ApplyDefault(text, ModConfig.SignTextColor.Value, out __state);
		}

		private static void Postfix(string __state, ZNetView ___m_nview)
		{
			if (!((Object)(object)___m_nview == (Object)null) && ___m_nview.IsValid() && ___m_nview.IsOwner())
			{
				ZDO zDO = ___m_nview.GetZDO();
				if (zDO != null)
				{
					zDO.Set("ChestFlow.SignAutomaticColor", __state);
				}
			}
		}
	}
	[HarmonyPatch(typeof(Sign), "GetText")]
	internal static class SignGetTextPatch
	{
		private const string AutomaticColorKey = "ChestFlow.SignAutomaticColor";

		private static bool Prefix(Sign __instance, ref string __result, ZNetView ___m_nview)
		{
			ZDO obj = (((Object)(object)___m_nview != (Object)null && ___m_nview.IsValid()) ? ___m_nview.GetZDO() : null);
			string text = ((obj != null) ? obj.GetString("ChestFlow.SignAutomaticColor", string.Empty) : null) ?? string.Empty;
			string text2 = (((Object)(object)__instance.m_textWidget != (Object)null) ? ((TMP_Text)__instance.m_textWidget).text : string.Empty);
			__result = ((text.Length > 0) ? SignTextColorMarkup.RemoveAutomatic(text2, text) : SignTextColorMarkup.RemoveLegacyYellow(text2));
			return false;
		}
	}
}
namespace ChestFlow.Core
{
	internal static class AutoFeedPolicy
	{
		internal static bool MatchesContainerPrefix(string? prefabName, string? configuredPrefix)
		{
			string text = configuredPrefix?.Trim() ?? string.Empty;
			if (text.Length == 0)
			{
				return true;
			}
			return (prefabName ?? string.Empty).StartsWith(text, StringComparison.OrdinalIgnoreCase);
		}

		internal static bool ShouldScan(float now, float nextScanAt)
		{
			return now >= nextScanAt;
		}
	}
	public enum ChestRuleScope
	{
		Auto,
		Group,
		Categories,
		Items
	}
	public sealed class ChestStorageRule
	{
		private static readonly ChestStorageRule AutomaticRule = new ChestStorageRule(ChestRuleScope.Auto, string.Empty, Array.Empty<ItemCategory>(), Array.Empty<string>());

		private readonly HashSet<ItemCategory> _categories;

		private readonly HashSet<string> _itemPrefabNames;

		public ChestRuleScope Scope { get; }

		public string GroupId { get; }

		public IReadOnlyCollection<ItemCategory> Categories => _categories;

		public IReadOnlyCollection<string> ItemPrefabNames => _itemPrefabNames;

		public bool IsAutomatic => Scope == ChestRuleScope.Auto;

		private ChestStorageRule(ChestRuleScope scope, string groupId, IEnumerable<ItemCategory> categories, IEnumerable<string> itemPrefabNames)
		{
			Scope = scope;
			GroupId = groupId ?? string.Empty;
			_categories = new HashSet<ItemCategory>(categories ?? Array.Empty<ItemCategory>());
			_itemPrefabNames = new HashSet<string>((itemPrefabNames ?? Array.Empty<string>()).Where((string name) => !string.IsNullOrWhiteSpace(name)).Select(NormalizePrefabName), StringComparer.OrdinalIgnoreCase);
		}

		public static ChestStorageRule Automatic()
		{
			return AutomaticRule;
		}

		public static ChestStorageRule ForGroup(string groupId)
		{
			if (!ItemCategoryCatalog.TryGetGroup(groupId, out ItemCategoryGroupDefinition definition) || definition == null)
			{
				throw new ArgumentException("Unknown storage group.", "groupId");
			}
			return new ChestStorageRule(ChestRuleScope.Group, definition.Id, Array.Empty<ItemCategory>(), Array.Empty<string>());
		}

		public static ChestStorageRule ForCategories(IEnumerable<ItemCategory> categories)
		{
			ItemCategory[] array = (categories ?? Array.Empty<ItemCategory>()).Distinct().ToArray();
			if (array.Length == 0)
			{
				throw new ArgumentException("Select at least one category.", "categories");
			}
			return new ChestStorageRule(ChestRuleScope.Categories, string.Empty, array, Array.Empty<string>());
		}

		public static ChestStorageRule ForItems(IEnumerable<string> itemPrefabNames)
		{
			string[] array = (itemPrefabNames ?? Array.Empty<string>()).Where((string name) => !string.IsNullOrWhiteSpace(name)).Select(NormalizePrefabName).Distinct<string>(StringComparer.OrdinalIgnoreCase)
				.ToArray();
			if (array.Length == 0)
			{
				throw new ArgumentException("Select at least one item.", "itemPrefabNames");
			}
			return new ChestStorageRule(ChestRuleScope.Items, string.Empty, Array.Empty<ItemCategory>(), array);
		}

		public bool Matches(string prefabName, ItemCategory category)
		{
			return Scope switch
			{
				ChestRuleScope.Group => string.Equals(ItemCategoryCatalog.Get(category).GroupId, GroupId, StringComparison.OrdinalIgnoreCase), 
				ChestRuleScope.Categories => _categories.Contains(category), 
				ChestRuleScope.Items => _itemPrefabNames.Contains(NormalizePrefabName(prefabName)), 
				_ => false, 
			};
		}

		public static string NormalizePrefabName(string value)
		{
			string text = (value ?? string.Empty).Trim();
			if (text.EndsWith("(Clone)", StringComparison.OrdinalIgnoreCase))
			{
				text = text.Substring(0, text.Length - "(Clone)".Length).TrimEnd(Array.Empty<char>());
			}
			return text;
		}
	}
	public static class ChestStorageRuleCodec
	{
		private const string Version = "v1";

		public static string Serialize(ChestStorageRule rule)
		{
			if (rule == null)
			{
				throw new ArgumentNullException("rule");
			}
			return rule.Scope switch
			{
				ChestRuleScope.Auto => string.Empty, 
				ChestRuleScope.Group => "v1|group|" + rule.GroupId, 
				ChestRuleScope.Categories => "v1|categories|" + string.Join(",", rule.Categories.Select((ItemCategory category) => ItemCategoryCatalog.Get(category).Id).OrderBy<string, string>((string id) => id, StringComparer.OrdinalIgnoreCase)), 
				ChestRuleScope.Items => "v1|items|" + string.Join(",", rule.ItemPrefabNames.OrderBy<string, string>((string name) => name, StringComparer.OrdinalIgnoreCase).Select(Encode)), 
				_ => throw new ArgumentOutOfRangeException("rule", rule.Scope, "Unknown chest rule scope."), 
			};
		}

		public static bool TryDeserialize(string serialized, out ChestStorageRule rule)
		{
			rule = ChestStorageRule.Automatic();
			if (string.IsNullOrWhiteSpace(serialized))
			{
				return true;
			}
			string[] array = serialized.Split(new char[1] { '|' }, 3);
			if (array.Length != 3 || !string.Equals(array[0], "v1", StringComparison.Ordinal))
			{
				return false;
			}
			try
			{
				switch (array[1])
				{
				case "group":
					rule = ChestStorageRule.ForGroup(array[2]);
					return true;
				case "categories":
				{
					List<ItemCategory> list = new List<ItemCategory>();
					foreach (string item in SplitPayload(array[2]))
					{
						if (!ItemCategoryCatalog.TryGet(item, out ItemCategoryDefinition definition) || definition == null)
						{
							return false;
						}
						list.Add(definition.Category);
					}
					rule = ChestStorageRule.ForCategories(list);
					return true;
				}
				case "items":
					rule = ChestStorageRule.ForItems(SplitPayload(array[2]).Select(Decode));
					return true;
				default:
					return false;
				}
			}
			catch (ArgumentException)
			{
				rule = ChestStorageRule.Automatic();
				return false;
			}
			catch (FormatException)
			{
				rule = ChestStorageRule.Automatic();
				return false;
			}
		}

		private static IEnumerable<string> SplitPayload(string payload)
		{
			return from value in (payload ?? string.Empty).Split(new char[1] { ',' }, StringSplitOptions.RemoveEmptyEntries)
				select value.Trim() into value
				where value.Length > 0
				select value;
		}

		private static string Encode(string value)
		{
			return Convert.ToBase64String(Encoding.UTF8.GetBytes(value ?? string.Empty));
		}

		private static string Decode(string value)
		{
			return Encoding.UTF8.GetString(Convert.FromBase64String(value));
		}
	}
	internal static class ChestToolbarLayout
	{
		internal static float TopForButton(float chestTop, int index, float buttonHeight, float gap)
		{
			if (index < 0)
			{
				throw new ArgumentOutOfRangeException("index");
			}
			return chestTop - (float)index * (Math.Max(0f, buttonHeight) + Math.Max(0f, gap));
		}
	}
	internal static class ChestUpgradePath
	{
		internal const int WoodenTier = 0;

		internal const int ReinforcedTier = 1;

		internal const int BlackMetalTier = 2;

		internal const int GraustenTier = 3;

		internal const string WoodenPrefab = "piece_chest_wood";

		internal const string ReinforcedPrefab = "piece_chest";

		internal const string BlackMetalPrefab = "piece_chest_blackmetal";

		internal const string GraustenPrefab = "piece_chest_grausten";

		internal static int ResolveManagedTier(string prefabName, int markerTier)
		{
			if (string.Equals(prefabName, "piece_chest_wood", StringComparison.OrdinalIgnoreCase))
			{
				if (markerTier < 0 || markerTier > 2)
				{
					return -1;
				}
				return markerTier;
			}
			if (markerTier == 1 && string.Equals(prefabName, "piece_chest", StringComparison.OrdinalIgnoreCase))
			{
				return 1;
			}
			if (markerTier == 2 && string.Equals(prefabName, "piece_chest_blackmetal", StringComparison.OrdinalIgnoreCase))
			{
				return 2;
			}
			if (markerTier == 3 && string.Equals(prefabName, "piece_chest_grausten", StringComparison.OrdinalIgnoreCase))
			{
				return 3;
			}
			return -1;
		}

		internal static bool IsLegacy(string prefabName, int markerTier)
		{
			if (markerTier > 0 && markerTier <= 2)
			{
				return string.Equals(prefabName, "piece_chest_wood", StringComparison.OrdinalIgnoreCase);
			}
			return false;
		}

		internal static bool CanUpgrade(int currentTier, int targetTier)
		{
			if (currentTier >= 0 && currentTier < 3 && targetTier > currentTier)
			{
				return targetTier <= 3;
			}
			return false;
		}

		internal static string PrefabForTier(int tier)
		{
			return tier switch
			{
				0 => "piece_chest_wood", 
				1 => "piece_chest", 
				2 => "piece_chest_blackmetal", 
				3 => "piece_chest_grausten", 
				_ => throw new ArgumentOutOfRangeException("tier"), 
			};
		}

		internal static int[] ObsoleteLegacyTiers(int legacyTier)
		{
			return legacyTier switch
			{
				1 => new int[1], 
				2 => new int[2] { 0, 1 }, 
				_ => Array.Empty<int>(), 
			};
		}
	}
	public enum FeedRequestState
	{
		New,
		Pending,
		Committed,
		Rejected
	}
	public sealed class FeedRequestLedger
	{
		private sealed class Entry
		{
			internal string Context = "";

			internal double Expires;

			internal bool? Result;
		}

		private readonly Dictionary<string, Entry> entries = new Dictionary<string, Entry>(StringComparer.Ordinal);

		public FeedRequestState Begin(string key, string context, double now)
		{
			if (string.IsNullOrEmpty(key) || key.Length > 96 || context.Length > 192 || double.IsNaN(now) || double.IsInfinity(now))
			{
				return FeedRequestState.Rejected;
			}
			string[] array = (from pair in entries
				where pair.Value.Expires <= now
				select pair.Key).ToArray();
			foreach (string key2 in array)
			{
				entries.Remove(key2);
			}
			if (entries.TryGetValue(key, out Entry value))
			{
				if (value.Context != context)
				{
					return FeedRequestState.Rejected;
				}
				if (!value.Result.HasValue)
				{
					return FeedRequestState.Pending;
				}
				if (!value.Result.Value)
				{
					return FeedRequestState.Rejected;
				}
				return FeedRequestState.Committed;
			}
			if (entries.Count >= 4096)
			{
				return FeedRequestState.Rejected;
			}
			entries.Add(key, new Entry
			{
				Context = context,
				Expires = now + 120.0
			});
			return FeedRequestState.New;
		}

		public void Complete(string key, bool committed)
		{
			if (entries.TryGetValue(key, out Entry value))
			{
				value.Result = committed;
			}
		}

		public void Clear()
		{
			entries.Clear();
		}
	}
	public static class FeedTransaction
	{
		public static bool Execute(Func<bool> withdraw, Action feed, Func<bool> fed, Action persist, Action restore)
		{
			try
			{
				if (!withdraw())
				{
					throw new InvalidOperationException("Food withdrawal did not complete.");
				}
				feed();
				if (!fed())
				{
					throw new InvalidOperationException("Creature feeding did not complete.");
				}
				persist();
				return true;
			}
			catch (Exception ex)
			{
				try
				{
					restore();
				}
				catch (Exception ex2)
				{
					throw new AggregateException("Food transaction recovery needs attention.", ex, ex2);
				}
				return false;
			}
		}
	}
	internal static class GearSlotsAmmoReplenishPolicy
	{
		internal static bool ShouldEnable(bool transferSucceeded, string? slotName)
		{
			if (transferSucceeded)
			{
				return string.Equals(slotName, "Ammo", StringComparison.Ordinal);
			}
			return false;
		}
	}
	public static class InventoryOrdering
	{
		private sealed class SortableItemComparer : IComparer<SortableItem>
		{
			private readonly SortMode _mode;

			private readonly int _direction;

			public SortableItemComparer(SortMode mode, bool descending)
			{
				_mode = mode;
				_direction = ((!descending) ? 1 : (-1));
			}

			public int Compare(SortableItem? left, SortableItem? right)
			{
				if (left == right)
				{
					return 0;
				}
				if (left == null)
				{
					return -1;
				}
				if (right == null)
				{
					return 1;
				}
				int num = ComparePrimary(left, right) * _direction;
				if (num != 0)
				{
					return num;
				}
				int num2 = StringComparer.OrdinalIgnoreCase.Compare(left.InternalName, right.InternalName);
				if (num2 != 0)
				{
					return num2;
				}
				int num3 = right.Quality.CompareTo(left.Quality);
				if (num3 != 0)
				{
					return num3;
				}
				int num4 = right.Stack.CompareTo(left.Stack);
				if (num4 == 0)
				{
					return left.OriginalIndex.CompareTo(right.OriginalIndex);
				}
				return num4;
			}

			private int ComparePrimary(SortableItem left, SortableItem right)
			{
				switch (_mode)
				{
				case SortMode.Category:
				{
					int num = left.Category.CompareTo(right.Category);
					if (num == 0)
					{
						return StringComparer.CurrentCultureIgnoreCase.Compare(left.LocalizedName, right.LocalizedName);
					}
					return num;
				}
				case SortMode.Name:
					return StringComparer.CurrentCultureIgnoreCase.Compare(left.LocalizedName, right.LocalizedName);
				case SortMode.Weight:
					return left.Weight.CompareTo(right.Weight);
				case SortMode.Value:
					return left.Value.CompareTo(right.Value);
				case SortMode.Quality:
					return left.Quality.CompareTo(right.Quality);
				default:
					return 0;
				}
			}
		}

		public static IReadOnlyList<int> OrderIndices(IReadOnlyList<SortableItem> items, SortMode mode, bool descending)
		{
			if (items == null)
			{
				throw new ArgumentNullException("items");
			}
			return (from item in items.OrderBy((SortableItem item) => item, new SortableItemComparer(mode, @descending))
				select item.OriginalIndex).ToArray();
		}
	}
	public enum ItemCategory
	{
		Sword,
		Knife,
		Club,
		Axe,
		Spear,
		Polearm,
		FistWeapon,
		Bow,
		Crossbow,
		ElementalMagic,
		BloodMagic,
		Bomb,
		OtherWeapon,
		Arrow,
		Bolt,
		SiegeAmmunition,
		OtherAmmunition,
		FishingBait,
		Shield,
		Helmet,
		ChestArmor,
		LegArmor,
		HandArmor,
		Cape,
		UtilityEquipment,
		Trinket,
		Pickaxe,
		BuildingTool,
		FarmingTool,
		FishingTool,
		Torch,
		Saddle,
		OtherTool,
		HealthFood,
		StaminaFood,
		EitrFood,
		BalancedFood,
		Feast,
		Mead,
		Potion,
		OtherConsumable,
		MeadBase,
		RawMeat,
		RawFish,
		Produce,
		Mushroom,
		UncookedFood,
		Spice,
		OtherCookingIngredient,
		Wood,
		Stone,
		Ore,
		Metal,
		HideAndLeather,
		BoneAndTeeth,
		ShellAndScale,
		Textile,
		Gem,
		MechanicalComponent,
		MagicMaterial,
		PlantMaterial,
		CreatureDrop,
		Fuel,
		OtherMaterial,
		Seed,
		Egg,
		Trophy,
		Valuable,
		Firework,
		BossSummoningItem,
		BossDrop,
		Key,
		QuestItem,
		Customization,
		Miscellaneous
	}
	public sealed class ItemCategoryDefinition
	{
		public ItemCategory Category { get; }

		public string Id { get; }

		public string GroupId { get; }

		public string Group { get; }

		public string DisplayName { get; }

		public ItemCategoryDefinition(ItemCategory category, string id, string groupId, string group, string displayName)
		{
			Category = category;
			Id = id;
			GroupId = groupId;
			Group = group;
			DisplayName = displayName;
		}
	}
	public sealed class ItemCategoryGroupDefinition
	{
		public string Id { get; }

		public string DisplayName { get; }

		public ItemCategoryGroupDefinition(string id, string displayName)
		{
			Id = id;
			DisplayName = displayName;
		}
	}
	public static class ItemCategoryCatalog
	{
		private static readonly ItemCategoryGroupDefinition[] GroupDefinitions = new ItemCategoryGroupDefinition[11]
		{
			new ItemCategoryGroupDefinition("weapons", "Weapons"),
			new ItemCategoryGroupDefinition("ammunition", "Ammunition"),
			new ItemCategoryGroupDefinition("armor", "Armor & Equipment"),
			new ItemCategoryGroupDefinition("tools", "Tools"),
			new ItemCategoryGroupDefinition("food", "Food & Consumables"),
			new ItemCategoryGroupDefinition("cooking", "Cooking Ingredients"),
			new ItemCategoryGroupDefinition("materials", "Materials"),
			new ItemCategoryGroupDefinition("farming", "Farming"),
			new ItemCategoryGroupDefinition("collectibles", "Collectibles"),
			new ItemCategoryGroupDefinition("progression", "Progression"),
			new ItemCategoryGroupDefinition("misc", "Miscellaneous")
		};

		private static readonly ItemCategoryDefinition[] Definitions = new ItemCategoryDefinition[75]
		{
			Define(ItemCategory.Sword, "weapons.swords", "Weapons", "Swords"),
			Define(ItemCategory.Knife, "weapons.knives", "Weapons", "Knives"),
			Define(ItemCategory.Club, "weapons.clubs", "Weapons", "Clubs & Maces"),
			Define(ItemCategory.Axe, "weapons.axes", "Weapons", "Axes"),
			Define(ItemCategory.Spear, "weapons.spears", "Weapons", "Spears"),
			Define(ItemCategory.Polearm, "weapons.polearms", "Weapons", "Polearms"),
			Define(ItemCategory.FistWeapon, "weapons.fists", "Weapons", "Fist Weapons"),
			Define(ItemCategory.Bow, "weapons.bows", "Weapons", "Bows"),
			Define(ItemCategory.Crossbow, "weapons.crossbows", "Weapons", "Crossbows"),
			Define(ItemCategory.ElementalMagic, "weapons.elemental_magic", "Weapons", "Elemental Magic"),
			Define(ItemCategory.BloodMagic, "weapons.blood_magic", "Weapons", "Blood Magic"),
			Define(ItemCategory.Bomb, "weapons.bombs", "Weapons", "Bombs"),
			Define(ItemCategory.OtherWeapon, "weapons.other", "Weapons", "Other Weapons"),
			Define(ItemCategory.Arrow, "ammunition.arrows", "Ammunition", "Arrows"),
			Define(ItemCategory.Bolt, "ammunition.bolts", "Ammunition", "Bolts"),
			Define(ItemCategory.SiegeAmmunition, "ammunition.siege", "Ammunition", "Siege Ammunition"),
			Define(ItemCategory.OtherAmmunition, "ammunition.other", "Ammunition", "Other Ammunition"),
			Define(ItemCategory.FishingBait, "ammunition.fishing_bait", "Ammunition", "Fishing Bait"),
			Define(ItemCategory.Shield, "armor.shields", "Armor & Equipment", "Shields"),
			Define(ItemCategory.Helmet, "armor.helmets", "Armor & Equipment", "Helmets"),
			Define(ItemCategory.ChestArmor, "armor.chest", "Armor & Equipment", "Chest Armor"),
			Define(ItemCategory.LegArmor, "armor.legs", "Armor & Equipment", "Leg Armor"),
			Define(ItemCategory.HandArmor, "armor.hands", "Armor & Equipment", "Hand Armor"),
			Define(ItemCategory.Cape, "armor.capes", "Armor & Equipment", "Capes"),
			Define(ItemCategory.UtilityEquipment, "equipment.utility", "Armor & Equipment", "Utility Equipment"),
			Define(ItemCategory.Trinket, "equipment.trinkets", "Armor & Equipment", "Trinkets"),
			Define(ItemCategory.Pickaxe, "tools.pickaxes", "Tools", "Pickaxes"),
			Define(ItemCategory.BuildingTool, "tools.building", "Tools", "Building Tools"),
			Define(ItemCategory.FarmingTool, "tools.farming", "Tools", "Farming Tools"),
			Define(ItemCategory.FishingTool, "tools.fishing", "Tools", "Fishing Tools"),
			Define(ItemCategory.Torch, "tools.lights", "Tools", "Portable Lights"),
			Define(ItemCategory.Saddle, "tools.saddles", "Tools", "Saddles"),
			Define(ItemCategory.OtherTool, "tools.other", "Tools", "Other Tools"),
			Define(ItemCategory.HealthFood, "food.health", "Food & Consumables", "Health Food"),
			Define(ItemCategory.StaminaFood, "food.stamina", "Food & Consumables", "Stamina Food"),
			Define(ItemCategory.EitrFood, "food.eitr", "Food & Consumables", "Eitr Food"),
			Define(ItemCategory.BalancedFood, "food.balanced", "Food & Consumables", "Balanced Food"),
			Define(ItemCategory.Feast, "food.feasts", "Food & Consumables", "Feasts"),
			Define(ItemCategory.Mead, "consumables.meads", "Food & Consumables", "Meads"),
			Define(ItemCategory.Potion, "consumables.potions", "Food & Consumables", "Potions"),
			Define(ItemCategory.OtherConsumable, "consumables.other", "Food & Consumables", "Other Consumables"),
			Define(ItemCategory.MeadBase, "cooking.mead_bases", "Cooking Ingredients", "Mead Bases"),
			Define(ItemCategory.RawMeat, "cooking.raw_meat", "Cooking Ingredients", "Raw Meat"),
			Define(ItemCategory.RawFish, "cooking.raw_fish", "Cooking Ingredients", "Raw Fish"),
			Define(ItemCategory.Produce, "cooking.produce", "Cooking Ingredients", "Produce & Berries"),
			Define(ItemCategory.Mushroom, "cooking.mushrooms", "Cooking Ingredients", "Mushrooms"),
			Define(ItemCategory.UncookedFood, "cooking.uncooked", "Cooking Ingredients", "Uncooked Dishes"),
			Define(ItemCategory.Spice, "cooking.spices", "Cooking Ingredients", "Spices"),
			Define(ItemCategory.OtherCookingIngredient, "cooking.other", "Cooking Ingredients", "Other Cooking Ingredients"),
			Define(ItemCategory.Wood, "materials.wood", "Materials", "Wood"),
			Define(ItemCategory.Stone, "materials.stone", "Materials", "Stone"),
			Define(ItemCategory.Ore, "materials.ore", "Materials", "Ores & Scrap"),
			Define(ItemCategory.Metal, "materials.metal", "Materials", "Metals"),
			Define(ItemCategory.HideAndLeather, "materials.hides", "Materials", "Hides & Leather"),
			Define(ItemCategory.BoneAndTeeth, "materials.bones", "Materials", "Bones, Teeth & Claws"),
			Define(ItemCategory.ShellAndScale, "materials.shells", "Materials", "Shells & Scales"),
			Define(ItemCategory.Textile, "materials.textiles", "Materials", "Textiles & Fibres"),
			Define(ItemCategory.Gem, "materials.gems", "Materials", "Gems & Crystal"),
			Define(ItemCategory.MechanicalComponent, "materials.mechanical", "Materials", "Mechanical Components"),
			Define(ItemCategory.MagicMaterial, "materials.magic", "Materials", "Magic Materials"),
			Define(ItemCategory.PlantMaterial, "materials.plants", "Materials", "Plant Materials"),
			Define(ItemCategory.CreatureDrop, "materials.creature_drops", "Materials", "Creature Drops"),
			Define(ItemCategory.Fuel, "materials.fuel", "Materials", "Fuel & Resin"),
			Define(ItemCategory.OtherMaterial, "materials.other", "Materials", "Other Materials"),
			Define(ItemCategory.Seed, "farming.seeds", "Farming", "Seeds & Cones"),
			Define(ItemCategory.Egg, "farming.eggs", "Farming", "Eggs"),
			Define(ItemCategory.Trophy, "collectibles.trophies", "Collectibles", "Trophies"),
			Define(ItemCategory.Valuable, "collectibles.valuables", "Collectibles", "Valuables"),
			Define(ItemCategory.Firework, "collectibles.fireworks", "Collectibles", "Fireworks"),
			Define(ItemCategory.BossSummoningItem, "progression.boss_summoning", "Progression", "Boss Summoning Items"),
			Define(ItemCategory.BossDrop, "progression.boss_drops", "Progression", "Boss Drops"),
			Define(ItemCategory.Key, "progression.keys", "Progression", "Keys & Sealbreakers"),
			Define(ItemCategory.QuestItem, "progression.quest", "Progression", "Quest Items"),
			Define(ItemCategory.Customization, "misc.customization", "Miscellaneous", "Customization"),
			Define(ItemCategory.Miscellaneous, "misc.other", "Miscellaneous", "Miscellaneous")
		};

		private static readonly Dictionary<ItemCategory, ItemCategoryDefinition> ByCategory = BuildByCategory();

		private static readonly Dictionary<string, ItemCategoryDefinition> ById = BuildById();

		private static readonly Dictionary<string, ItemCategoryGroupDefinition> GroupsById = BuildGroupsById();

		public static IReadOnlyList<ItemCategoryDefinition> All => Definitions;

		public static IReadOnlyList<ItemCategoryGroupDefinition> Groups => GroupDefinitions;

		public static ItemCategoryDefinition Get(ItemCategory category)
		{
			if (!ByCategory.TryGetValue(category, out ItemCategoryDefinition value) || value == null)
			{
				throw new ArgumentOutOfRangeException("category", category, "Unknown item category.");
			}
			return value;
		}

		public static bool TryGet(string id, out ItemCategoryDefinition? definition)
		{
			return ById.TryGetValue(id ?? string.Empty, out definition);
		}

		public static bool TryGetGroup(string id, out ItemCategoryGroupDefinition? definition)
		{
			return GroupsById.TryGetValue(id ?? string.Empty, out definition);
		}

		public static int SortRank(ItemCategory category)
		{
			for (int i = 0; i < Definitions.Length; i++)
			{
				if (Definitions[i].Category == category)
				{
					return i;
				}
			}
			return Definitions.Length;
		}

		private static ItemCategoryDefinition Define(ItemCategory category, string id, string group, string displayName)
		{
			return new ItemCategoryDefinition(category, id, GroupId(group), group, displayName);
		}

		private static string GroupId(string displayName)
		{
			for (int i = 0; i < GroupDefinitions.Length; i++)
			{
				if (string.Equals(GroupDefinitions[i].DisplayName, displayName, StringComparison.Ordinal))
				{
					return GroupDefinitions[i].Id;
				}
			}
			throw new InvalidOperationException("Category references an unknown main group: " + displayName);
		}

		private static Dictionary<ItemCategory, ItemCategoryDefinition> BuildByCategory()
		{
			Dictionary<ItemCategory, ItemCategoryDefinition> dictionary = new Dictionary<ItemCategory, ItemCategoryDefinition>();
			ItemCategoryDefinition[] definitions = Definitions;
			foreach (ItemCategoryDefinition itemCategoryDefinition in definitions)
			{
				dictionary.Add(itemCategoryDefinition.Category, itemCategoryDefinition);
			}
			return dictionary;
		}

		private static Dictionary<string, ItemCategoryDefinition> BuildById()
		{
			Dictionary<string, ItemCategoryDefinition> dictionary = new Dictionary<string, ItemCategoryDefinition>(StringComparer.OrdinalIgnoreCase);
			ItemCategoryDefinition[] definitions = Definitions;
			foreach (ItemCategoryDefinition itemCategoryDefinition in definitions)
			{
				dictionary.Add(itemCategoryDefinition.Id, itemCategoryDefinition);
			}
			return dictionary;
		}

		private static Dictionary<string, ItemCategoryGroupDefinition> BuildGroupsById()
		{
			Dictionary<string, ItemCategoryGroupDefinition> dictionary = new Dictionary<string, ItemCategoryGroupDefinition>(StringComparer.OrdinalIgnoreCase);
			ItemCategoryGroupDefinition[] groupDefinitions = GroupDefinitions;
			foreach (ItemCategoryGroupDefinition itemCategoryGroupDefinition in groupDefinitions)
			{
				dictionary.Add(itemCategoryGroupDefinition.Id, itemCategoryGroupDefinition);
			}
			return dictionary;
		}
	}
	public static class ItemCategoryClassifier
	{
		private static readonly HashSet<string> BossSummoningItems = Names("AncientSeed", "WitheredBone", "DragonEgg", "GoblinTotem");

		private static readonly HashSet<string> BossDrops = Names("HardAntler", "DragonTear", "YagluthDrop", "QueenDrop", "FaderDrop");

		private static readonly HashSet<string> Keys = Names("CryptKey", "DvergrKey", "DvergrKeyFragment", "HildirKey_forestcrypt", "HildirKey_mountaincave", "HildirKey_plainsfortress");

		private static readonly HashSet<string> QuestItems = Names("Bell", "BellFragment", "chest_hildir1", "chest_hildir2", "chest_hildir3", "DyrnwynBladeFragment", "DyrnwynHiltFragment", "DyrnwynTipFragment");

		private static readonly HashSet<string> Valuables = Names("Amber", "AmberPearl", "Coins", "Ruby", "SilverNecklace");

		private static readonly HashSet<string> Seeds = Names("Acorn", "BeechSeeds", "BirchSeeds", "CarrotSeeds", "FirCone", "OnionSeeds", "PineCone", "TurnipSeeds", "VineberrySeeds", "VineGreenSeeds");

		private static readonly HashSet<string> Eggs = Names("AsksvinEgg", "ChickenEgg", "VoltureEgg");

		private static readonly HashSet<string> Saddles = Names("SaddleAsksvin", "SaddleLox");

		private static readonly HashSet<string> BuildingTools = Names("Feaster", "Hammer");

		private static readonly HashSet<string> FarmingTools = Names("Cultivator", "Hoe", "KnifeButcher", "Scythe");

		private static readonly HashSet<string> OtherTools = Names("BarberKit", "Tankard", "Tankard_dvergr", "TankardAnniversary", "TankardOdin");

		private static readonly HashSet<string> OtherConsumables = Names("HealthUpgrade_Bonemass", "HealthUpgrade_GDKing", "Pukeberries", "StaminaUpgrade_Greydwarf", "StaminaUpgrade_Troll", "StaminaUpgrade_Wraith");

		private static readonly HashSet<string> SiegeAmmunition = Names("BombSiege", "Catapult_ammo", "TurretBolt", "TurretBoltBone", "TurretBoltFlametal", "TurretBoltWood");

		private static readonly HashSet<string> Produce = Names("Barley", "Blueberries", "Carrot", "Cloudberry", "Fiddleheadfern", "Honey", "Onion", "Raspberry", "Turnip", "Vineberry");

		private static readonly HashSet<string> Mushrooms = Names("Mushroom", "MushroomBlue", "MushroomBzerker", "MushroomJotunPuffs", "MushroomMagecap", "MushroomSmokePuff", "MushroomYellow");

		private static readonly HashSet<string> RawMeats = Names("AsksvinMeat", "BjornMeat", "BoneMawSerpentMeat", "BugMeat", "ChickenMeat", "DeerMeat", "HareMeat", "LoxMeat", "NeckTail", "RawMeat", "RottenMeat", "SerpentMeat", "VoltureMeat", "WolfMeat");

		private static readonly HashSet<string> RawFish = Names("FishAnglerRaw", "FishRaw");

		private static readonly HashSet<string> UncookedFoods = Names("BreadDough", "FishAndBreadUncooked", "HoneyGlazedChickenUncooked", "LoxPieUncooked", "MagicallyStuffedShroomUncooked", "MeatPlatterUncooked", "MisthareSupremeUncooked", "PiquantPieUncooked", "RoastedCrustPieUncooked", "VikingCupcakeUncooked");

		private static readonly HashSet<string> OtherCookingIngredients = Names("BarleyFlour", "Bloodbag", "CuredSquirrelHamstring", "Entrails", "FragrantBundle", "FreezeGland", "FreshSeaweed", "GiantBloodSack", "GreydwarfEye", "Ooze", "PowderedDragonEgg", "PungentPebbles", "RoyalJelly", "Sap");

		private static readonly HashSet<string> Woods = Names("Blackwood", "ElderBark", "FineWood", "RoundLog", "Wood", "YggdrasilWood");

		private static readonly HashSet<string> Stones = Names("BlackMarble", "Flint", "Grausten", "Obsidian", "Stone", "StoneRock");

		private static readonly HashSet<string> Ores = Names("BlackMetalScrap", "BronzeScrap", "CopperOre", "CopperScrap", "FlametalOre", "FlametalOreNew", "IronOre", "IronScrap", "SilverOre", "TinOre");

		private static readonly HashSet<string> Metals = Names("BlackMetal", "Bronze", "Copper", "Flametal", "FlametalNew", "Iron", "Silver", "Tin");

		private static readonly HashSet<string> Hides = Names("AskHide", "BjornHide", "DeerHide", "LeatherScraps", "LoxPelt", "ScaleHide", "TrollHide", "WolfPelt");

		private static readonly HashSet<string> Bones = Names("AsksvinCarrionNeck", "AsksvinCarrionPelvic", "AsksvinCarrionRibcage", "AsksvinCarrionSkull", "BoneFragments", "BonemawSerpentTooth", "CharredBone", "Charredskull", "UndeadBjornRibcage", "WolfClaw", "WolfFang");

		private static readonly HashSet<string> Shells = Names("BonemawSerpentScale", "Carapace", "Chitin", "Mandible", "SerpentScale");

		private static readonly HashSet<string> Textiles = Names("CandleWick", "Flax", "JuteBlue", "JuteRed", "LinenThread", "MorgenSinew", "WolfHairBundle");

		private static readonly HashSet<string> Gems = Names("Crystal", "GemstoneBlue", "GemstoneGreen", "GemstoneRed");

		private static readonly HashSet<string> MechanicalComponents = Names("AxeHead1", "AxeHead2", "BarrelRings", "BronzeNails", "CeramicPlate", "Chain", "CharredCogwheel", "DvergrNeedle", "IronNails", "Ironpit", "MechanicalSpring", "ScytheHandle", "SharpeningStone");

		private static readonly HashSet<string> MagicMaterials = Names("BlackCore", "CelestialFeather", "Ectoplasm", "Eitr", "MoltenCore", "ShieldCore", "Softtissue", "SurtlingCore", "Thunderstone", "Wisp", "YmirRemains");

		private static readonly HashSet<string> PlantMaterials = Names("Dandelion", "Guck", "Root", "Thistle");

		private static readonly HashSet<string> CreatureDrops = Names("AskBladder", "Bilebag", "BjornPaw", "BlobVial", "Feathers", "Larva", "MorgenHeart", "Needle", "ProustitePowder", "QueenBee", "SulfurStone");

		private static readonly HashSet<string> Fuels = Names("CharcoalResin", "Coal", "Resin", "Tar");

		public static ItemCategory Classify(ItemClassificationInput item)
		{
			if (item == null)
			{
				throw new ArgumentNullException("item");
			}
			if (item.IsQuestItem)
			{
				return ItemCategory.QuestItem;
			}
			if (IdentityMatches(BossSummoningItems, item))
			{
				return ItemCategory.BossSummoningItem;
			}
			if (IdentityMatches(BossDrops, item))
			{
				return ItemCategory.BossDrop;
			}
			if (IdentityMatches(Keys, item))
			{
				return ItemCategory.Key;
			}
			if (IdentityMatches(QuestItems, item))
			{
				return ItemCategory.QuestItem;
			}
			if (IdentityMatches(Valuables, item))
			{
				return ItemCategory.Valuable;
			}
			if (IdentityStartsWith(item, "FireworksRocket"))
			{
				return ItemCategory.Firework;
			}
			if (IdentityMatches(SiegeAmmunition, item))
			{
				return ItemCategory.SiegeAmmunition;
			}
			if (IdentityMatches(Saddles, item))
			{
				return ItemCategory.Saddle;
			}
			if (IdentityMatches(Seeds, item))
			{
				return ItemCategory.Seed;
			}
			if (IdentityMatches(Eggs, item))
			{
				return ItemCategory.Egg;
			}
			if (IdentityStartsWith(item, "Feast"))
			{
				return ItemCategory.Feast;
			}
			if (IsMeadBase(item))
			{
				return ItemCategory.MeadBase;
			}
			if (IdentityMatches(UncookedFoods, item))
			{
				return ItemCategory.UncookedFood;
			}
			if (IdentityMatches(RawMeats, item))
			{
				return ItemCategory.RawMeat;
			}
			if (IdentityMatches(RawFish, item) || IsType(item, "Fish"))
			{
				return ItemCategory.RawFish;
			}
			if (IdentityMatches(Mushrooms, item))
			{
				return ItemCategory.Mushroom;
			}
			if (IdentityMatches(Produce, item))
			{
				return ItemCategory.Produce;
			}
			if (IdentityStartsWith(item, "Spice"))
			{
				return ItemCategory.Spice;
			}
			if (IdentityMatches(OtherCookingIngredients, item))
			{
				return ItemCategory.OtherCookingIngredient;
			}
			if (IsType(item, "Shield"))
			{
				return ItemCategory.Shield;
			}
			if (IsType(item, "Helmet"))
			{
				return ItemCategory.Helmet;
			}
			if (IsType(item, "Chest"))
			{
				return ItemCategory.ChestArmor;
			}
			if (IsType(item, "Legs"))
			{
				return ItemCategory.LegArmor;
			}
			if (IsType(item, "Hands"))
			{
				return ItemCategory.HandArmor;
			}
			if (IsType(item, "Shoulder"))
			{
				return ItemCategory.Cape;
			}
			if (IsType(item, "Utility"))
			{
				return ItemCategory.UtilityEquipment;
			}
			if (IsType(item, "Trinket"))
			{
				return ItemCategory.Trinket;
			}
			if (IsFishingBait(item))
			{
				return ItemCategory.FishingBait;
			}
			if (IsArrow(item))
			{
				return ItemCategory.Arrow;
			}
			if (IsBolt(item))
			{
				return ItemCategory.Bolt;
			}
			if (IsType(item, "Ammo") || IsType(item, "AmmoNonEquipable"))
			{
				return ItemCategory.OtherAmmunition;
			}
			if (IsSkill(item, "Pickaxes"))
			{
				return ItemCategory.Pickaxe;
			}
			if (item.HasBuildPieces || IdentityMatches(BuildingTools, item))
			{
				return ItemCategory.BuildingTool;
			}
			if (IsSkill(item, "Farming") || IdentityMatches(FarmingTools, item))
			{
				return ItemCategory.FarmingTool;
			}
			if (IsSkill(item, "Fishing") || IdentityStartsWith(item, "FishingRod"))
			{
				return ItemCategory.FishingTool;
			}
			if (IsType(item, "Torch"))
			{
				return ItemCategory.Torch;
			}
			if (IdentityMatches(OtherTools, item))
			{
				return ItemCategory.OtherTool;
			}
			if (IsBomb(item))
			{
				return ItemCategory.Bomb;
			}
			if (IsWeaponType(item))
			{
				if (IsSkill(item, "Swords"))
				{
					return ItemCategory.Sword;
				}
				if (IsSkill(item, "Knives"))
				{
					return ItemCategory.Knife;
				}
				if (IsSkill(item, "Clubs"))
				{
					return ItemCategory.Club;
				}
				if (IsSkill(item, "Axes") || IsSkill(item, "WoodCutting"))
				{
					return ItemCategory.Axe;
				}
				if (IsSkill(item, "Spears"))
				{
					return ItemCategory.Spear;
				}
				if (IsSkill(item, "Polearms") || IsType(item, "Attach_Atgeir"))
				{
					return ItemCategory.Polearm;
				}
				if (IsSkill(item, "Unarmed"))
				{
					return ItemCategory.FistWeapon;
				}
				if (IsSkill(item, "ElementalMagic"))
				{
					return ItemCategory.ElementalMagic;
				}
				if (IsSkill(item, "BloodMagic"))
				{
					return ItemCategory.BloodMagic;
				}
				if (IsSkill(item, "Crossbows"))
				{
					return ItemCategory.Crossbow;
				}
				if (IsSkill(item, "Bows") || IsType(item, "Bow"))
				{
					return ItemCategory.Bow;
				}
				return ItemCategory.OtherWeapon;
			}
			if (IsType(item, "Tool"))
			{
				return ItemCategory.OtherTool;
			}
			if (IdentityMatches(OtherConsumables, item))
			{
				return ItemCategory.OtherConsumable;
			}
			if (HasFoodStats(item))
			{
				return ClassifyFood(item);
			}
			if (IsMead(item))
			{
				return ItemCategory.Mead;
			}
			if (item.HasConsumeStatusEffect)
			{
				return ItemCategory.Potion;
			}
			if (IsType(item, "Consumable"))
			{
				return ItemCategory.OtherConsumable;
			}
			if (IsType(item, "Trophy"))
			{
				return ItemCategory.Trophy;
			}
			if (IdentityMatches(Woods, item))
			{
				return ItemCategory.Wood;
			}
			if (IdentityMatches(Stones, item))
			{
				return ItemCategory.Stone;
			}
			if (IdentityMatches(Ores, item))
			{
				return ItemCategory.Ore;
			}
			if (IdentityMatches(Metals, item))
			{
				return ItemCategory.Metal;
			}
			if (IdentityMatches(Hides, item) || IdentityEndsWith(item, "Hide") || IdentityEndsWith(item, "Pelt"))
			{
				return ItemCategory.HideAndLeather;
			}
			if (IdentityMatches(Bones, item))
			{
				return ItemCategory.BoneAndTeeth;
			}
			if (IdentityMatches(Shells, item))
			{
				return ItemCategory.ShellAndScale;
			}
			if (IdentityMatches(Textiles, item))
			{
				return ItemCategory.Textile;
			}
			if (IdentityMatches(Gems, item))
			{
				return ItemCategory.Gem;
			}
			if (IdentityMatches(MechanicalComponents, item))
			{
				return ItemCategory.MechanicalComponent;
			}
			if (IdentityMatches(MagicMaterials, item))
			{
				return ItemCategory.MagicMaterial;
			}
			if (IdentityMatches(PlantMaterials, item))
			{
				return ItemCategory.PlantMaterial;
			}
			if (IdentityMatches(CreatureDrops, item))
			{
				return ItemCategory.CreatureDrop;
			}
			if (IdentityMatches(Fuels, item))
			{
				return ItemCategory.Fuel;
			}
			if (item.Value > 0 && (IsType(item, "Material") || IsType(item, "Misc")))
			{
				return ItemCategory.Valuable;
			}
			if (IsType(item, "Material"))
			{
				return ItemCategory.OtherMaterial;
			}
			if (IsType(item, "Customization"))
			{
				return ItemCategory.Customization;
			}
			return ItemCategory.Miscellaneous;
		}

		private static ItemCategory ClassifyFood(ItemClassificationInput item)
		{
			if (item.FoodEitr > 0f)
			{
				return ItemCategory.EitrFood;
			}
			float num = Math.Max(item.FoodHealth, item.FoodStamina);
			if (num > 0f && Math.Abs(item.FoodHealth - item.FoodStamina) <= num * 0.15f)
			{
				return ItemCategory.BalancedFood;
			}
			if (!(item.FoodHealth > item.FoodStamina))
			{
				return ItemCategory.StaminaFood;
			}
			return ItemCategory.HealthFood;
		}

		private static bool HasFoodStats(ItemClassificationInput item)
		{
			if (!(item.FoodHealth > 0f) && !(item.FoodStamina > 0f))
			{
				return item.FoodEitr > 0f;
			}
			return true;
		}

		private static bool IsWeaponType(ItemClassificationInput item)
		{
			if (!IsType(item, "OneHandedWeapon") && !IsType(item, "TwoHandedWeapon") && !IsType(item, "TwoHandedWeaponLeft") && !IsType(item, "Bow"))
			{
				return IsType(item, "Attach_Atgeir");
			}
			return true;
		}

		private static bool IsBomb(ItemClassificationInput item)
		{
			if (!IdentityStartsWith(item, "Bomb") && !IdentityStartsWith(item, "OozeBomb") && !IdentityStartsWith(item, "BileBomb"))
			{
				return IdentityStartsWith(item, "SmokeBomb");
			}
			return true;
		}

		private static bool IsMeadBase(ItemClassificationInput item)
		{
			if (!IdentityStartsWith(item, "MeadBase"))
			{
				return IdentityEndsWith(item, "WineBase");
			}
			return true;
		}

		private static bool IsMead(ItemClassificationInput item)
		{
			if (!IsMeadBase(item))
			{
				if (!IdentityStartsWith(item, "Mead"))
				{
					return IdentityEndsWith(item, "Wine");
				}
				return true;
			}
			return false;
		}

		private static bool IsFishingBait(ItemClassificationInput item)
		{
			if (!IdentityStartsWith(item, "FishingBait"))
			{
				return Contains(item.AmmoType, "bait");
			}
			return true;
		}

		private static bool IsArrow(ItemClassificationInput item)
		{
			if (!IdentityStartsWith(item, "Arrow"))
			{
				return Contains(item.AmmoType, "arrow");
			}
			return true;
		}

		private static bool IsBolt(ItemClassificationInput item)
		{
			if (!IdentityStartsWith(item, "Bolt"))
			{
				return Contains(item.AmmoType, "bolt");
			}
			return true;
		}

		private static bool IsType(ItemClassificationInput item, string value)
		{
			return EqualsIgnoreCase(item.ItemType, value);
		}

		private static bool IsSkill(ItemClassificationInput item, string value)
		{
			return EqualsIgnoreCase(item.SkillType, value);
		}

		private static bool IdentityMatches(ISet<string> names, ItemClassificationInput item)
		{
			string item2 = CleanName(item.PrefabName);
			string text = CleanName(item.SharedName);
			string item3 = CleanLocalizationToken(text);
			if (!names.Contains(item2) && !names.Contains(text))
			{
				return names.Contains(item3);
			}
			return true;
		}

		private static bool IdentityStartsWith(ItemClassificationInput item, string prefix)
		{
			if (!StartsWith(CleanName(item.PrefabName), prefix))
			{
				return StartsWith(CleanLocalizationToken(item.SharedName), prefix);
			}
			return true;
		}

		private static bool IdentityEndsWith(ItemClassificationInput item, string suffix)
		{
			if (!EndsWith(CleanName(item.PrefabName), suffix))
			{
				return EndsWith(CleanLocalizationToken(item.SharedName), suffix);
			}
			return true;
		}

		private static string CleanName(string value)
		{
			string text = (value ?? string.Empty).Trim();
			if (text.EndsWith("(Clone)", StringComparison.OrdinalIgnoreCase))
			{
				text = text.Substring(0, text.Length - "(Clone)".Length).TrimEnd(Array.Empty<char>());
			}
			return text;
		}

		private static string CleanLocalizationToken(string value)
		{
			string text = CleanName(value);
			if (text.StartsWith("$item_", StringComparison.OrdinalIgnoreCase))
			{
				text = text.Substring(6);
			}
			return text.Replace("_", string.Empty).Replace("-", string.Empty).Replace(" ", string.Empty);
		}

		private static bool StartsWith(string value, string prefix)
		{
			return value.StartsWith(prefix, StringComparison.OrdinalIgnoreCase);
		}

		private static bool EndsWith(string value, string suffix)
		{
			return value.EndsWith(suffix, StringComparison.OrdinalIgnoreCase);
		}

		private static bool Contains(string value, string fragment)
		{
			return (value ?? string.Empty).IndexOf(fragment, StringComparison.OrdinalIgnoreCase) >= 0;
		}

		private static bool EqualsIgnoreCase(string left, string right)
		{
			return string.Equals(left, right, StringComparison.OrdinalIgnoreCase);
		}

		private static HashSet<string> Names(params string[] names)
		{
			return new HashSet<string>(names, StringComparer.OrdinalIgnoreCase);
		}
	}
	public sealed class ItemClassificationInput
	{
		public string PrefabName { get; set; } = string.Empty;

		public string SharedName { get; set; } = string.Empty;

		public string ItemType { get; set; } = string.Empty;

		public string AttachOverrideType { get; set; } = string.Empty;

		public string SkillType { get; set; } = string.Empty;

		public string AmmoType { get; set; } = string.Empty;

		public bool IsQuestItem { get; set; }

		public bool HasBuildPieces { get; set; }

		public bool HasConsumeStatusEffect { get; set; }

		public int Value { get; set; }

		public float FoodHealth { get; set; }

		public float FoodStamina { get; set; }

		public float FoodEitr { get; set; }
	}
	internal enum ItemInteractionMode
	{
		Nothing,
		Locked,
		Replenish
	}
	internal static class ItemInteractionModeCycle
	{
		internal static ItemInteractionMode Next(ItemInteractionMode current, bool canReplenish)
		{
			switch (current)
			{
			case ItemInteractionMode.Nothing:
				return ItemInteractionMode.Locked;
			case ItemInteractionMode.Locked:
				if (!canReplenish)
				{
					return ItemInteractionMode.Nothing;
				}
				return ItemInteractionMode.Replenish;
			default:
				return ItemInteractionMode.Nothing;
			}
		}
	}
	internal static class ItemStackLock
	{
		internal const string CustomDataKey = "ChestFlow.StackLocked";

		internal static bool IsLocked(IDictionary<string, string>? customData)
		{
			if (customData != null && customData.TryGetValue("ChestFlow.StackLocked", out string value))
			{
				return value == "1";
			}
			return false;
		}

		internal static void SetLocked(IDictionary<string, string> customData, bool locked)
		{
			if (locked)
			{
				customData["ChestFlow.StackLocked"] = "1";
			}
			else
			{
				customData.Remove("ChestFlow.StackLocked");
			}
		}
	}
	internal static class KilnWoodPolicy
	{
		internal const string Wood = "$item_wood";

		internal const string CoreWood = "$item_roundlog";

		internal const string FineWood = "$item_finewood";

		internal const string Coal = "$item_coal";

		internal static IReadOnlyList<string> AllowedPriority(bool allowCoreWood, bool allowFineWood)
		{
			List<string> list = new List<string> { "$item_wood" };
			if (allowCoreWood)
			{
				list.Add("$item_roundlog");
			}
			if (allowFineWood)
			{
				list.Add("$item_finewood");
			}
			return list;
		}
	}
	internal readonly struct PlayerSideControlPlacement
	{
		internal float CenterX { get; }

		internal float Width { get; }

		internal float StackBottomY { get; }

		internal float StackHeight { get; }

		internal float TrashBottomY { get; }

		internal float TrashHeight { get; }

		internal PlayerSideControlPlacement(float centerX, float width, float stackBottomY, float stackHeight, float trashBottomY, float trashHeight)
		{
			CenterX = centerX;
			Width = width;
			StackBottomY = stackBottomY;
			StackHeight = stackHeight;
			TrashBottomY = trashBottomY;
			TrashHeight = trashHeight;
		}
	}
	internal static class PlayerSideControlLayout
	{
		internal static PlayerSideControlPlacement Calculate(float left, float right, float weightTop, float armorBottom, float inventoryBottom, float preferredStackHeight, float armorGap, float weightIconClearance, float horizontalOffset)
		{
			float width = Math.Max(64f, right - left);
			float stackHeight = Math.Max(32f, Math.Min(44f, preferredStackHeight));
			float num = weightTop + Math.Max(0f, weightIconClearance);
			float num2 = armorBottom - Math.Max(0f, armorGap);
			float trashHeight = Math.Max(1f, num2 - num);
			return new PlayerSideControlPlacement((left + right) * 0.5f + horizontalOffset, width, inventoryBottom, stackHeight, num, trashHeight);
		}
	}
	internal static class RequirementLabelLayout
	{
		internal static float ExpandedWidth(float baseWidth, float preferredWidth, float availableWidth)
		{
			float val = Math.Max(baseWidth, availableWidth - 8f);
			return Math.Min(Math.Max(baseWidth, preferredWidth + 6f), val);
		}

		internal static float OffsetTowardCenter(float baseWidth, float expandedWidth, float elementCenter, float rowCenter)
		{
			float num = Math.Max(0f, expandedWidth - baseWidth);
			if (num <= 0f)
			{
				return 0f;
			}
			if (elementCenter < rowCenter)
			{
				return num * 0.5f;
			}
			if (elementCenter > rowCenter)
			{
				return num * -0.5f;
			}
			return 0f;
		}
	}
	internal static class RestockMarker
	{
		internal const string IdKey = "ChestFlow.RestockId";

		internal const string TargetKey = "ChestFlow.RestockTarget";

		internal static bool TryRead(IDictionary<string, string>? customData, out string id, out int target)
		{
			id = string.Empty;
			target = 0;
			if (customData == null || !customData.TryGetValue("ChestFlow.RestockId", out string value) || string.IsNullOrWhiteSpace(value) || !customData.TryGetValue("ChestFlow.RestockTarget", out string value2) || !int.TryParse(value2, NumberStyles.Integer, CultureInfo.InvariantCulture, out target) || target <= 0)
			{
				target = 0;
				return false;
			}
			id = value;
			return true;
		}

		internal static void Set(IDictionary<string, string> customData, string id, int target)
		{
			customData["ChestFlow.RestockId"] = id;
			customData["ChestFlow.RestockTarget"] = target.ToString(CultureInfo.InvariantCulture);
		}

		internal static void Clear(IDictionary<string, string> customData)
		{
			customData.Remove("ChestFlow.RestockId");
			customData.Remove("ChestFlow.RestockTarget");
		}
	}
	internal enum RestockInventoryKind
	{
		Player,
		GearSlotsQuick,
		GearSlotsAmmo
	}
	internal sealed class RestockProfile
	{
		internal string Id { get; set; }

		internal RestockInventoryKind InventoryKind { get; set; }

		internal int X { get; set; }

		internal int Y { get; set; }

		internal string PrefabName { get; set; }

		internal int Quality { get; set; }

		internal int Variant { get; set; }

		internal int Target { get; set; }

		internal RestockProfile(string id, RestockInventoryKind inventoryKind, int x, int y, string prefabName, int quality, int variant, int target)
		{
			Id = id;
			InventoryKind = inventoryKind;
			X = x;
			Y = y;
			PrefabName = prefabName;
			Quality = quality;
			Variant = variant;
			Target = target;
		}
	}
	internal static class RestockProfileCodec
	{
		private const string Version = "v1";

		internal static string Serialize(IEnumerable<RestockProfile> profiles)
		{
			IEnumerable<string> second = from profile in profiles.Where((RestockProfile profile) => IsValid(profile)).OrderBy<RestockProfile, string>((RestockProfile profile) => profile.Id, StringComparer.Ordinal)
				select string.Join("|", profile.Id, profile.InventoryKind.ToString(), profile.X.ToString(CultureInfo.InvariantCulture), profile.Y.ToString(CultureInfo.InvariantCulture), Encode(profile.PrefabName), profile.Quality.ToString(CultureInfo.InvariantCulture), profile.Variant.ToString(CultureInfo.InvariantCulture), profile.Target.ToString(CultureInfo.InvariantCulture));
			return string.Join("\n", new string[1] { "v1" }.Concat(second));
		}

		internal static bool TryDeserialize(string? data, out List<RestockProfile> profiles)
		{
			profiles = new List<RestockProfile>();
			if (string.IsNullOrWhiteSpace(data))
			{
				return true;
			}
			string[] array = data.Replace("\r", string.Empty).Split(new char[1] { '\n' });
			if (array.Length == 0 || !string.Equals(array[0], "v1", StringComparison.Ordinal))
			{
				return false;
			}
			HashSet<string> hashSet = new HashSet<string>(StringComparer.Ordinal);
			for (int i = 1; i < array.Length; i++)
			{
				if (!string.IsNullOrWhiteSpace(array[i]))
				{
					string[] array2 = array[i].Split(new char[1] { '|' });
					if (array2.Length != 8 || string.IsNullOrWhiteSpace(array2[0]) || !Enum.TryParse<RestockInventoryKind>(array2[1], ignoreCase: false, out var result) || !int.TryParse(array2[2], NumberStyles.Integer, CultureInfo.InvariantCulture, out var result2) || !int.TryParse(array2[3], NumberStyles.Integer, CultureInfo.InvariantCulture, out var result3) || !TryDecode(array2[4], out string decoded) || !int.TryParse(array2[5], NumberStyles.Integer, CultureInfo.InvariantCulture, out var result4) || !int.TryParse(array2[6], NumberStyles.Integer, CultureInfo.InvariantCulture, out var result5) || !int.TryParse(array2[7], NumberStyles.Integer, CultureInfo.InvariantCulture, out var result6))
					{
						profiles.Clear();
						return false;
					}
					RestockProfile restockProfile = new RestockProfile(array2[0], result, result2, result3, decoded, result4, result5, result6);
					if (!IsValid(restockProfile) || !hashSet.Add(restockProfile.Id))
					{
						profiles.Clear();
						return false;
					}
					profiles.Add(restockProfile);
				}
			}
			return true;
		}

		private static bool IsValid(RestockProfile profile)
		{
			if (profile != null && !string.IsNullOrWhiteSpace(profile.Id) && !string.IsNullOrWhiteSpace(profile.PrefabName) && profile.X >= 0 && profile.Y >= 0 && profile.Quality >= 0 && profile.Variant >= 0)
			{
				return profile.Target > 0;
			}
			return false;
		}

		private static string Encode(string value)
		{
			return Convert.ToBase64String(Encoding.UTF8.GetBytes(value));
		}

		private static bool TryDecode(string value, out string decoded)
		{
			decoded = string.Empty;
			try
			{
				decoded = Encoding.UTF8.GetString(Convert.FromBase64String(value));
				return !string.IsNullOrWhiteSpace(decoded);
			}
			catch (FormatException)
			{
				return false;
			}
		}
	}
	internal static class RestockProfileSlotPolicy
	{
		internal static void RemoveConflicts(IList<RestockProfile> profiles, RestockInventoryKind inventoryKind, int x, int y, string activeId)
		{
			for (int num = profiles.Count - 1; num >= 0; num--)
			{
				RestockProfile restockProfile = profiles[num];
				if (restockProfile.InventoryKind == inventoryKind && restockProfile.X == x && restockProfile.Y == y && !string.Equals(restockProfile.Id, activeId, StringComparison.Ordinal))
				{
					profiles.RemoveAt(num);
				}
			}
		}
	}
	internal static class RestockTargetPolicy
	{
		internal static int GetTarget(int maxStack)
		{
			return Math.Max(1, maxStack);
		}
	}
	public static class SignTextColorMarkup
	{
		private const string ColorSuffix = "</color>";

		private const string White = "#FFFFFF";

		private static readonly IReadOnlyDictionary<string, string> NamedColors = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase)
		{
			["black"] = "#000000",
			["blue"] = "#0000FF",
			["brown"] = "#A52A2A",
			["cyan"] = "#00FFFF",
			["gold"] = "#FFD700",
			["gray"] = "#808080",
			["green"] = "#008000",
			["grey"] = "#808080",
			["lime"] = "#00FF00",
			["magenta"] = "#FF00FF",
			["orange"] = "#FFA500",
			["pink"] = "#FFC0CB",
			["purple"] = "#800080",
			["red"] = "#FF0000",
			["silver"] = "#C0C0C0",
			["teal"] = "#008080",
			["white"] = "#FFFFFF",
			["yellow"] = "#FFFF00"
		};

		public static string ApplyDefault(string text, string configuredColor, out string automaticColor)
		{
			automaticColor = string.Empty;
			if (string.IsNullOrEmpty(text) || text.IndexOf("<color=", StringComparison.OrdinalIgnoreCase) >= 0)
			{
				return text;
			}
			string text2 = NormalizeOrWhite(configuredColor);
			if (text2.Length == 0)
			{
				return text;
			}
			automaticColor = text2;
			return "<color=" + text2 + ">" + text + "</color>";
		}

		public static string RemoveAutomatic(string text, string automaticColor)
		{
			if (string.IsNullOrEmpty(text) || string.IsNullOrWhiteSpace(automaticColor))
			{
				return text;
			}
			string text2 = NormalizeOrWhite(automaticColor);
			string text3 = "<color=" + text2 + ">";
			if (!text.StartsWith(text3, StringComparison.OrdinalIgnoreCase))
			{
				return text;
			}
			int num = text.Length - text3.Length;
			if (text.EndsWith("</color>", StringComparison.OrdinalIgnoreCase))
			{
				num -= "</color>".Length;
			}
			return text.Substring(text3.Length, Math.Max(0, num));
		}

		public static string RemoveLegacyYellow(string text)
		{
			if (string.IsNullOrEmpty(text))
			{
				return text;
			}
			string[] array = new string[3] { "<color=yellow>", "<color=#FFFF00>", "<color=#FFFF00FF>" };
			foreach (string text2 in array)
			{
				if (text.StartsWith(text2, StringComparison.OrdinalIgnoreCase))
				{
					int num = text.Length - text2.Length;
					if (text.EndsWith("</color>", StringComparison.OrdinalIgnoreCase))
					{
						num -= "</color>".Length;
					}
					return text.Substring(text2.Length, Math.Max(0, num));
				}
			}
			return text;
		}

		public static string NormalizeOrWhite(string configuredColor)
		{
			string text = configuredColor?.Trim() ?? string.Empty;
			if (text.Length == 0 || text.Equals("none", StringComparison.OrdinalIgnoreCase) || text.Equals("vanilla", StringComparison.OrdinalIgnoreCase))
			{
				return string.Empty;
			}
			if (NamedColors.TryGetValue(text, out string value))
			{
				return value;
			}
			string text2 = ((text[0] == '#') ? text.Substring(1) : text);
			if (!IsHex(text2))
			{
				return "#FFFFFF";
			}
			if (text2.Length == 3 || text2.Length == 4)
			{
				char[] array = new char[text2.Length * 2];
				for (int i = 0; i < text2.Length; i++)
				{
					array[i * 2] = text2[i];
					array[i * 2 + 1] = text2[i];
				}
				text2 = new string(array);
			}
			return "#" + text2.ToUpperInvariant();
		}

		private static bool IsHex(string value)
		{
			if (value.Length != 3 && value.Length != 4 && value.Length != 6 && value.Length != 8)
			{
				return false;
			}
			foreach (char c in value)
			{
				bool num = c >= '0' && c <= '9';
				bool flag = c >= 'a' && c <= 'f';
				bool flag2 = c >= 'A' && c <= 'F';
				if (!num && !flag && !flag2)
				{
					return false;
				}
			}
			return true;
		}
	}
	public sealed class SortableItem
	{
		public int OriginalIndex { get; set; }

		public int Category { get; set; }

		public string InternalName { get; set; } = string.Empty;

		public string LocalizedName { get; set; } = string.Empty;

		public float Weight { get; set; }

		public int Value { get; set; }

		public int Quality { get; set; }

		public int Stack { get; set; }
	}
	public enum SortMode
	{
		Category,
		Name,
		Weight,
		Value,
		Quality
	}
	public enum StorageMatchMode
	{
		ExactItemOnly,
		ExactItemOrCategory
	}
	public sealed class StoragePreset
	{
		public string Rule { get; }

		public string Reserves { get; }

		public StoragePreset(string rule, string reserves)
		{
			Rule = rule;
			Reserves = reserves;
		}
	}
	public static class StoragePresetCodec
	{
		public static bool ValidName(string name)
		{
			if (!string.IsNullOrWhiteSpace(name) && name.Length <= 32)
			{
				return name.All((char character) => char.IsLetterOrDigit(character) || character == ' ' || character == '-' || character == '_');
			}
			return false;
		}

		public static string Encode(IReadOnlyDictionary<string, StoragePreset> presets)
		{
			if (presets.Count > 32)
			{
				throw new ArgumentException("At most 32 storage presets can be saved.");
			}
			using MemoryStream memoryStream = new MemoryStream();
			using (BinaryWriter binaryWriter = new BinaryWriter(memoryStream, Encoding.UTF8, leaveOpen: true))
			{
				binaryWriter.Write(1);
				binaryWriter.Write(presets.Count);
				foreach (KeyValuePair<string, StoragePreset> item in presets.OrderBy<KeyValuePair<string, StoragePreset>, string>((KeyValuePair<string, StoragePreset> pair) => pair.Key, StringComparer.OrdinalIgnoreCase))
				{
					Validate(item.Key, item.Value);
					binaryWriter.Write(item.Key);
					binaryWriter.Write(item.Value.Rule);
					binaryWriter.Write(item.Value.Reserves);
				}
			}
			if (memoryStream.Length > 1048576)
			{
				throw new ArgumentException("Storage presets exceed the one MiB limit.");
			}
			return Convert.ToBase64String(memoryStream.ToArray());
		}

		public static Dictionary<string, StoragePreset> Decode(string? payload)
		{
			Dictionary<string, StoragePreset> dictionary = new Dictionary<string, StoragePreset>(StringComparer.OrdinalIgnoreCase);
			if (payload == null)
			{
				return dictionary;
			}
			if (payload.Length > 1400000)
			{
				throw new FormatException("Storage preset payload is too large.");
			}
			using MemoryStream memoryStream = new MemoryStream(Convert.FromBase64String(payload));
			using BinaryReader binaryReader = new BinaryReader(memoryStream, Encoding.UTF8);
			if (binaryReader.ReadInt32() != 1)
			{
				throw new FormatException("Unsupported storage preset format.");
			}
			int num = binaryReader.ReadInt32();
			if (num < 0 || num > 32)
			{
				throw new FormatException("Invalid storage preset count.");
			}
			for (int i = 0; i < num; i++)
			{
				string text = binaryReader.ReadString();
				StoragePreset storagePreset = new StoragePreset(binaryReader.ReadString(), binaryReader.ReadString());
				Validate(text, storagePreset);
				dictionary.Add(text, storagePreset);
			}
			if (memoryStream.Position != memoryStream.Length)
			{
				throw new FormatException("Unexpected storage preset data.");
			}
			return dictionary;
		}

		private static void Validate(string name, StoragePreset preset)
		{
			if (!ValidName(name) || preset.Rule.Length > 65536 || !ChestStorageRuleCodec.TryDeserialize(preset.Rule, out ChestStorageRule _))
			{
				throw new FormatException("Invalid storage preset.");
			}
			StorageReserves.Decode(preset.Reserves);
		}
	}
	public static class StorageReserves
	{
		public static int Available(int total, int reserve)
		{
			return Math.Max(0, total - Math.Max(0, reserve));
		}

		public static string Encode(IReadOnlyDictionary<string, int> values)
		{
			if (values.Count > 128)
			{
				throw new ArgumentException("At most 128 reserve entries are allowed.");
			}
			foreach (KeyValuePair<string, int> value in values)
			{
				if (string.IsNullOrWhiteSpace(value.Key) || value.Key.Length > 128 || value.Value < 0 || value.Value > 999999)
				{
					throw new ArgumentException("Invalid reserve entry.");
				}
			}
			return "1;" + string.Join(";", from pair in values.OrderBy<KeyValuePair<string, int>, string>((KeyValuePair<string, int> pair) => pair.Key, StringComparer.OrdinalIgnoreCase)
				select Uri.EscapeDataString(pair.Key) + "=" + pair.Value.ToString(CultureInfo.InvariantCulture));
		}

		public static Dictionary<string, int> Decode(string text)
		{
			Dictionary<string, int> dictionary = new Dictionary<string, int>(StringComparer.OrdinalIgnoreCase);
			if (string.IsNullOrEmpty(text))
			{
				return dictionary;
			}
			if (text.Length > 65536 || !text.StartsWith("1;", StringComparison.Ordinal))
			{
				throw new FormatException("Unsupported reserve data.");
			}
			string[] array = text.Substring(2).Split(new char[1] { ';' }, StringSplitOptions.RemoveEmptyEntries);
			foreach (string text2 in array)
			{
				int num = text2.IndexOf('=');
				if (num <= 0 || !int.TryParse(text2.Substring(num + 1), NumberStyles.None, CultureInfo.InvariantCulture, out var result))
				{
					throw new FormatException("Invalid reserve quantity.");
				}
				string text3 = Uri.UnescapeDataString(text2.Substring(0, num));
				if (string.IsNullOrWhiteSpace(text3) || text3.Length > 128 || result < 0 || result > 999999 || dictionary.Count >= 128 || dictionary.ContainsKey(text3))
				{
					throw new FormatException("Invalid reserve entry.");
				}
				dictionary.Add(text3, result);
			}
			return dictionary;
		}
	}
	internal static class TrashOperationPlanner
	{
		internal static int GetDestroyAmount(int stack, int heldAmount, bool isQuestItem)
		{
			if (isQuestItem || stack <= 0 || heldAmount <= 0)
			{
				return 0;
			}
			return Math.Min(stack, heldAmount);
		}
	}
}