using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.Linq;
using System.Numerics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using ChestNetwork.Core;
using ChestNetwork.Core.Armor;
using ChestNetwork.Core.Deposit;
using ChestNetwork.Core.Filling;
using ChestNetwork.Core.Multiplayer;
using ChestNetwork.Plugin.Adapters;
using ChestNetwork.Plugin.Armor;
using ChestNetwork.Plugin.Interaction;
using ChestNetwork.Plugin.Machines;
using ChestNetwork.Plugin.Net;
using ChestNetwork.Plugin.Ownership;
using ChestNetwork.Plugin.Patches;
using ChestNetwork.Plugin.Storage;
using ChestNetwork.Plugin.Texts;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using TMPro;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: IgnoresAccessChecksTo("assembly_guiutils")]
[assembly: IgnoresAccessChecksTo("assembly_valheim")]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("ChestNetwork.Plugin")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("0.4.0.0")]
[assembly: AssemblyInformationalVersion("0.4.0+6e7ba34d720892abcc32bfe576c2fa62aea456e7")]
[assembly: AssemblyProduct("ChestNetwork.Plugin")]
[assembly: AssemblyTitle("ChestNetwork.Plugin")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.4.0.0")]
[module: UnverifiableCode]
[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 ChestNetwork.Plugin
{
	[BepInPlugin("jordan.chestnetwork", "ChestNetwork", "0.4.0")]
	public sealed class ChestNetworkPlugin : BaseUnityPlugin
	{
		public const string Guid = "jordan.chestnetwork";

		public const string Name = "ChestNetwork";

		public const string Version = "0.4.0";

		private Harmony? _harmony;

		internal static ManualLogSource Log { get; private set; }

		internal static PluginSettings Settings { get; private set; }

		private void Awake()
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Expected O, but got Unknown
			Log = ((BaseUnityPlugin)this).Logger;
			Settings = new PluginSettings(((BaseUnityPlugin)this).Config);
			_harmony = new Harmony("jordan.chestnetwork");
			_harmony.PatchAll(typeof(ChestNetworkPlugin).Assembly);
			AltInteraction.Register(MachinePatches.TryFillHovered);
			AltInteraction.RegisterSwitch(MachinePatches.TryFillSwitch, MachinePatches.FillSwitchHover);
			AltInteraction.RegisterSwitch(ArmorStandPatches.TrySwitch, ArmorStandCoordinator.HoverAction);
			AltInteraction.Register(ArmorStandPatches.TryHovered);
			AltInteraction.Register(ContainerPatches.TryStoreHovered);
			ModTexts.RegisterIfReady();
			Log.LogInfo((object)"ChestNetwork 0.4.0 loaded.");
		}

		private void Update()
		{
			OwnershipCoordinator.Tick();
			NetworkTransaction.Tick();
			AltInteraction.Tick();
		}

		private void OnDestroy()
		{
			Harmony? harmony = _harmony;
			if (harmony != null)
			{
				harmony.UnpatchSelf();
			}
		}
	}
	internal sealed class PluginSettings
	{
		private readonly ConfigEntry<bool> _enabled;

		private readonly ConfigEntry<ConnectionRule> _connectionRule;

		private readonly ConfigEntry<bool> _inclusiveBoundaries;

		private readonly ConfigEntry<string> _allowedStationTypes;

		private readonly ConfigEntry<bool> _useCarts;

		private readonly ConfigEntry<bool> _useShips;

		private readonly ConfigEntry<bool> _allowEquippedItems;

		private readonly ConfigEntry<float> _refreshInterval;

		private readonly ConfigEntry<bool> _showAvailableAmount;

		private readonly ConfigEntry<string> _availableAmountFormat;

		private readonly ConfigEntry<bool> _fillEnabled;

		private readonly ConfigEntry<bool> _useAltInteract;

		private readonly ConfigEntry<KeyboardShortcut> _altShortcut;

		private readonly ConfigEntry<FillOrigin> _fillOrigin;

		private readonly ConfigEntry<InventoryUse> _fillInventoryUse;

		private readonly ConfigEntry<int> _fillMinimumReserve;

		private readonly ConfigEntry<ReserveScope> _fillReserveScope;

		private readonly ConfigEntry<int> _fillMaxPerAction;

		private readonly ConfigEntry<string> _fillForbiddenItems;

		private readonly ConfigEntry<OrePriority> _fillOrePriority;

		private readonly ConfigEntry<bool> _quickStackEnabled;

		private readonly ConfigEntry<string> _quickStackCategories;

		private readonly ConfigEntry<string> _quickStackForcedItems;

		private readonly ConfigEntry<string> _quickStackExcludedItems;

		private readonly ConfigEntry<bool> _armorEnabled;

		private readonly ConfigEntry<bool> _armorProtectHotbar;

		private readonly ConfigEntry<float> _armorSetWeight;

		private readonly ConfigEntry<float> _armorTierWeight;

		private readonly ConfigEntry<float> _armorQualityWeight;

		private readonly ConfigEntry<string> _armorSets;

		public bool Enabled => _enabled.Value;

		public float RefreshInterval => Math.Max(0f, _refreshInterval.Value);

		public bool ShowAvailableAmount => _showAvailableAmount.Value;

		public bool FillEnabled => _fillEnabled.Value;

		public bool UseAltInteract => _useAltInteract.Value;

		public KeyboardShortcut AltShortcut => _altShortcut.Value;

		public FillOrigin FillOrigin => _fillOrigin.Value;

		public OrePriority FillOrePriority => _fillOrePriority.Value;

		public FillSettings FillSettings { get; private set; }

		public bool QuickStackEnabled => _quickStackEnabled.Value;

		public bool ArmorStandEnabled => _armorEnabled.Value;

		public ArmorFillSettings ArmorFillSettings { get; private set; } = ArmorFillSettings.Default;

		public ArmorSetCatalog ArmorSets { get; private set; } = ArmorSetCatalog.Vanilla;

		public DepositSettings DepositSettings { get; private set; }

		public string AvailableAmountFormat => _availableAmountFormat.Value;

		public ModConfig LocalModConfig { get; private set; }

		public PluginSettings(ConfigFile config)
		{
			//IL_0184: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fc: Expected O, but got Unknown
			//IL_023f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0249: Expected O, but got Unknown
			_enabled = config.Bind<bool>("General", "Enabled", true, "Use the resources of containers in the crafting station network.");
			_connectionRule = config.Bind<ConnectionRule>("Network", "ConnectionRule", (ConnectionRule)0, "OverlappingZones: two stations are connected when their zones overlap. StationInsideZone: when one stands inside the other's zone.");
			_inclusiveBoundaries = config.Bind<bool>("Network", "InclusiveBoundaries", true, "Whether a point exactly on a zone border is inside the zone.");
			_allowedStationTypes = config.Bind<string>("Network", "AllowedStationTypes", string.Empty, "Comma-separated station names (e.g. $piece_workbench,$piece_forge). Empty: every station type.");
			_useCarts = config.Bind<bool>("Containers", "UseCarts", false, "Use the content of carts.");
			_useShips = config.Bind<bool>("Containers", "UseShips", false, "Use the content of ships.");
			_allowEquippedItems = config.Bind<bool>("Containers", "AllowEquippedItems", false, "Allow consuming items the player wears.");
			_refreshInterval = config.Bind<float>("Performance", "RefreshInterval", 0.5f, "Seconds between two scans of the network for the build and craft menus. Consumption always rescans.");
			_showAvailableAmount = config.Bind<bool>("Display", "ShowAvailableAmount", true, "Show the available amount (inventory + network containers) next to each required amount.");
			_availableAmountFormat = config.Bind<string>("Display", "AvailableAmountFormat", "{0}/{1}", "Requirement text. {0} = required amount, {1} = available amount.");
			_fillEnabled = config.Bind<bool>("Filling", "Enabled", true, "Fill smelters and fires from the network containers.");
			_useAltInteract = config.Bind<bool>("Interaction", "UseAltInteract", true, "Act on the aimed object (fill a machine...) with the vanilla alternate use: AltPlace + Use (Shift + E by default; gamepad: its alt keys + use). Rebind them in the game settings.");
			_altShortcut = config.Bind<KeyboardShortcut>("Interaction", "Shortcut", KeyboardShortcut.Empty, "Additional key doing the same on the object under the crosshair. Empty: none.");
			_fillOrigin = config.Bind<FillOrigin>("Filling", "NetworkOrigin", FillOrigin.Player, "Where the station network is resolved from: the player (as for building) or the machine.");
			_fillInventoryUse = config.Bind<InventoryUse>("Filling", "InventoryUse", (InventoryUse)0, "Whether the player's inventory is used: Never, First (before containers) or Last (after containers).");
			_fillMinimumReserve = config.Bind<int>("Filling", "MinimumReserve", 0, new ConfigDescription("Units of each item always left in the containers.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(0, 100000), Array.Empty<object>()));
			_fillReserveScope = config.Bind<ReserveScope>("Filling", "ReserveScope", (ReserveScope)0, "Network: the containers together keep the reserve. PerContainer: each container keeps it.");
			_fillMaxPerAction = config.Bind<int>("Filling", "MaxPerAction", 0, new ConfigDescription("Most units inserted by one action. 0: no limit.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(0, 100000), Array.Empty<object>()));
			_fillForbiddenItems = config.Bind<string>("Filling", "ForbiddenItems", string.Empty, "Comma-separated item names never used for filling (e.g. $item_finewood).");
			_fillOrePriority = config.Bind<OrePriority>("Filling", "OrePriority", OrePriority.QueuedFirst, "When a smelter accepts several items: QueuedFirst (what it is already processing) or MachineOrder.");
			_quickStackEnabled = config.Bind<bool>("QuickStack", "Enabled", true, "Alternate use on a chest of the network stores your items into the network chests that already hold them, instead of opening it.");
			_quickStackCategories = config.Bind<string>("QuickStack", "IncludedCategories", "Material,Trophy", "Comma-separated item types stored (game names: Material, Trophy, Consumable, Ammo, Fish...). The hotbar row and equipped items are never stored.");
			_quickStackForcedItems = config.Bind<string>("QuickStack", "ForcedItems", string.Empty, "Comma-separated items always stored, whatever their type (e.g. $item_raspberries).");
			_quickStackExcludedItems = config.Bind<string>("QuickStack", "ExcludedItems", string.Empty, "Comma-separated items never stored, whatever their type (e.g. $item_finewood). Wins over ForcedItems.");
			_armorEnabled = config.Bind<bool>("ArmorStand", "Enabled", true, "Alternate use on an armor stand: dress it from your inventory and the network when it holds no armor, else swap armor with it.");
			_armorProtectHotbar = config.Bind<bool>("ArmorStand", "ProtectHotbar", true, "Never take armor from the hotbar row when dressing a stand.");
			_armorSetWeight = config.Bind<float>("ArmorStand", "SetWeight", 100f, "Dressing: cost of a piece outside the chosen set (dominant).");
			_armorTierWeight = config.Bind<float>("ArmorStand", "TierWeight", 10f, "Dressing: cost per tier of difference with the chosen set.");
			_armorQualityWeight = config.Bind<float>("ArmorStand", "QualityWeight", 1f, "Dressing: cost per quality level of difference with the chosen set.");
			_armorSets = config.Bind<string>("ArmorStand", "Sets", "rags:1:ArmorRagsChest,ArmorRagsLegs;leather:1:ArmorLeatherChest,ArmorLeatherLegs,HelmetLeather,CapeDeerHide;troll:2:ArmorTrollLeatherChest,ArmorTrollLeatherLegs,HelmetTrollLeather,CapeTrollHide;bronze:2:ArmorBronzeChest,ArmorBronzeLegs,HelmetBronze;root:3:ArmorRootChest,ArmorRootLegs,HelmetRoot;iron:3:ArmorIronChest,ArmorIronLegs,HelmetIron;wolf:4:ArmorWolfChest,ArmorWolfLegs,HelmetDrake,CapeWolf;fenris:4:ArmorFenringChest,ArmorFenringLegs,HelmetFenring;padded:5:ArmorPaddedCuirass,ArmorPaddedGreaves,HelmetPadded;carapace:6:ArmorCarapaceChest,ArmorCarapaceLegs,HelmetCarapace,CapeFeather;mage:6:ArmorMageChest,ArmorMageLegs,HelmetMage;flametal:7:ArmorFlametalChest,ArmorFlametalLegs;askvin:7:ArmorAshlandsMediumChest,ArmorAshlandsMediumlegs,HelmetAshlandsMediumHood,CapeAsksvin;deepnorthheavy:8:ArmorDeepNorthHeavyChest,ArmorDeepNorthHeavylegs,HelmetDNHeavy;deepnorthmedium:8:ArmorDeepNorthMediumChest,ArmorDeepNorthMediumlegs,HelmetDNMedium;deepnorthmage:8:ArmorDeepNorthMageChest,ArmorDeepNorthMagelegs,HelmetDNMage", "Armor sets, used for items without a game set name: set:tier:prefab,prefab;... Tiers follow the biomes (1 = Meadows). Add armors of other mods here.");
			LocalModConfig = Build();
			FillSettings = BuildFillSettings();
			DepositSettings = BuildDepositSettings();
			BuildArmorSettings();
			config.SettingChanged += delegate
			{
				LocalModConfig = Build();
				FillSettings = BuildFillSettings();
				DepositSettings = BuildDepositSettings();
				BuildArmorSettings();
				HandshakePatches.BroadcastConfig();
			};
		}

		private FillSettings BuildFillSettings()
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			FillSettings obj = FillSettings.Default.<Clone>$();
			obj.set_InventoryUse(_fillInventoryUse.Value);
			obj.set_MinimumReserve(Math.Max(0, _fillMinimumReserve.Value));
			obj.set_ReserveScope(_fillReserveScope.Value);
			obj.set_MaxPerAction((_fillMaxPerAction.Value > 0) ? new int?(_fillMaxPerAction.Value) : ((int?)null));
			obj.set_ForbiddenItems((IReadOnlyCollection<string>)(object)SplitList(_fillForbiddenItems.Value));
			return obj;
		}

		private DepositSettings BuildDepositSettings()
		{
			DepositSettings obj = DepositSettings.Default.<Clone>$();
			obj.set_IncludedCategories((IReadOnlyCollection<string>)(object)SplitList(_quickStackCategories.Value));
			obj.set_ForcedItems((IReadOnlyCollection<string>)(object)SplitList(_quickStackForcedItems.Value));
			obj.set_ExcludedItems((IReadOnlyCollection<string>)(object)SplitList(_quickStackExcludedItems.Value));
			return obj;
		}

		private void BuildArmorSettings()
		{
			ArmorFillSettings obj = ArmorFillSettings.Default.<Clone>$();
			obj.set_SetWeight(Weight(_armorSetWeight.Value, ArmorFillSettings.Default.SetWeight));
			obj.set_TierWeight(Weight(_armorTierWeight.Value, ArmorFillSettings.Default.TierWeight));
			obj.set_QualityWeight(Weight(_armorQualityWeight.Value, ArmorFillSettings.Default.QualityWeight));
			obj.set_ProtectHotbar(_armorProtectHotbar.Value);
			ArmorFillSettings = obj;
			ArmorSetCatalog armorSets = default(ArmorSetCatalog);
			string text = default(string);
			if (ArmorSetCatalog.TryParse(_armorSets.Value, ref armorSets, ref text))
			{
				ArmorSets = armorSets;
				return;
			}
			ChestNetworkPlugin.Log.LogWarning((object)("[ArmorStand] Sets: " + text + " Using the vanilla table."));
			ArmorSets = ArmorSetCatalog.Vanilla;
		}

		private static double Weight(float value, double fallback)
		{
			if (!(value >= 0f) || float.IsNaN(value) || float.IsInfinity(value))
			{
				return fallback;
			}
			return value;
		}

		private static string[] SplitList(string value)
		{
			return (from entry in value.Split(',')
				select entry.Trim() into entry
				where entry.Length > 0
				select entry).ToArray();
		}

		private ModConfig Build()
		{
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			string[] array = SplitList(_allowedStationTypes.Value);
			List<ContainerKind> list = new List<ContainerKind>();
			if (!_useCarts.Value)
			{
				list.Add((ContainerKind)1);
			}
			if (!_useShips.Value)
			{
				list.Add((ContainerKind)2);
			}
			ModConfig obj = ModConfig.Default.<Clone>$();
			obj.set_ConnectionRule(_connectionRule.Value);
			obj.set_InclusiveBoundaries(_inclusiveBoundaries.Value);
			obj.set_AllowedStationTypes((IReadOnlyCollection<string>)(object)((array.Length == 0) ? null : array));
			obj.set_ExcludedContainerKinds((IReadOnlyCollection<ContainerKind>)list);
			obj.set_AllowEquippedItems(_allowEquippedItems.Value);
			obj.set_QualityMatching((QualityMatching)1);
			return obj;
		}
	}
	internal static class PluginVersion
	{
		public const string Value = "0.4.0";
	}
}
namespace ChestNetwork.Plugin.Texts
{
	internal static class ModTexts
	{
		[HarmonyPatch(typeof(Localization), "SetupLanguage")]
		private static class SetupLanguagePatch
		{
			private static void Postfix(Localization __instance, string language)
			{
				Register(__instance, language);
			}
		}

		public const string FillPreparing = "$chestnetwork_fill_preparing";

		public const string FillMachineBusy = "$chestnetwork_fill_machine_busy";

		public const string FillAlreadyFull = "$chestnetwork_fill_already_full";

		public const string FillNothingToAdd = "$chestnetwork_fill_nothing_to_add";

		public const string FillHoverAction = "$chestnetwork_fill_hover";

		public const string WaitingForContainers = "$chestnetwork_waiting_for_containers";

		public const string StoreHoverAction = "$chestnetwork_store_hover";

		public const string StoreNotInNetwork = "$chestnetwork_store_not_in_network";

		public const string StorePreparing = "$chestnetwork_store_preparing";

		public const string StoreNothing = "$chestnetwork_store_nothing";

		public const string StoreFull = "$chestnetwork_store_full";

		public const string StoreDone = "$chestnetwork_store_done";

		public const string ArmorFillHover = "$chestnetwork_armor_fill_hover";

		public const string ArmorSwapHover = "$chestnetwork_armor_swap_hover";

		public const string ArmorNothing = "$chestnetwork_armor_nothing";

		public const string ArmorPreparing = "$chestnetwork_armor_preparing";

		public const string ArmorBusy = "$chestnetwork_armor_busy";

		private const string Fallback = "English";

		private static readonly Dictionary<string, Dictionary<string, string>> ByLanguage = new Dictionary<string, Dictionary<string, string>>
		{
			["English"] = new Dictionary<string, string>
			{
				["$chestnetwork_fill_preparing"] = "Preparing to fill...",
				["$chestnetwork_fill_machine_busy"] = "Machine used by another player, try again",
				["$chestnetwork_fill_already_full"] = "Already full",
				["$chestnetwork_fill_nothing_to_add"] = "Nothing to add",
				["$chestnetwork_fill_hover"] = "Fill from chests",
				["$chestnetwork_waiting_for_containers"] = "Chest network: waiting for containers held by other players...",
				["$chestnetwork_store_hover"] = "Store in network (items already there)",
				["$chestnetwork_store_not_in_network"] = "This chest is not in a crafting station network",
				["$chestnetwork_store_preparing"] = "Preparing to store...",
				["$chestnetwork_store_nothing"] = "Nothing to store",
				["$chestnetwork_store_full"] = "$1 chest full",
				["$chestnetwork_store_done"] = "Stored $1 item(s) in $2 chest(s)",
				["$chestnetwork_armor_fill_hover"] = "Dress the stand",
				["$chestnetwork_armor_swap_hover"] = "Swap armor",
				["$chestnetwork_armor_nothing"] = "No armor found",
				["$chestnetwork_armor_preparing"] = "Preparing the armor stand...",
				["$chestnetwork_armor_busy"] = "Armor stand used by another player, try again"
			},
			["French"] = new Dictionary<string, string>
			{
				["$chestnetwork_fill_preparing"] = "Préparation du remplissage...",
				["$chestnetwork_fill_machine_busy"] = "Machine utilisée par un autre joueur, réessayez",
				["$chestnetwork_fill_already_full"] = "Déjà plein",
				["$chestnetwork_fill_nothing_to_add"] = "Rien à ajouter",
				["$chestnetwork_fill_hover"] = "Remplir depuis les coffres",
				["$chestnetwork_waiting_for_containers"] = "Réseau de coffres : attente des coffres détenus par d'autres joueurs...",
				["$chestnetwork_store_hover"] = "Ranger dans le réseau (items déjà présents)",
				["$chestnetwork_store_not_in_network"] = "Ce coffre n'est pas dans un réseau d'établis",
				["$chestnetwork_store_preparing"] = "Préparation du rangement...",
				["$chestnetwork_store_nothing"] = "Rien à ranger",
				["$chestnetwork_store_full"] = "Coffre de $1 plein",
				["$chestnetwork_store_done"] = "$1 objet(s) rangé(s) dans $2 coffre(s)",
				["$chestnetwork_armor_fill_hover"] = "Garnir",
				["$chestnetwork_armor_swap_hover"] = "Échanger l'armure",
				["$chestnetwork_armor_nothing"] = "Aucune armure trouvée",
				["$chestnetwork_armor_preparing"] = "Préparation du porte-armure...",
				["$chestnetwork_armor_busy"] = "Porte-armure utilisé par un autre joueur, réessayez"
			},
			["German"] = new Dictionary<string, string>
			{
				["$chestnetwork_fill_preparing"] = "Befüllung wird vorbereitet...",
				["$chestnetwork_fill_machine_busy"] = "Maschine wird von einem anderen Spieler benutzt, versuche es erneut",
				["$chestnetwork_fill_already_full"] = "Bereits voll",
				["$chestnetwork_fill_nothing_to_add"] = "Nichts hinzuzufügen",
				["$chestnetwork_fill_hover"] = "Aus Truhen befüllen",
				["$chestnetwork_waiting_for_containers"] = "Truhennetzwerk: warte auf Truhen anderer Spieler...",
				["$chestnetwork_store_hover"] = "Im Netzwerk einlagern (bereits vorhandene Gegenstände)",
				["$chestnetwork_store_not_in_network"] = "Diese Truhe gehört zu keinem Werkbanknetzwerk",
				["$chestnetwork_store_preparing"] = "Einlagerung wird vorbereitet...",
				["$chestnetwork_store_nothing"] = "Nichts einzulagern",
				["$chestnetwork_store_full"] = "Truhe für $1 voll",
				["$chestnetwork_store_done"] = "$1 Gegenstände in $2 Truhe(n) eingelagert",
				["$chestnetwork_armor_fill_hover"] = "Ständer ausstatten",
				["$chestnetwork_armor_swap_hover"] = "Rüstung tauschen",
				["$chestnetwork_armor_nothing"] = "Keine Rüstung gefunden",
				["$chestnetwork_armor_preparing"] = "Rüstungsständer wird vorbereitet...",
				["$chestnetwork_armor_busy"] = "Rüstungsständer wird von einem anderen Spieler benutzt, versuche es erneut"
			},
			["Spanish"] = new Dictionary<string, string>
			{
				["$chestnetwork_fill_preparing"] = "Preparando el llenado...",
				["$chestnetwork_fill_machine_busy"] = "Máquina en uso por otro jugador, inténtalo de nuevo",
				["$chestnetwork_fill_already_full"] = "Ya está lleno",
				["$chestnetwork_fill_nothing_to_add"] = "Nada que añadir",
				["$chestnetwork_fill_hover"] = "Llenar desde los cofres",
				["$chestnetwork_waiting_for_containers"] = "Red de cofres: esperando cofres de otros jugadores...",
				["$chestnetwork_store_hover"] = "Guardar en la red (objetos ya presentes)",
				["$chestnetwork_store_not_in_network"] = "Este cofre no está en una red de mesas de trabajo",
				["$chestnetwork_store_preparing"] = "Preparando el almacenamiento...",
				["$chestnetwork_store_nothing"] = "Nada que guardar",
				["$chestnetwork_store_full"] = "Cofre de $1 lleno",
				["$chestnetwork_store_done"] = "$1 objeto(s) guardado(s) en $2 cofre(s)",
				["$chestnetwork_armor_fill_hover"] = "Equipar el soporte",
				["$chestnetwork_armor_swap_hover"] = "Intercambiar armadura",
				["$chestnetwork_armor_nothing"] = "No se encontró armadura",
				["$chestnetwork_armor_preparing"] = "Preparando el soporte de armadura...",
				["$chestnetwork_armor_busy"] = "Soporte de armadura en uso por otro jugador, inténtalo de nuevo"
			},
			["Portuguese_Brazilian"] = new Dictionary<string, string>
			{
				["$chestnetwork_fill_preparing"] = "Preparando o abastecimento...",
				["$chestnetwork_fill_machine_busy"] = "Máquina em uso por outro jogador, tente novamente",
				["$chestnetwork_fill_already_full"] = "Já está cheio",
				["$chestnetwork_fill_nothing_to_add"] = "Nada para adicionar",
				["$chestnetwork_fill_hover"] = "Abastecer a partir dos baús",
				["$chestnetwork_waiting_for_containers"] = "Rede de baús: aguardando baús de outros jogadores...",
				["$chestnetwork_store_hover"] = "Guardar na rede (itens já presentes)",
				["$chestnetwork_store_not_in_network"] = "Este baú não está em uma rede de bancadas",
				["$chestnetwork_store_preparing"] = "Preparando o armazenamento...",
				["$chestnetwork_store_nothing"] = "Nada para guardar",
				["$chestnetwork_store_full"] = "Baú de $1 cheio",
				["$chestnetwork_store_done"] = "$1 item(ns) guardado(s) em $2 baú(s)",
				["$chestnetwork_armor_fill_hover"] = "Equipar o suporte",
				["$chestnetwork_armor_swap_hover"] = "Trocar armadura",
				["$chestnetwork_armor_nothing"] = "Nenhuma armadura encontrada",
				["$chestnetwork_armor_preparing"] = "Preparando o suporte de armadura...",
				["$chestnetwork_armor_busy"] = "Suporte de armadura em uso por outro jogador, tente novamente"
			},
			["Polish"] = new Dictionary<string, string>
			{
				["$chestnetwork_fill_preparing"] = "Przygotowywanie napełniania...",
				["$chestnetwork_fill_machine_busy"] = "Maszyna jest używana przez innego gracza, spróbuj ponownie",
				["$chestnetwork_fill_already_full"] = "Już pełne",
				["$chestnetwork_fill_nothing_to_add"] = "Nie ma czego dodać",
				["$chestnetwork_fill_hover"] = "Napełnij ze skrzyń",
				["$chestnetwork_waiting_for_containers"] = "Sieć skrzyń: oczekiwanie na skrzynie innych graczy...",
				["$chestnetwork_store_hover"] = "Odłóż do sieci (przedmioty już obecne)",
				["$chestnetwork_store_not_in_network"] = "Ta skrzynia nie należy do sieci stołów warsztatowych",
				["$chestnetwork_store_preparing"] = "Przygotowywanie odkładania...",
				["$chestnetwork_store_nothing"] = "Nic do odłożenia",
				["$chestnetwork_store_full"] = "Skrzynia na $1 pełna",
				["$chestnetwork_store_done"] = "Odłożono przedmioty: $1, skrzynie: $2",
				["$chestnetwork_armor_fill_hover"] = "Ubierz stojak",
				["$chestnetwork_armor_swap_hover"] = "Zamień zbroję",
				["$chestnetwork_armor_nothing"] = "Nie znaleziono zbroi",
				["$chestnetwork_armor_preparing"] = "Przygotowywanie stojaka na zbroję...",
				["$chestnetwork_armor_busy"] = "Stojak na zbroję jest używany przez innego gracza, spróbuj ponownie"
			},
			["Russian"] = new Dictionary<string, string>
			{
				["$chestnetwork_fill_preparing"] = "Подготовка к заполнению...",
				["$chestnetwork_fill_machine_busy"] = "Машина используется другим игроком, попробуйте ещё раз",
				["$chestnetwork_fill_already_full"] = "Уже заполнено",
				["$chestnetwork_fill_nothing_to_add"] = "Нечего добавить",
				["$chestnetwork_fill_hover"] = "Заполнить из сундуков",
				["$chestnetwork_waiting_for_containers"] = "Сеть сундуков: ожидание сундуков других игроков...",
				["$chestnetwork_store_hover"] = "Сложить в сеть (уже имеющиеся предметы)",
				["$chestnetwork_store_not_in_network"] = "Этот сундук не входит в сеть верстаков",
				["$chestnetwork_store_preparing"] = "Подготовка к размещению...",
				["$chestnetwork_store_nothing"] = "Нечего сложить",
				["$chestnetwork_store_full"] = "Сундук для $1 заполнен",
				["$chestnetwork_store_done"] = "Сложено предметов: $1, сундуков: $2",
				["$chestnetwork_armor_fill_hover"] = "Одеть стойку",
				["$chestnetwork_armor_swap_hover"] = "Обменяться бронёй",
				["$chestnetwork_armor_nothing"] = "Броня не найдена",
				["$chestnetwork_armor_preparing"] = "Подготовка стойки для брони...",
				["$chestnetwork_armor_busy"] = "Стойка для брони используется другим игроком, попробуйте ещё раз"
			},
			["Chinese"] = new Dictionary<string, string>
			{
				["$chestnetwork_fill_preparing"] = "正在准备填充...",
				["$chestnetwork_fill_machine_busy"] = "机器正被其他玩家使用，请重试",
				["$chestnetwork_fill_already_full"] = "已满",
				["$chestnetwork_fill_nothing_to_add"] = "没有可添加的物品",
				["$chestnetwork_fill_hover"] = "从箱子中填充",
				["$chestnetwork_waiting_for_containers"] = "箱子网络：正在等待其他玩家持有的箱子...",
				["$chestnetwork_store_hover"] = "存入网络（已有的物品）",
				["$chestnetwork_store_not_in_network"] = "这个箱子不在工作台网络中",
				["$chestnetwork_store_preparing"] = "正在准备存放...",
				["$chestnetwork_store_nothing"] = "没有可存放的物品",
				["$chestnetwork_store_full"] = "$1箱子已满",
				["$chestnetwork_store_done"] = "已将$1件物品存入$2个箱子",
				["$chestnetwork_armor_fill_hover"] = "装备盔甲架",
				["$chestnetwork_armor_swap_hover"] = "交换盔甲",
				["$chestnetwork_armor_nothing"] = "未找到盔甲",
				["$chestnetwork_armor_preparing"] = "正在准备盔甲架...",
				["$chestnetwork_armor_busy"] = "盔甲架正被其他玩家使用，请重试"
			}
		};

		public static void Register(Localization localization, string language)
		{
			ByLanguage.TryGetValue(language, out Dictionary<string, string> value);
			foreach (KeyValuePair<string, string> item in ByLanguage["English"])
			{
				string value2;
				string text = ((value != null && value.TryGetValue(item.Key, out value2)) ? value2 : item.Value);
				localization.AddWord(item.Key.Substring(1), text);
			}
		}

		public static void RegisterIfReady()
		{
			Localization instance = Localization.m_instance;
			if (instance != null)
			{
				Register(instance, instance.GetSelectedLanguage());
			}
		}
	}
}
namespace ChestNetwork.Plugin.Storage
{
	internal static class QuickStackCoordinator
	{
		public static bool TryStart(Player player, Container target)
		{
			//IL_0083: 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)
			if (!NetworkSession.FeaturesEnabled || !ChestNetworkPlugin.Settings.QuickStackEnabled || !IsBuiltChest(target))
			{
				return false;
			}
			ContainerRegistry.Entry entry = ContainerRegistry.Find(GameSnapshots.IdOf(target));
			Container openedByPlayer = (((Object)(object)InventoryGui.instance != (Object)null) ? InventoryGui.instance.m_currentContainer : null);
			ContainerSnapshot val = ((entry != null) ? GameSnapshots.Container(entry, player.GetPlayerID(), openedByPlayer) : null);
			if (val == (ContainerSnapshot)null)
			{
				return false;
			}
			if (!val.IsAccessible)
			{
				((Character)player).Message((MessageType)2, "$msg_cantopen", 0, (Sprite)null, false);
				return true;
			}
			NetworkContext networkContext = NetworkContext.At(player, ((Component)player).transform.position, committable: false);
			ContainerSelector val2 = new ContainerSelector(NetworkSession.Config);
			StationNetwork network = networkContext.Network;
			ContainerSnapshot[] array = new ContainerSnapshot[1];
			ContainerSnapshot obj = val.<Clone>$();
			obj.set_IsInUse(false);
			array[0] = obj;
			if (val2.Select(network, (IEnumerable<ContainerSnapshot>)(object)array).Count == 0)
			{
				((Character)player).Message((MessageType)2, "$chestnetwork_store_not_in_network", 0, (Sprite)null, false);
				return true;
			}
			DepositPlan val3 = Plan(player, networkContext, skipUnavailable: true);
			if (val3.TotalDeposited == 0L)
			{
				Report(player, val3, 0L, 0);
				return true;
			}
			List<ZNetView> needed = ContainerRegistry.ViewsOf(val3.ContainersTouched);
			if (!NetworkTransaction.Begin(player, needed, Commit))
			{
				((Character)player).Message((MessageType)2, "$chestnetwork_store_preparing", 0, (Sprite)null, false);
			}
			return true;
		}

		public static bool IsNetworkChest(Player player, Container container)
		{
			if (IsBuiltChest(container))
			{
				return NetworkContext.Wide(player).Selected.Any((ContainerSnapshot snapshot) => snapshot.Id == GameSnapshots.IdOf(container));
			}
			return false;
		}

		private static bool IsBuiltChest(Container container)
		{
			if ((Object)(object)container == (Object)null || (Object)(object)container.m_nview == (Object)null || !container.m_nview.IsValid())
			{
				return false;
			}
			Piece componentInParent = ((Component)container).GetComponentInParent<Piece>();
			if ((Object)(object)componentInParent != (Object)null)
			{
				return componentInParent.IsPlacedByPlayer();
			}
			return false;
		}

		private static DepositPlan Plan(Player player, NetworkContext context, bool skipUnavailable)
		{
			//IL_0040: 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)
			IEnumerable<ContainerSnapshot> enumerable = context.Selected;
			if (skipUnavailable)
			{
				enumerable = enumerable.Where((ContainerSnapshot c) => !OwnershipCoordinator.IsUnavailable(context.EntriesById[c.Id].Container.m_nview));
			}
			Inventory inventory = ((Humanoid)player).GetInventory();
			IReadOnlyList<ItemStack> readOnlyList = new DepositFilter(ChestNetworkPlugin.Settings.DepositSettings).Select((IEnumerable<CategorizedStack>)GameSnapshots.CategorizedItems(inventory), inventory.GetWidth());
			return new DepositPlanner().Plan((IEnumerable<ItemStack>)readOnlyList, enumerable);
		}

		private static void Commit(Player player)
		{
			//IL_0007: 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_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0117: Unknown result type (might be due to invalid IL or missing references)
			//IL_011c: 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)
			//IL_0143: Unknown result type (might be due to invalid IL or missing references)
			NetworkContext networkContext = NetworkContext.At(player, ((Component)player).transform.position, committable: true);
			DepositPlan val = Plan(player, networkContext, skipUnavailable: false);
			ValidationResult val2 = new PlanValidator(NetworkSession.Config).ValidateDeposit(val, (IEnumerable<ItemStack>)GameSnapshots.Items(((Humanoid)player).GetInventory()), (IEnumerable<ContainerSnapshot>)networkContext.Reread(val.ContainersTouched));
			if (!val2.IsValid)
			{
				ChestNetworkPlugin.Log.LogInfo((object)("Quick stack invalidated before commit: " + string.Join("; ", val2.Issues)));
				return;
			}
			Inventory inventory = ((Humanoid)player).GetInventory();
			int width = inventory.GetWidth();
			long num = 0L;
			HashSet<string> hashSet = new HashSet<string>();
			foreach (StackDeposit deposit in val.Deposits)
			{
				Vector2i val3 = GameSnapshots.GridPosOf(deposit.SourceSlot, width);
				ItemData itemAt = inventory.GetItemAt(val3.x, val3.y);
				if (itemAt != null && !(GameSnapshots.StackKey(itemAt) != deposit.StackKey))
				{
					Inventory inventory2 = networkContext.EntriesById[deposit.ContainerId].Container.GetInventory();
					Vector2i val4 = GameSnapshots.GridPosOf(deposit.TargetSlot, inventory2.GetWidth());
					int stack = itemAt.m_stack;
					inventory2.MoveItemToThis(inventory, itemAt, (int)Math.Min(deposit.Amount, stack), val4.x, val4.y);
					int num2 = stack - itemAt.m_stack;
					if (num2 > 0)
					{
						num += num2;
						hashSet.Add(deposit.ContainerId);
					}
				}
			}
			OwnershipCoordinator.Reserve(hashSet);
			NetworkContext.Invalidate();
			Report(player, val, num, hashSet.Count);
		}

		private static void Report(Player player, DepositPlan plan, long stored, int chests)
		{
			foreach (DepositRemainder item in plan.NoRoom)
			{
				string text = Localization.instance.Localize(item.ItemId);
				((Character)player).Message((MessageType)1, Localization.instance.Localize("$chestnetwork_store_full", new string[1] { text }), 0, (Sprite)null, false);
			}
			string text2 = ((stored > 0) ? Localization.instance.Localize("$chestnetwork_store_done", new string[2]
			{
				stored.ToString(CultureInfo.InvariantCulture),
				chests.ToString(CultureInfo.InvariantCulture)
			}) : "$chestnetwork_store_nothing");
			((Character)player).Message((MessageType)2, text2, 0, (Sprite)null, false);
		}
	}
}
namespace ChestNetwork.Plugin.Patches
{
	internal static class ArmorStandPatches
	{
		[HarmonyPatch(typeof(ArmorStand), "Awake")]
		private static class ArmorStandAwake
		{
			private static void Postfix(ArmorStand __instance)
			{
				OwnershipCoordinator.RegisterMachine(__instance.m_nview);
			}
		}

		public static bool TrySwitch(Player player, Switch sw)
		{
			ArmorStand componentInParent = ((Component)sw).GetComponentInParent<ArmorStand>();
			if ((Object)(object)componentInParent != (Object)null && componentInParent.m_slots.Exists((ArmorStandSlot slot) => (Object)(object)slot.m_switch == (Object)(object)sw))
			{
				return ArmorStandCoordinator.TryStart(player, componentInParent);
			}
			return false;
		}

		public static bool TryHovered(Player player, GameObject hovering)
		{
			ArmorStand componentInParent = hovering.GetComponentInParent<ArmorStand>();
			if ((Object)(object)componentInParent != (Object)null)
			{
				return ArmorStandCoordinator.TryStart(player, componentInParent);
			}
			return false;
		}
	}
	[HarmonyPatch(typeof(Player), "ConsumeResources")]
	internal static class ConsumeResourcesPatch
	{
		private static bool Prefix(Player __instance, Requirement[] requirements, int qualityLevel, int itemQuality, int multiplier)
		{
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Expected O, but got Unknown
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Expected O, but got Unknown
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			if (!NetworkSession.FeaturesEnabled || (Object)(object)__instance != (Object)(object)Player.m_localPlayer || requirements == null)
			{
				return true;
			}
			List<Requirement> list = RequirementMapper.ToCore(__instance, requirements, qualityLevel, itemQuality, multiplier);
			Inventory inventory = ((Humanoid)__instance).GetInventory();
			ConsumptionPlanner val = new ConsumptionPlanner(NetworkSession.Config);
			PlanValidator validator = new PlanValidator(NetworkSession.Config);
			NetworkContext networkContext = NetworkContext.Committable(__instance);
			PlanResult val2 = val.Plan((IEnumerable<Requirement>)list, (IEnumerable<ItemStack>)GameSnapshots.Items(inventory), (IEnumerable<ContainerSnapshot>)networkContext.Selected);
			if (val2.IsSuccess && !Revalidate(val2.Plan, inventory, networkContext, validator))
			{
				networkContext = NetworkContext.Committable(__instance, forceRescan: true);
				val2 = val.Plan((IEnumerable<Requirement>)list, (IEnumerable<ItemStack>)GameSnapshots.Items(inventory), (IEnumerable<ContainerSnapshot>)networkContext.Selected);
			}
			if (!val2.IsSuccess)
			{
				ChestNetworkPlugin.Log.LogWarning((object)$"No complete plan ({val2.Status}), falling back to vanilla consumption.");
				return true;
			}
			Commit(val2.Plan, inventory, networkContext);
			NetworkContext.Invalidate();
			return false;
		}

		private static bool Revalidate(ConsumptionPlan plan, Inventory inventory, NetworkContext context, PlanValidator validator)
		{
			List<ContainerSnapshot> list = context.Reread(from w in plan.Withdrawals
				where !w.IsFromInventory
				select w.ContainerId);
			ValidationResult val = validator.Validate(plan, (IEnumerable<ItemStack>)GameSnapshots.Items(inventory), (IEnumerable<ContainerSnapshot>)list);
			if (!val.IsValid)
			{
				ChestNetworkPlugin.Log.LogInfo((object)("Plan invalidated before commit: " + string.Join("; ", val.Issues)));
			}
			return val.IsValid;
		}

		private static void Commit(ConsumptionPlan plan, Inventory playerInventory, NetworkContext context)
		{
			HashSet<string> hashSet = new HashSet<string>();
			bool allowEquippedItems = NetworkSession.Config.AllowEquippedItems;
			foreach (Withdrawal withdrawal in plan.Withdrawals)
			{
				Inventory inventory;
				if (withdrawal.IsFromInventory)
				{
					inventory = playerInventory;
				}
				else
				{
					inventory = context.EntriesById[withdrawal.ContainerId].Container.GetInventory();
					hashSet.Add(withdrawal.ContainerId);
				}
				InventoryOps.Remove(inventory, withdrawal.ItemId, withdrawal.Quality, withdrawal.Amount, allowEquippedItems || !withdrawal.IsFromInventory);
			}
			if (hashSet.Count > 0)
			{
				OwnershipCoordinator.Reserve(hashSet);
				ChestNetworkPlugin.Log.LogInfo((object)$"Resources taken from {hashSet.Count} container(s) of the network.");
			}
		}
	}
	internal static class ContainerPatches
	{
		[HarmonyPatch(typeof(Container), "Interact")]
		private static class ContainerInteract
		{
			private static bool Prefix(Container __instance, Humanoid character, bool hold, bool alt, ref bool __result)
			{
				//IL_000b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0016: Expected O, but got Unknown
				if (!AltInteraction.IsAltUse(character, hold, alt) || !QuickStackCoordinator.TryStart((Player)character, __instance))
				{
					return true;
				}
				__result = true;
				return false;
			}
		}

		[HarmonyPatch(typeof(Container), "GetHoverText")]
		private static class ContainerHover
		{
			private static void Postfix(Container __instance, ref string __result)
			{
				Player localPlayer = Player.m_localPlayer;
				if ((Object)(object)localPlayer != (Object)null && AltInteraction.Available && ChestNetworkPlugin.Settings.QuickStackEnabled && QuickStackCoordinator.IsNetworkChest(localPlayer, __instance))
				{
					__result += AltInteraction.HoverLine("$chestnetwork_store_hover");
				}
			}
		}

		public static bool TryStoreHovered(Player player, GameObject hovering)
		{
			Container componentInParent = hovering.GetComponentInParent<Container>();
			if ((Object)(object)componentInParent != (Object)null)
			{
				return QuickStackCoordinator.TryStart(player, componentInParent);
			}
			return false;
		}
	}
	internal static class MachinePatches
	{
		[HarmonyPatch(typeof(Fireplace), "Interact")]
		private static class FireplaceInteract
		{
			private static bool Prefix(Fireplace __instance, Humanoid user, bool hold, bool alt, ref bool __result)
			{
				//IL_0017: Unknown result type (might be due to invalid IL or missing references)
				//IL_0022: Expected O, but got Unknown
				if (!AltInteraction.IsAltUse(user, hold, alt))
				{
					return true;
				}
				MachineSlot machineSlot = MachineSlot.FromFireplace(__instance);
				if (machineSlot == null || !FillCoordinator.TryStart((Player)user, machineSlot))
				{
					return true;
				}
				__result = true;
				return false;
			}
		}

		[HarmonyPatch(typeof(Fireplace), "GetHoverText")]
		private static class FireplaceHover
		{
			private static void Postfix(Fireplace __instance, ref string __result)
			{
				if (!string.IsNullOrEmpty(__result) && ShowsHoverLine(MachineSlot.FromFireplace(__instance)))
				{
					__result += AltInteraction.HoverLine("$chestnetwork_fill_hover");
				}
			}
		}

		[HarmonyPatch(typeof(Smelter), "Awake")]
		private static class SmelterAwake
		{
			private static void Postfix(Smelter __instance)
			{
				OwnershipCoordinator.RegisterMachine(__instance.m_nview);
			}
		}

		[HarmonyPatch(typeof(Fireplace), "Awake")]
		private static class FireplaceAwake
		{
			private static void Postfix(Fireplace __instance)
			{
				OwnershipCoordinator.RegisterMachine(__instance.m_nview);
			}
		}

		private static bool ShowsHoverLine(MachineSlot? slot)
		{
			if (slot != null && AltInteraction.Available && ChestNetworkPlugin.Settings.FillEnabled)
			{
				return !double.IsNaN(slot.RemainingCapacity());
			}
			return false;
		}

		public static bool TryFillHovered(Player player, GameObject hovering)
		{
			Switch componentInParent = hovering.GetComponentInParent<Switch>();
			MachineSlot machineSlot = (((Object)(object)componentInParent != (Object)null) ? MachineSlot.FromSwitch(componentInParent) : null);
			if (machineSlot == null)
			{
				Fireplace componentInParent2 = hovering.GetComponentInParent<Fireplace>();
				machineSlot = (((Object)(object)componentInParent2 != (Object)null) ? MachineSlot.FromFireplace(componentInParent2) : null);
			}
			if (machineSlot != null)
			{
				return FillCoordinator.TryStart(player, machineSlot);
			}
			return false;
		}

		public static bool TryFillSwitch(Player player, Switch sw)
		{
			MachineSlot machineSlot = MachineSlot.FromSwitch(sw);
			if (machineSlot != null)
			{
				return FillCoordinator.TryStart(player, machineSlot);
			}
			return false;
		}

		public static string? FillSwitchHover(Player player, Switch sw)
		{
			if (!ShowsHoverLine(MachineSlot.FromSwitch(sw)))
			{
				return null;
			}
			return "$chestnetwork_fill_hover";
		}
	}
	[HarmonyPatch(typeof(InventoryGui), "SetupRequirement")]
	internal static class RequirementDisplayPatch
	{
		private static void Postfix(Transform elementRoot, Requirement req, Player player, int quality, int craftMultiplier, bool __result)
		{
			PluginSettings settings = ChestNetworkPlugin.Settings;
			if (__result && NetworkSession.FeaturesEnabled && settings.ShowAvailableAmount && !((Object)(object)req.m_resItem == (Object)null) && !((Object)(object)player == (Object)null) && !((Object)(object)player != (Object)(object)Player.m_localPlayer))
			{
				int num = req.GetAmount(quality) * craftMultiplier;
				if (num > 0)
				{
					string name = req.m_resItem.m_itemData.m_shared.m_name;
					long available = CountInInventory(((Humanoid)player).GetInventory(), name) + NetworkContext.Wide(player).ContainerStock.GetTotal(name);
					((Component)((Component)elementRoot).transform.Find("res_amount")).GetComponent<TMP_Text>().text = Format(settings.AvailableAmountFormat, num, available);
				}
			}
		}

		private static long CountInInventory(Inventory inventory, string itemName)
		{
			long num = 0L;
			foreach (ItemData allItem in inventory.GetAllItems())
			{
				if (allItem.m_shared.m_name == itemName && allItem.m_worldLevel >= Game.m_worldLevel)
				{
					num += allItem.m_stack;
				}
			}
			return num;
		}

		private static string Format(string format, int required, long available)
		{
			try
			{
				return string.Format(format, required, available);
			}
			catch (FormatException)
			{
				return $"{required}/{available}";
			}
		}
	}
	internal static class RequirementPatches
	{
		[HarmonyPatch]
		private static class CheckScope
		{
			private static IEnumerable<MethodBase> TargetMethods()
			{
				yield return AccessTools.Method(typeof(Player), "HaveRequirements", new Type[2]
				{
					typeof(Piece),
					typeof(RequirementMode)
				}, (Type[])null);
				yield return AccessTools.Method(typeof(Player), "HaveRequirementItems", (Type[])null, (Type[])null);
				yield return AccessTools.Method(typeof(InventoryGui), "SetupRequirement", (Type[])null, (Type[])null);
			}

			private static void Prefix(out bool __state)
			{
				__state = NetworkSession.FeaturesEnabled;
				if (__state)
				{
					s_checkDepth++;
				}
			}

			private static void Finalizer(bool __state)
			{
				if (__state)
				{
					s_checkDepth--;
				}
			}
		}

		[HarmonyPatch]
		private static class CommitScope
		{
			private static IEnumerable<MethodBase> TargetMethods()
			{
				yield return AccessTools.Method(typeof(Player), "UpdatePlacement", (Type[])null, (Type[])null);
				yield return AccessTools.Method(typeof(InventoryGui), "DoCrafting", (Type[])null, (Type[])null);
			}

			private static void Prefix()
			{
				s_commitDepth++;
			}

			private static void Finalizer()
			{
				s_commitDepth--;
			}
		}

		[HarmonyPatch(typeof(Player), "HaveRequirements", new Type[]
		{
			typeof(Piece),
			typeof(RequirementMode)
		})]
		private static class ExplainPieceFailure
		{
			private static void Postfix(Player __instance, Piece piece, RequirementMode mode, bool __result)
			{
				//IL_0003: Unknown result type (might be due to invalid IL or missing references)
				if (!__result && (int)mode == 0 && NetworkSession.FeaturesEnabled)
				{
					ExplainCommitFailure(__instance, piece.m_resources);
				}
			}
		}

		[HarmonyPatch(typeof(Player), "HaveRequirementItems")]
		private static class ExplainRecipeFailure
		{
			private static void Postfix(Player __instance, Recipe piece, bool discover, bool __result)
			{
				if (!__result && !discover && NetworkSession.FeaturesEnabled)
				{
					ExplainCommitFailure(__instance, piece.m_resources);
				}
			}
		}

		[HarmonyPatch(typeof(Inventory), "CountItems")]
		private static class CountItemsPatch
		{
			private static void Postfix(Inventory __instance, string name, int quality, ref int __result)
			{
				if (name != null)
				{
					ResourceCount val = StockFor(__instance);
					if (val != null)
					{
						long num = ((quality < 0) ? val.GetTotal(name) : val.GetTotal(name, quality));
						__result = (int)Math.Min(2147483647L, __result + num);
					}
				}
			}
		}

		[HarmonyPatch(typeof(Inventory), "HaveItem", new Type[]
		{
			typeof(string),
			typeof(bool)
		})]
		private static class HaveItemPatch
		{
			private static void Postfix(Inventory __instance, string name, ref bool __result)
			{
				if (!__result && name != null)
				{
					ResourceCount val = StockFor(__instance);
					if (val != null && val.GetTotal(name) > 0)
					{
						__result = true;
					}
				}
			}
		}

		private const string WaitingMessage = "$chestnetwork_waiting_for_containers";

		private const float WaitingMessageInterval = 2f;

		private static int s_checkDepth;

		private static int s_commitDepth;

		private static float s_lastWaitingMessage = float.NegativeInfinity;

		private static ResourceCount? StockFor(Inventory inventory)
		{
			if (s_checkDepth == 0)
			{
				return null;
			}
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null || inventory != ((Humanoid)localPlayer).GetInventory())
			{
				return null;
			}
			if (s_commitDepth <= 0)
			{
				return NetworkContext.Wide(localPlayer).ContainerStock;
			}
			return NetworkContext.Committable(localPlayer).ContainerStock;
		}

		private static void ExplainCommitFailure(Player player, Requirement[] requirements)
		{
			if (s_commitDepth == 0 || (Object)(object)player != (Object)(object)Player.m_localPlayer || Time.time - s_lastWaitingMessage < 2f)
			{
				return;
			}
			ResourceCount containerStock = NetworkContext.Wide(player).ContainerStock;
			ResourceCount containerStock2 = NetworkContext.Committable(player).ContainerStock;
			foreach (Requirement val in requirements)
			{
				if (!((Object)(object)val.m_resItem == (Object)null))
				{
					string name = val.m_resItem.m_itemData.m_shared.m_name;
					if (containerStock.GetTotal(name) > containerStock2.GetTotal(name))
					{
						s_lastWaitingMessage = Time.time;
						((Character)player).Message((MessageType)2, "$chestnetwork_waiting_for_containers", 0, (Sprite)null, false);
						break;
					}
				}
			}
		}
	}
}
namespace ChestNetwork.Plugin.Ownership
{
	internal static class ActionIntent
	{
		private static readonly List<Requirement> None = new List<Requirement>();

		public static List<Requirement> Current(Player player)
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			if (((Character)player).InPlaceMode())
			{
				Piece selectedPiece = player.GetSelectedPiece();
				if ((Object)(object)selectedPiece == (Object)null || player.m_noPlacementCost || ZoneSystem.instance.GetGlobalKey(selectedPiece.FreeBuildKey()))
				{
					return None;
				}
				return RequirementMapper.ToCore(player, selectedPiece.m_resources, 0, -1, 1);
			}
			InventoryGui instance = InventoryGui.instance;
			if ((Object)(object)instance != (Object)null && InventoryGui.IsVisible() && instance.InCraftTab() && (Object)(object)((RecipeDataPair)(ref instance.m_selectedRecipe)).Recipe != (Object)null)
			{
				Recipe recipe = ((RecipeDataPair)(ref instance.m_selectedRecipe)).Recipe;
				ItemData itemData = ((RecipeDataPair)(ref instance.m_selectedRecipe)).ItemData;
				int qualityLevel = ((itemData == null) ? 1 : (itemData.m_quality + 1));
				int multiplier = ((!instance.m_multiCrafting) ? 1 : instance.m_multiCraftAmount);
				return RequirementMapper.ToCore(player, recipe.m_resources, qualityLevel, -1, multiplier);
			}
			return None;
		}
	}
	internal static class NetworkTransaction
	{
		private sealed class Pending
		{
			public Player Player { get; }

			public float Deadline { get; }

			public IReadOnlyList<ZNetView> Needed { get; }

			public Action<Player> Commit { get; }

			public Pending(Player player, float deadline, IReadOnlyList<ZNetView> needed, Action<Player> commit)
			{
				Player = player;
				Deadline = deadline;
				Needed = needed;
				Commit = commit;
			}
		}

		private const float PreparationTimeout = 3.5f;

		private static Pending? s_pending;

		public static bool Begin(Player player, IReadOnlyList<ZNetView> needed, Action<Player> commit)
		{
			s_pending = new Pending(player, Time.time + 3.5f, needed, commit);
			foreach (ZNetView item in needed)
			{
				OwnershipCoordinator.RequestOwnership(item, player);
			}
			return TryComplete();
		}

		public static void Tick()
		{
			if (NetworkSession.FeaturesEnabled)
			{
				TryComplete();
			}
		}

		private static bool TryComplete()
		{
			Pending pending = s_pending;
			if (pending == null)
			{
				return false;
			}
			if (!(Time.time >= pending.Deadline) && !pending.Needed.All(IsSettled))
			{
				return false;
			}
			s_pending = null;
			if ((Object)(object)pending.Player != (Object)null)
			{
				pending.Commit(pending.Player);
			}
			return true;
		}

		private static bool IsSettled(ZNetView view)
		{
			if (!((Object)(object)view == (Object)null) && view.IsValid() && !OwnershipCoordinator.IsCommittable(view))
			{
				return OwnershipCoordinator.IsUnavailable(view);
			}
			return true;
		}
	}
	internal static class OwnershipCoordinator
	{
		private sealed class Shared
		{
			public ZNetView View { get; }

			public Func<bool> IsInUse { get; }

			public Func<long, bool> HasAccess { get; }

			public Action? OnSynced { get; }

			public Shared(ZNetView view, Func<bool> isInUse, Func<long, bool> hasAccess, Action? onSynced)
			{
				View = view;
				IsInUse = isInUse;
				HasAccess = hasAccess;
				OnSynced = onSynced;
			}
		}

		private const string RequestRpc = "ChestNetwork_RequestOwnership";

		private const string ResponseRpc = "ChestNetwork_OwnershipResponse";

		private const double RequestTimeout = 3.0;

		private const double RetryDelay = 4.0;

		private const double ReservationDuration = 2.0;

		private const double IntentInterval = 0.25;

		private const double GrantedOwnershipTimeout = 10.0;

		private static readonly OwnershipTracker Tracker = new OwnershipTracker(3.0, 4.0);

		private static readonly Dictionary<string, double> ReservedUntil = new Dictionary<string, double>();

		private static readonly Dictionary<string, double> GrantedAt = new Dictionary<string, double>();

		private static readonly Dictionary<string, Shared> Registered = new Dictionary<string, Shared>();

		private static readonly HashSet<int> RegisteredViews = new HashSet<int>();

		private static double s_nextIntentTick;

		private static double Now => Time.time;

		public static string IdOf(ZNetView view)
		{
			return ((object)Unsafe.As<ZDOID, ZDOID>(ref view.GetZDO().m_uid)/*cast due to .constrained prefix*/).ToString();
		}

		public static void RegisterContainer(Container container)
		{
			Register(container.m_nview, () => container.IsInUse() || ((Object)(object)container.m_wagon != (Object)null && container.m_wagon.InUse()) || ((Object)(object)InventoryGui.instance != (Object)null && (Object)(object)InventoryGui.instance.m_currentContainer == (Object)(object)container), (long playerId) => GameSnapshots.HasPrivacyAccess(container, playerId), delegate
			{
				container.Load();
			});
		}

		public static void RegisterMachine(ZNetView view)
		{
			Register(view, () => false, (long _) => true, null);
		}

		public static bool IsCommittable(ZNetView view)
		{
			if ((Object)(object)view != (Object)null && view.IsValid() && view.IsOwner())
			{
				return Tracker.IsUsableWhenOwned(IdOf(view), Now);
			}
			return false;
		}

		public static bool PrepareForCommit(Container container)
		{
			if (!IsCommittable(container.m_nview))
			{
				return false;
			}
			container.Load();
			return true;
		}

		public static bool IsUnavailable(ZNetView view)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Invalid comparison between Unknown and I4
			return (int)Tracker.StateOf(IdOf(view), Now) == 3;
		}

		public static void Reserve(IEnumerable<string> ids)
		{
			foreach (string id in ids)
			{
				ReservedUntil[id] = Now + 2.0;
			}
		}

		public static void RequestOwnership(ZNetView view, Player player)
		{
			if (!((Object)(object)view == (Object)null) && view.IsValid() && !view.IsOwner())
			{
				if (!view.GetZDO().HasOwner())
				{
					view.ClaimOwnership();
				}
				else if (Tracker.TryBeginRequest(IdOf(view), Now))
				{
					view.InvokeRPC("ChestNetwork_RequestOwnership", new object[1] { player.GetPlayerID() });
				}
			}
		}

		public static void Tick()
		{
			if (!NetworkSession.FeaturesEnabled)
			{
				return;
			}
			SyncGrantedObjects();
			if (!(Now < s_nextIntentTick))
			{
				s_nextIntentTick = Now + 0.25;
				PruneReservations();
				Player localPlayer = Player.m_localPlayer;
				if ((Object)(object)localPlayer != (Object)null)
				{
					PrepareIntent(localPlayer);
				}
			}
		}

		private static void Register(ZNetView view, Func<bool> isInUse, Func<long, bool> hasAccess, Action? onSynced)
		{
			if (!((Object)(object)view == (Object)null) && view.GetZDO() != null && RegisteredViews.Add(((Object)view).GetInstanceID()))
			{
				Shared shared = new Shared(view, isInUse, hasAccess, onSynced);
				Registered[IdOf(view)] = shared;
				view.Register<long>("ChestNetwork_RequestOwnership", (Action<long, long>)delegate(long sender, long playerId)
				{
					OnRequest(shared, sender, playerId);
				});
				view.Register<bool, uint>("ChestNetwork_OwnershipResponse", (Action<long, bool, uint>)delegate(long sender, bool granted, uint revision)
				{
					OnResponse(shared, granted, revision);
				});
			}
		}

		private static void PrepareIntent(Player player)
		{
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			List<Requirement> list = ActionIntent.Current(player);
			if (list.Count == 0)
			{
				return;
			}
			NetworkContext networkContext = NetworkContext.Wide(player);
			List<ContainerSnapshot> list2 = networkContext.Selected.Where((ContainerSnapshot val2) => (int)Tracker.StateOf(val2.Id, Now) != 3).ToList();
			PlanResult val = new ConsumptionPlanner(NetworkSession.Config).Plan((IEnumerable<Requirement>)list, (IEnumerable<ItemStack>)GameSnapshots.Items(((Humanoid)player).GetInventory()), (IEnumerable<ContainerSnapshot>)list2);
			if (!val.IsSuccess)
			{
				return;
			}
			foreach (string item in (from w in val.Plan.Withdrawals
				where !w.IsFromInventory
				select w.ContainerId).Distinct())
			{
				Container container = networkContext.EntriesById[item].Container;
				if ((Object)(object)container != (Object)null)
				{
					RequestOwnership(container.m_nview, player);
				}
			}
		}

		private static void OnRequest(Shared shared, long sender, long playerId)
		{
			//IL_0051: 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)
			ZNetView view = shared.View;
			if (!((Object)(object)view == (Object)null) && view.IsValid())
			{
				string text = IdOf(view);
				ReservedUntil.TryGetValue(text, out var value);
				if ((int)OwnershipGrantPolicy.Decide(view.IsOwner(), shared.IsInUse(), shared.HasAccess(playerId), value, Now) != 0)
				{
					view.InvokeRPC(sender, "ChestNetwork_OwnershipResponse", new object[2] { false, 0u });
					return;
				}
				ZDO zDO = view.GetZDO();
				ZDOMan.instance.ForceSendZDO(sender, zDO.m_uid);
				zDO.SetOwner(sender);
				Tracker.Forget(text);
				ReservedUntil.Remove(text);
				view.InvokeRPC(sender, "ChestNetwork_OwnershipResponse", new object[2] { true, zDO.DataRevision });
				NetworkContext.Invalidate();
			}
		}

		private static void OnResponse(Shared shared, bool granted, uint revision)
		{
			if (!((Object)(object)shared.View == (Object)null) && shared.View.IsValid())
			{
				string text = IdOf(shared.View);
				if (granted)
				{
					Tracker.OnGranted(text, revision, Now);
					GrantedAt[text] = Now;
				}
				else
				{
					Tracker.OnDenied(text, Now);
				}
				NetworkContext.Invalidate();
			}
		}

		private static void SyncGrantedObjects()
		{
			foreach (string item in Tracker.AwaitingData())
			{
				if (!Registered.TryGetValue(item, out Shared value) || (Object)(object)value.View == (Object)null || !value.View.IsValid())
				{
					Forget(item);
					continue;
				}
				ZNetView view = value.View;
				if (!view.IsOwner())
				{
					GrantedAt.TryGetValue(item, out var value2);
					if (Now - value2 > 10.0)
					{
						Forget(item);
					}
				}
				else if (Tracker.OnDataRevision(item, view.GetZDO().DataRevision))
				{
					GrantedAt.Remove(item);
					value.OnSynced?.Invoke();
					Reserve(new string[1] { item });
					NetworkContext.Invalidate();
				}
			}
			PruneUnloaded();
		}

		private static void Forget(string id)
		{
			Tracker.Forget(id);
			GrantedAt.Remove(id);
		}

		private static void PruneReservations()
		{
			foreach (string item in (from entry in ReservedUntil
				where entry.Value <= Now
				select entry.Key).ToList())
			{
				ReservedUntil.Remove(item);
			}
		}

		private static void PruneUnloaded()
		{
			if (Registered.Count < 256 || Time.frameCount % 300 != 0)
			{
				return;
			}
			foreach (string item in (from entry in Registered
				where (Object)(object)entry.Value.View == (Object)null || !entry.Value.View.IsValid()
				select entry.Key).ToList())
			{
				Registered.Remove(item);
			}
		}
	}
}
namespace ChestNetwork.Plugin.Net
{
	internal static class HandshakePatches
	{
		[HarmonyPatch(typeof(ZNet), "Awake")]
		private static class ResetOnNewSession
		{
			private static void Postfix()
			{
				NetworkSession.Reset();
			}
		}

		[HarmonyPatch(typeof(ZNet), "OnNewConnection")]
		private static class RegisterOnConnection
		{
			private static void Postfix(ZNet __instance, ZNetPeer peer)
			{
				peer.m_rpc.Register<ZPackage>("ChestNetwork_Version", (Action<ZRpc, ZPackage>)delegate(ZRpc rpc, ZPackage package)
				{
					OnVersion(__instance, rpc, package);
				});
				if (!__instance.IsServer())
				{
					peer.m_rpc.Register<ZPackage>("ChestNetwork_Config", (Action<ZRpc, ZPackage>)OnConfig);
					peer.m_rpc.Invoke("ChestNetwork_Version", new object[1] { VersionPackage(withConfig: false) });
				}
			}
		}

		[HarmonyPatch(typeof(ZNet), "RPC_PeerInfo")]
		private static class CheckOnPeerInfo
		{
			private static bool Prefix(ZNet __instance, ZRpc rpc)
			{
				if (__instance.IsServer())
				{
					if (NetworkSession.IsAccepted(rpc))
					{
						return true;
					}
					ChestNetworkPlugin.Log.LogWarning((object)("Client " + rpc.GetSocket().GetEndPointString() + " has no compatible ChestNetwork: connection refused."));
					rpc.Invoke("Error", new object[1] { 3 });
					return false;
				}
				if (NetworkSession.ServerState == NetworkSession.ServerModState.Unknown)
				{
					ChestNetworkPlugin.Log.LogWarning((object)"Server does not run ChestNetwork: mod disabled for this session.");
					NetworkSession.OnServerMissing();
				}
				return true;
			}
		}

		[HarmonyPatch(typeof(ZNet), "Disconnect")]
		private static class ForgetOnDisconnect
		{
			private static void Prefix(ZNetPeer peer)
			{
				if (peer?.m_rpc != null)
				{
					NetworkSession.ForgetClient(peer.m_rpc);
				}
			}
		}

		private const string VersionRpc = "ChestNetwork_Version";

		private const string ConfigRpc = "ChestNetwork_Config";

		public static void BroadcastConfig()
		{
			if ((Object)(object)ZNet.instance == (Object)null || !ZNet.instance.IsServer())
			{
				return;
			}
			foreach (ZRpc client in NetworkSession.Clients)
			{
				if (client.IsConnected())
				{
					client.Invoke("ChestNetwork_Config", new object[1] { ConfigPackage() });
				}
			}
		}

		private static ZPackage VersionPackage(bool withConfig)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: 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_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Expected O, but got Unknown
			ZPackage val = new ZPackage();
			val.Write(3);
			val.Write("0.4.0");
			val.Write(withConfig ? ModConfigCodec.Encode(ChestNetworkPlugin.Settings.LocalModConfig) : string.Empty);
			return val;
		}

		private static ZPackage ConfigPackage()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Expected O, but got Unknown
			ZPackage val = new ZPackage();
			val.Write(ModConfigCodec.Encode(ChestNetworkPlugin.Settings.LocalModConfig));
			return val;
		}

		private static void OnVersion(ZNet net, ZRpc rpc, ZPackage package)
		{
			int num = package.ReadInt();
			string text = package.ReadString();
			string encoded = package.ReadString();
			if (net.IsServer())
			{
				if (!Protocol.IsCompatible(num))
				{
					ChestNetworkPlugin.Log.LogWarning((object)($"Client {rpc.GetSocket().GetEndPointString()} runs ChestNetwork {text} (protocol {num}), " + $"server needs protocol {3}: connection refused."));
					return;
				}
				NetworkSession.AcceptClient(rpc);
				rpc.Invoke("ChestNetwork_Version", new object[1] { VersionPackage(withConfig: true) });
			}
			else if (!Protocol.IsCompatible(num))
			{
				ChestNetworkPlugin.Log.LogWarning((object)$"Server runs ChestNetwork {text} (protocol {num}): incompatible, mod disabled.");
				NetworkSession.OnServerMissing();
			}
			else
			{
				ApplyServerConfig(encoded, text);
			}
		}

		private static void OnConfig(ZRpc rpc, ZPackage package)
		{
			ApplyServerConfig(package.ReadString(), null);
		}

		private static void ApplyServerConfig(string encoded, string? serverVersion)
		{
			ModConfig config = default(ModConfig);
			string text = default(string);
			if (!ModConfigCodec.TryDecode(encoded, ref config, ref text))
			{
				ChestNetworkPlugin.Log.LogError((object)("Unreadable server configuration (" + text + "): mod disabled."));
				NetworkSession.OnServerMissing();
			}
			else
			{
				NetworkSession.OnServerPresent(config);
				NetworkContext.Invalidate();
				ChestNetworkPlugin.Log.LogInfo((object)((serverVersion == null) ? "Server configuration updated." : ("Server runs ChestNetwork " + serverVersion + ": using its configuration.")));
			}
		}
	}
	internal static class NetworkSession
	{
		public enum ServerModState
		{
			Unknown,
			Present,
			Missing
		}

		private static readonly HashSet<ZRpc> ValidatedClients = new HashSet<ZRpc>();

		private static ModConfig? s_serverConfig;

		public static ServerModState ServerState { get; private set; } = ServerModState.Unknown;

		public static bool IsClient
		{
			get
			{
				if ((Object)(object)ZNet.instance != (Object)null)
				{
					return !ZNet.instance.IsServer();
				}
				return false;
			}
		}

		public static bool FeaturesEnabled
		{
			get
			{
				if (ChestNetworkPlugin.Settings.Enabled)
				{
					if (IsClient)
					{
						return ServerState == ServerModState.Present;
					}
					return true;
				}
				return false;
			}
		}

		public static ModConfig Config
		{
			get
			{
				if (!IsClient || !(s_serverConfig != (ModConfig)null))
				{
					return ChestNetworkPlugin.Settings.LocalModConfig;
				}
				return s_serverConfig;
			}
		}

		public static IEnumerable<ZRpc> Clients => ValidatedClients;

		public static void Reset()
		{
			ValidatedClients.Clear();
			s_serverConfig = null;
			ServerState = ServerModState.Unknown;
		}

		public static void AcceptClient(ZRpc rpc)
		{
			ValidatedClients.Add(rpc);
		}

		public static bool IsAccepted(ZRpc rpc)
		{
			return ValidatedClients.Contains(rpc);
		}

		public static void ForgetClient(ZRpc rpc)
		{
			ValidatedClients.Remove(rpc);
		}

		public static void OnServerPresent(ModConfig config)
		{
			ServerState = ServerModState.Present;
			s_serverConfig = config;
		}

		public static void OnServerMissing()
		{
			ServerState = ServerModState.Missing;
		}
	}
}
namespace ChestNetwork.Plugin.Machines
{
	public enum FillOrigin
	{
		Player,
		Machine
	}
	internal static class FillCoordinator
	{
		public static bool TryStart(Player player, MachineSlot slot)
		{
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			if (!NetworkSession.FeaturesEnabled || !ChestNetworkPlugin.Settings.FillEnabled || double.IsNaN(slot.RemainingCapacity()))
			{
				return false;
			}
			FillPlan val = Plan(player, slot, NetworkContext.At(player, OriginOf(player, slot), committable: false), fromCommittableOnly: false);
			if (val.TotalInserted == 0L)
			{
				FillFeedback.Show(player, val.Status, Array.Empty<Withdrawal>());
				return true;
			}
			List<ZNetView> list = new List<ZNetView> { slot.View };
			list.AddRange(ContainerRegistry.ViewsOf(from w in val.Withdrawals
				where !w.IsFromInventory
				select w.ContainerId));
			if (!NetworkTransaction.Begin(player, list, delegate(Player committing)
			{
				Commit(committing, slot);
			}))
			{
				((Character)player).Message((MessageType)2, "$chestnetwork_fill_preparing", 0, (Sprite)null, false);
			}
			return true;
		}

		private static void Commit(Player player, MachineSlot slot)
		{
			//IL_003c: 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_02f0: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)slot.View == (Object)null || !slot.View.IsValid())
			{
				return;
			}
			if (!OwnershipCoordinator.IsCommittable(slot.View))
			{
				((Character)player).Message((MessageType)2, "$chestnetwork_fill_machine_busy", 0, (Sprite)null, false);
				return;
			}
			NetworkContext networkContext = NetworkContext.At(player, OriginOf(player, slot), committable: true);
			FillPlan val = Plan(player, slot, networkContext, fromCommittableOnly: true);
			if (val.TotalInserted == 0L)
			{
				FillFeedback.Show(player, val.Status, Array.Empty<Withdrawal>());
				return;
			}
			bool allowEquippedItems = NetworkSession.Config.AllowEquippedItems;
			foreach (Withdrawal withdrawal2 in val.Withdrawals)
			{
				InventoryOps.Remove(withdrawal2.IsFromInventory ? ((Humanoid)player).GetInventory() : networkContext.EntriesById[withdrawal2.ContainerId].Container.GetInventory(), withdrawal2.ItemId, withdrawal2.Quality, withdrawal2.Amount, allowEquippedItems || !withdrawal2.IsFromInventory);
			}
			List<KeyValuePair<string, long>> list = new List<KeyValuePair<string, long>>();
			foreach (Withdrawal withdrawal in val.Withdrawals)
			{
				int num = list.FindIndex((KeyValuePair<string, long> unit) => unit.Key == withdrawal.ItemId);
				if (num < 0)
				{
					list.Add(new KeyValuePair<string, long>(withdrawal.ItemId, withdrawal.Amount));
				}
				else
				{
					list[num] = new KeyValuePair<string, long>(withdrawal.ItemId, list[num].Value + withdrawal.Amount);
				}
			}
			long num2 = slot.Insert(list);
			FillSettlement val2 = val.Settle(num2);
			foreach (Withdrawal item in val2.Refunded)
			{
				ContainerRegistry.Entry value;
				Container origin = ((item.ContainerId != null && networkContext.EntriesById.TryGetValue(item.ContainerId, out value)) ? value.Container : null);
				ItemReturn.GiveBack(player, item.ItemId, item.Quality, item.Amount, origin);
			}
			if (val2.Refunded.Count > 0)
			{
				ChestNetworkPlugin.Log.LogWarning((object)$"Machine accepted {num2} of {val.TotalInserted} planned units; the rest was given back.");
			}
			List<string> list2 = (from w in val.Withdrawals
				where !w.IsFromInventory
				select w.ContainerId).Distinct().ToList();
			list2.Add(OwnershipCoordinator.IdOf(slot.View));
			OwnershipCoordinator.Reserve(list2);
			NetworkContext.Invalidate();
			FillFeedback.Show(player, val.Status, val2.Inserted);
		}

		private static FillPlan Plan(Player player, MachineSlot slot, NetworkContext context, bool fromCommittableOnly)
		{
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			IEnumerable<ContainerSnapshot> enumerable = context.Selected;
			if (!fromCommittableOnly)
			{
				enumerable = enumerable.Where((ContainerSnapshot c) => !OwnershipCoordinator.IsUnavailable(context.EntriesById[c.Id].Container.m_nview));
			}
			return new MachineFillPlanner(NetworkSession.Config, ChestNetworkPlugin.Settings.FillSettings).Plan(slot.RemainingCapacity(), (IEnumerable<string>)slot.AcceptedItems(ChestNetworkPlugin.Settings.FillOrePriority), (IEnumerable<ItemStack>)GameSnapshots.Items(((Humanoid)player).GetInventory()), enumerable);
		}

		private static Vector3 OriginOf(Player player, MachineSlot slot)
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			if (ChestNetworkPlugin.Settings.FillOrigin != FillOrigin.Machine)
			{
				return ((Component)player).transform.position;
			}
			return slot.Transform.position;
		}
	}
	internal static class FillFeedback
	{
		public const string Preparing = "$chestnetwork_fill_preparing";

		public const string MachineBusy = "$chestnetwork_fill_machine_busy";

		public const string AlreadyFull = "$chestnetwork_fill_already_full";

		public const string NothingToAdd = "$chestnetwork_fill_nothing_to_add";

		public const string HoverAction = "$chestnetwork_fill_hover";

		public static void Show(Player player, FillStatus status, IReadOnlyList<Withdrawal> inserted)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Invalid comparison between Unknown and I4
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Invalid comparison between Unknown and I4
			string text = ((inserted.Count > 0) ? Added(inserted) : (((int)status == 2) ? "$chestnetwork_fill_already_full" : (((int)status == 3) ? "$chestnetwork_fill_nothing_to_add" : null)));
			if (text != null)
			{
				((Character)player).Message((MessageType)2, text, 0, (Sprite)null, false);
			}
		}

		private static string Added(IReadOnlyList<Withdrawal> inserted)
		{
			return string.Join(", ", from w in inserted
				group w by w.ItemId into @group
				select $"+{@group.Sum((Withdrawal w) => w.Amount)} {Localization.instance.Localize(@group.Key)}");
		}
	}
	public enum OrePriority
	{
		QueuedFirst,
		MachineOrder
	}
	internal abstract class MachineSlot
	{
		private sealed class SmelterOre : MachineSlot
		{
			private readonly Smelter _smelter;

			public SmelterOre(Smelter smelter)
				: base(smelter.m_nview, ((Component)smelter).transform)
			{
				_smelter = smelter;
			}

			public override double RemainingCapacity()
			{
				return Math.Max(0, _smelter.m_maxOre - _smelter.GetQueueSize());
			}

			public override IReadOnlyList<string> AcceptedItems(OrePriority priority)
			{
				List<string> list = new List<string>();
				Dictionary<string, string> dictionary = new Dictionary<string, string>();
				foreach (ItemConversion item in _smelter.m_conversion)
				{
					if (!((Object)(object)item.m_from == (Object)null))
					{
						string name = item.m_from.m_itemData.m_shared.m_name;
						list.Add(name);
						dictionary[((Object)((Component)item.m_from).gameObject).name] = name;
					}
				}
				if (priority == OrePriority.MachineOrder)
				{
					return list;
				}
				List<string> ordered = new List<string>();
				ZDO zDO = base.View.GetZDO();
				int queueSize = _smelter.GetQueueSize();
				for (int i = 0; i < queueSize; i++)
				{
					if (dictionary.TryGetValue(zDO.GetString("item" + i, ""), out var value) && !ordered.Contains(value))
					{
						ordered.Add(value);
					}
				}
				ordered.AddRange(list.Where((string shared) => !ordered.Contains(shared)));
				return ordered;
			}

			public override long Insert(IReadOnlyList<KeyValuePair<string, long>> units)
			{
				//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ab: 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_00bf: Unknown result type (might be due to invalid IL or missing references)
				long num = (long)RemainingCapacity();
				long num2 = 0L;
				foreach (KeyValuePair<string, long> unit in units)
				{
					string text = PrefabOf(unit.Key);
					long num3 = ((text == null) ? 0 : Math.Min(unit.Value, num - num2));
					for (long num4 = 0L; num4 < num3; num4++)
					{
						_smelter.QueueOre(text, false);
					}
					num2 += num3;
					if (num3 < unit.Value)
					{
						break;
					}
				}
				if (num2 > 0)
				{
					_smelter.m_oreAddedEffects.Create(base.Transform.position, base.Transform.rotation, (Transform)null, 1f, -1, default(ZDOID));
				}
				return num2;
			}

			private string? PrefabOf(string shared)
			{
				return (from conversion in _smelter.m_conversion
					where (Object)(object)conversion.m_from != (Object)null && conversion.m_from.m_itemData.m_shared.m_name == shared
					select ((Object)((Component)conversion.m_from).gameObject).name).FirstOrDefault();
			}
		}

		private sealed class SmelterFuel : MachineSlot
		{
			private readonly Smelter _smelter;

			public SmelterFuel(Smelter smelter)
				: base(smelter.m_nview, ((Component)smelter).transform)
			{
				_smelter = smelter;
			}

			public override double RemainingCapacity()
			{
				if (!((Object)(object)_smelter.m_fuelItem == (Object)null) && _smelter.m_maxFuel > 0)
				{
					return Math.Max(0.0, Math.Floor((float)_smelter.m_maxFuel - _smelter.GetFuel()));
				}
				return double.NaN;
			}

			public override IReadOnlyList<string> AcceptedItems(OrePriority priority)
			{
				return new string[1] { _smelter.m_fuelItem.m_itemData.m_shared.m_name };
			}

			public override long Insert(IReadOnlyList<KeyValuePair<string, long>> units)
			{
				//IL_0050: Unknown result type (might be due to invalid IL or missing references)
				//IL_005b: Unknown result type (might be due to invalid IL or missing references)
				//IL_006e: 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)
				double num = RemainingCapacity();
				long num2 = (double.IsNaN(num) ? 0 : Math.Min(Sum(units), (long)num));
				if (num2 > 0)
				{
					_smelter.SetFuel(_smelter.GetFuel() + (float)num2);
					_smelter.m_fuelAddedEffects.Create(base.Transform.position, base.Transform.rotation, base.Transform, 1f, -1, default(ZDOID));
				}
				return num2;
			}
		}

		private sealed class FireplaceFuel : MachineSlot
		{
			private readonly Fireplace _fireplace;

			private float Fuel => base.View.GetZDO().GetFloat(ZDOVars.s_fuel, 0f);

			public FireplaceFuel(Fireplace fireplace)
				: base(fireplace.m_nview, ((Component)fireplace).transform)
			{
				_fireplace = fireplace;
			}

			public override double RemainingCapacity()
			{
				if (_fireplace.m_canRefill && !_fireplace.m_infiniteFuel && !((Object)(object)_fireplace.m_fuelItem == (Object)null))
				{
					return Math.Max(0.0, Math.Ceiling(_fireplace.m_maxFuel) - Math.Ceiling(Fuel));
				}
				return double.NaN;
			}

			public override IReadOnlyList<string> AcceptedItems(OrePriority priority)
			{
				return new string[1] { _fireplace.m_fuelItem.m_itemData.m_shared.m_name };
			}

			public override long Insert(IReadOnlyList<KeyValuePair<string, long>> units)
			{
				//IL_006c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0077: Unknown result type (might be due to invalid IL or missing references)
				//IL_0085: 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)
				double num = RemainingCapacity();
				long num2 = (double.IsNaN(num) ? 0 : Math.Min(Sum(units), (long)num));
				if (num2 > 0)
				{
					float num3 = Mathf.Clamp(Fuel + (float)num2, 0f, _fireplace.m_maxFuel);
					base.View.GetZDO().Set(ZDOVars.s_fuel, num3);
					_fireplace.m_fuelAddedEffects.Create(base.Transform.position, base.Transform.rotation, (Transform)null, 1f, -1, default(ZDOID));
					_fireplace.UpdateState();
				}
				return num2;
			}
		}

		public ZNetView View { get; }

		public Transform Transform { get; }

		protected MachineSlot(ZNetView view, Transform transform)
		{
			View = view;
			Transform = transform;
		}

		public abstract double RemainingCapacity();

		public abstract IReadOnlyList<string> AcceptedItems(OrePriority priority);

		public abstract long Insert(IReadOnlyList<KeyValuePair<string, long>> units);

		public static MachineSlot? FromSwitch(Switch sw)
		{
			Smelter componentInParent = ((Component)sw).GetComponentInParent<Smelter>();
			if ((Object)(object)componentInParent == (Object)null || (Object)(object)componentInParent.m_nview == (Object)null || !componentInParent.m_nview.IsValid())
			{
				return null;
			}
			if ((Object)(object)sw == (Object)(object)componentInParent.m_addOreSwitch)
			{
				return new SmelterOre(componentInParent);
			}
			if (!((Object)(object)sw == (Object)(object)componentInParent.m_addWoodSwitch))
			{
				return null;
			}
			return new SmelterFuel(componentInParent);
		}

		public static MachineSlot? FromFireplace(Fireplace fireplace)
		{
			if (!((Object)(object)fireplace.m_nview != (Object)null) || !fireplace.m_nview.IsValid())
			{
				return null;
			}
			return new FireplaceFuel(fireplace);
		}

		protected static long Sum(IReadOnlyList<KeyValuePair<string, long>> units)
		{
			return units.Sum<KeyValuePair<string, long>>((KeyValuePair<string, long> unit) => unit.Value);
		}
	}
	internal static class PrefabIndex
	{
		private static readonly Dictionary<string, GameObject> ByShared = new Dictionary<string, GameObject>();

		public static GameObject? Find(string sharedName)
		{
			if (ByShared.TryGetValue(sharedName, out GameObject value) && (Object)(object)value != (Object)null)
			{
				return value;
			}
			if ((Object)(object)ObjectDB.instance == (Object)null)
			{
				return null;
			}
			foreach (GameObject item in ObjectDB.instance.m_items)
			{
				ItemDrop val = (((Object)(object)item != (Object)null) ? item.GetComponent<ItemDrop>() : null);
				if ((Object)(object)val != (Object)null && val.m_itemData.m_shared.m_name == sharedName)
				{
					ByShared[sharedName] = item;
					return item;
				}
			}
			return null;
		}
	}
}
namespace ChestNetwork.Plugin.Interaction
{
	internal static class AltInteraction
	{
		private sealed class SwitchHandler
		{
			public Func<Player, Switch, bool> Act { get; }

			public Func<Player, Switch, string?> HoverAction { get; }

			public SwitchHandler(Func<Player, Switch, bool> act, Func<Player, Switch, string?> hoverAction)
			{
				Act = act;
				HoverAction = hoverAction;
			}
		}

		[HarmonyPatch(typeof(Switch), "Interact")]
		private static class SwitchInteract
		{
			private static bool Prefix(Switch __instance, Humanoid character, bool hold, bool alt, ref bool __result)
			{
				//IL_0026: Unknown result type (might be due to invalid IL or missing references)
				//IL_0031: Expected O, but got Unknown
				if (!IsAltUse(character, hold, alt))
				{
					return true;
				}
				foreach (SwitchHandler switchHandler in SwitchHandlers)
				{
					if (switchHandler.Act((Player)character, __instance))
					{
						__result = true;
						return false;
					}
				}
				return true;
			}
		}

		[HarmonyPatch(typeof(Switch), "GetHoverText")]
		private static class SwitchHover
		{
			private static void Postfix(Switch __instance, ref string __result)
			{
				Player localPlayer = Player.m_localPlayer;
				if ((Object)(object)localPlayer == (Object)null || !Available)
				{
					return;
				}
				foreach (SwitchHandler switchHandler in SwitchHandlers)
				{
					string text = switchHandler.HoverAction(localPlayer, __instance);
					if (text != null)
					{
						__result += HoverLine(text);
						break;
					}
				}
			}
		}

		private static readonly List<Func<Player, GameObject, bool>> Handlers = new List<Func<Player, GameObject, bool>>();

		private static readonly List<SwitchHandler> SwitchHandlers = new List<SwitchHandler>();

		public static bool Available
		{
			get
			{
				if (NetworkSession.FeaturesEnabled)
				{
					return ChestNetworkPlugin.Settings.UseAltInteract;
				}
				return false;
			}
		}

		public static bool IsAltUse(Humanoid user, bool hold, bool alt)
		{
			if (alt && !hold && (Object)(object)user == (Object)(object)Player.m_localPlayer)
			{
				return ChestNetworkPlugin.Settings.UseAltInteract;
			}
			return false;
		}

		public static void Register(Func<Player, GameObject, bool> handler)
		{
			Handlers.Add(handler);
		}

		public static void RegisterSwitch(Func<Player, Switch, bool> act, Func<Player, Switch, string?> hoverAction)
		{
			SwitchHandlers.Add(new SwitchHandler(act, hoverAction));
		}

		public static string HoverLine(string action)
		{
			string text = ((ZInput.IsNonClassicFunctionality() && ZInput.IsGamepadActive()) ? "$KEY_AltKeys + $KEY_Use" : "$KEY_AltPlace + $KEY_Use");
			return Localization.instance.Localize("\n[<color=yellow><b>" + text + "</b></color>] " + action);
		}

		public static void Tick()
		{
			//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)
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null || !NetworkSession.FeaturesEnabled)
			{
				return;
			}
			KeyboardShortcut altShortcut = ChestNetworkPlugin.Settings.AltShortcut;
			if (!((KeyboardShortcut)(ref altShortcut)).IsDown() || !((Character)localPlayer).TakeInput())
			{
				return;
			}
			GameObject hovering = localPlayer.m_hovering;
			if ((Object)(object)hovering == (Object)null)
			{
				return;
			}
			using List<Func<Player, GameObject, bool>>.Enumerator enumerator = Handlers.GetEnumerator();
			while (enumerator.MoveNext() && !enumerator.Current(localPlayer, hovering))
			{
			}
		}
	}
}
namespace ChestNetwork.Plugin.Armor
{
	internal static class ArmorPieces
	{
		public static ArmorSlot? SlotOf(ItemType type)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Invalid comparison between Unknown and I4
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Invalid comparison between Unknown and I4
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Invalid comparison between Unknown and I4
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Invalid comparison between Unknown and I4
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Invalid comparison between Unknown and I4
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Invalid comparison between Unknown and I4
			if ((int)type <= 7)
			{
				if ((int)type == 6)
				{
					return (ArmorSlot)0;
				}
				if ((int)type == 7)
				{
					return (ArmorSlot)1;
				}
			}
			else
			{
				if ((int)type == 11)
				{
					return (ArmorSlot)2;
				}
				if ((int)type == 17)
				{
					return (ArmorSlot)3;
				}
				if ((int)type == 18)
				{
					return (ArmorSlot)4;
				}
			}
			return null;
		}

		public static ArmorPiece? Of(ItemData item, string? containerId, int slot)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: 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)
			//IL_007c: Expected O, but got Unknown
			if (!((Object)(object)item?.m_dropPrefab == (Object)null))
			{
				ArmorSlot? val = SlotOf(item.m_shared.m_itemType);
				if (val.HasValue)
				{
					ArmorSlot valueOrDefault = val.GetValueOrDefault();
					return new ArmorPiece(containerId, slot, ((Object)item.m_dropPrefab).name, item.m_shared.m_name, item.m_quality, valueOrDefault, item.m_shared.m_setName, (double)item.m_shared.m_armor, item.m_equipped);
				}
			}
			return null;
		}

		public static List<ArmorPiece> In(Inventory inventory, string? containerId)
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			List<ArmorPiece> list = new List<ArmorPiece>();
			int width = inventory.GetWidth();
			foreach (ItemData allItem in inventory.GetAllItems())
			{
				ArmorPiece val = Of(allItem, containerId, GameSnapshots.SlotOf(allItem.m_gridPos, width));
				if (val != (ArmorPiece)null)
				{
					list.Add(val);
				}
			}
			return list;
		}

		public static ItemData? Find(Inventory inventory, ArmorPiece piece)
		{
			//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_0013: 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)
			Vector2i val = GameSnapshots.GridPosOf(piece.Slot, inventory.GetWidth());
			ItemData itemAt = inventory.GetItemAt(val.x, val.y);
			ArmorPiece val2 = ((itemAt != null) ? Of(itemAt, piece.ContainerId, piece.Slot) : null);
			if (!(val2 != (ArmorPiece)null) || !(val2.PrefabName == piece.PrefabName) || val2.Quality != piece.Quality || val2.IsEquipped)
			{
				return null;
			}
			return itemAt;
		}

		public static Dictionary<ArmorSlot, ItemData> Worn(Player player)
		{
			Dictionary<ArmorSlot, ItemData> dictionary = new Dictionary<ArmorSlot, ItemData>();
			Add(dictionary, (ArmorSlot)0, ((Humanoid)player).m_helmetItem);
			Add(dictionary, (ArmorSlot)1, ((Humanoid)player).m_chestItem);
			Add(dictionary, (ArmorSlot)2, ((Humanoid)player).m_legItem);
			Add(dictionary, (ArmorSlot)3, ((Humanoid)player).m_shoulderItem);
			Add(dictionary, (ArmorSlot)4, ((Humanoid)player).m_utilityItem);
			return dictionary;
		}

		private static void Add(Dictionary<ArmorSlot, ItemData> worn, ArmorSlot slot, ItemData? item)
		{
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			if (item != null)
			{
				worn.Add(slot, item);
			}
		}
	}
	internal static class ArmorStandCoordinator
	{
		private sealed class SwapState
		{
			public ArmorSwapPlan Plan { get; }

			public Dictionary<ArmorSlot, ArmorPiece> Stand { get; }

			public Dictionary<ArmorSlot, ArmorPiece> Worn { get; }

			public int Weapons { get; }

			public int Free { get; }

			public SwapState(ArmorSwapPlan plan, Dictionary<ArmorSlot, ArmorPiece> stand, Dictionary<ArmorSlot, ArmorPiece> worn, int weapons, int free)
			{
				Plan = plan;
				Stand = stand;
				Worn = worn;
				Weapons = weapons;
				Free = free;
			}
		}

		private const string InventoryFull = "$inventory_full";

		private static bool s_catalogReported;

		public static bool TryStart(Player player, ArmorStand stand)
		{
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			if (!NetworkSession.FeaturesEnabled || !ChestNetworkPlugin.Settings.ArmorStandEnabled || (Object)(object)stand == (Object)null || (Object)(object)stand.m_nview == (Object)null || !stand.m_nview.IsValid())
			{
				return false;
			}
			ArmorStandView armorStandView = new ArmorStandView(stand);
			if (!PrivateArea.CheckAccess(armorStandView.Position, 0f, true, false))
			{
				return true;
			}
			ReportUncataloguedArmorOnce();
			if (HoldsArmor(armorStandView))
			{
				return StartSwap(player, armorStandView);
			}
			return StartFill(player, armorStandView);
		}

		public static string? HoverAction(Player player, Switch sw)
		{
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			ArmorStand componentInParent = ((Component)sw).GetComponentInParent<ArmorStand>();
			if ((Object)(object)componentInParent == (Object)null || !ChestNetworkPlugin.Settings.ArmorStandEnabled || (Object)(object)componentInParent.m_nview == (Object)null || !componentInParent.m_nview.IsValid() || !componentInParent.m_slots.Any((ArmorStandSlot slot) => (Object)(object)slot.m_switch == (Object)(object)sw) || !PrivateArea.CheckAccess(((Component)componentInParent).transform.position, 0f, false, false))
			{
				return null;
			}
			if (!HoldsArmor(new ArmorStandView(componentInParent)))
			{
				return "$chestnetwork_armor_fill_hover";
			}
			return "$chestnetwork_armor_swap_hover";
		}

		private static bool HoldsArmor(ArmorStandView view)
		{
			return view.ManagedSlots().Values.Any(view.Has);
		}

		private static bool StartFill(Player player, ArmorStandView view)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			NetworkContext context = NetworkContext.At(player, ((Component)player).transform.position, committable: false);
			ArmorFillPlan val = PlanFill(player, view, context, skipUnavailable: true);
			if (val.Choices.Count == 0)
			{
				((Character)player).Message((MessageType)2, "$chestnetwork_armor_nothing", 0, (Sprite)null, false);
				return true;
			}
			List<ZNetView> list = new List<ZNetView> { view.View };
			list.AddRange(ContainerRegistry.ViewsOf(from c in val.Choices
				where c.Value.ContainerId != null
				select c.Value.ContainerId));
			if (!NetworkTransaction.Begin(player, list, delegate(Player committing)
			{
				CommitFill(committing, view);
			}))
			{
				((Character)player).Message((MessageType)2, "$chestnetwork_armor_preparing", 0, (Sprite)null, false);
			}
			return true;
		}

		private static ArmorFillPlan PlanFill(Player player, ArmorStandView view, NetworkContext context, bool skipUnavailable)
		{
			//IL_0156: Unknown result type (might be due to invalid IL or missing references)
			Dictionary<ArmorSlot, int> managed = view.ManagedSlots();
			List<ArmorSlot> list = (from slot in managed
				where !view.Has(slot.Value)
				select slot.Key).ToList();
			IEnumerable<ContainerSnapshot> source = context.Selected;
			if (skipUnavailable)
			{
				source = source.Where((ContainerSnapshot c) => !OwnershipCoordinator.IsUnavailable(context.EntriesById[c.Id].Container.m_nview));
			}
			List<string> list2 = source.Select((ContainerSnapshot c) => c.Id).ToList();
			List<ArmorPiece> list3 = new List<ArmorPiece>(ArmorPieces.In(((Humanoid)player).GetInventory(), null));
			foreach (string item in list2)
			{
				list3.AddRange(ArmorPieces.In(context.EntriesById[item].Container.GetInventory(), item));
			}
			list3 = list3.Where(delegate(ArmorPiece piece)
			{
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				if (managed.TryGetValue(piece.SlotType, out var value))
				{
					ItemData val = Item(player, context, piece);
					if (val != null)
					{
						return view.CanPlace(value, val);
					}
				}
				return false;
			}).ToList();
			return new ArmorFillPlanner(ChestNetworkPlugin.Settings.ArmorSets, ChestNetworkPlugin.Settings.ArmorFillSettings).Plan((IEnumerable<ArmorPiece>)list3, (IReadOnlyList<string>)list2, (IEnumerable<ArmorSlot>)list, ((Humanoid)player).GetInventory().GetWidth());
		}

		private static void CommitFill(Player player, ArmorStandView view)
		{
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0164: Unknown result type (might be due to invalid IL or missing references)
			//IL_0275: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)view.View == (Object)null || !view.View.IsValid())
			{
				return;
			}
			if (!OwnershipCoordinator.IsCommittable(view.View))
			{
				((Character)player).Message((MessageType)2, "$chestnetwork_armor_busy", 0, (Sprite)null, false);
				return;
			}
			NetworkContext networkContext = NetworkContext.At(player, ((Component)player).transform.position, committable: true);
			ArmorFillPlan val = PlanFill(player, view, networkContext, skipUnavailable: false);
			if (val.Choices.Count == 0)
			{
				((Character)player).Message((MessageType)2, "$chestnetwork_armor_nothing", 0, (Sprite)null, false);
				return;
			}
			Dictionary<ArmorSlot, int> dictionary = view.ManagedSlots();
			List<ArmorPiece> list = new List<ArmorPiece>(ArmorPieces.In(((Humanoid)player).GetInventory(), null));
			List<string> list2 = (from c in val.Choices
				where c.Value.ContainerId != null
				select c.Value.ContainerId).Distinct().ToList();
			foreach (string item in list2)
			{
				list.AddRange(ArmorPieces.In(networkContext.EntriesById[item].Container.GetInventory(), item));
			}
			ValidationResult val2 = new PlanValidator(NetworkSession.Config).ValidateArmorFill(val, (IEnumerable<ArmorPiece>)list, (IEnumerable<ContainerSnapshot>)networkContext.Reread(list2), from slot in dictionary
				where !view.Has(slot.Value)
				select slot.Key, view.Id);
			if (!val2.IsValid)
			{
				ChestNetworkPlugin.Log.LogInfo((object)("Armor stand fill invalidated before commit: " + string.Join("; ", val2.Issues)));
				return;
			}
			HashSet<string> hashSet = new HashSet<string> { view.Id };
			foreach (KeyValuePair<ArmorSlot, ArmorPiece> choice in val.Choices)
			{
				Inventory val3 = ((choice.Value.ContainerId == null) ? ((Humanoid)player).GetInventory() : networkContext.EntriesById[choice.Value.ContainerId].Container.GetInventory());
				ItemData val4 = ArmorPieces.Find(val3, choice.Value);
				if (val4 != null)
				{
					view.Write(dictionary[choice.Key], val4);
					val3.RemoveOneItem(val4);
					if (choice.Value.ContainerId != null)
					{
						hashSet.Add(choice.Value.ContainerId);
					}
				}
			}
			view.PlayEffect();
			OwnershipCoordinator.Reserve(hashSet);
			NetworkContext.Invalidate();
		}

		private static ItemData? Item(Player player, NetworkContext context, ArmorPiece piece)
		{
			return ArmorPieces.Find((piece.ContainerId == null) ? ((Humanoid)player).GetInventory() : context.EntriesById[piece.ContainerId].Container.GetInventory(), piece);
		}

		private static bool StartSwap(Player player, ArmorStandView view)
		{
			if (!PlanSwap(player, view).Plan.IsFeasible)
			{
				((Character)player).Message((MessageType)2, "$inventory_full", 0, (Sprite)null, false);
				return true;
			}
			if (!NetworkTransaction.Begin(player, (IReadOnlyList<ZNetView>)(object)new ZNetView[1] { view.View }, delegate(Player committing)
			{
				CommitSwap(committing, view);
			}))
			{
				((Character)player).Message((MessageType)2, "$chestnetwork_armor_preparing", 0, (Sprite)null, false);
			}
			return true;
		}

		private static SwapState PlanSwap(Player player, ArmorStandView view)
		{
			//IL_0050: 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_00a7: Expected I4, but got Unknown
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			Dictionary<ArmorSlot, int> dictionary = view.ManagedSlots();
			Dictionary<ArmorSlot, ArmorPiece> dictionary2 = new Dictionary<ArmorSlot, ArmorPiece>();
			foreach (KeyValuePair<ArmorSlot, int> item i