using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using EmployeeTweaks;
using EmployeeTweaks.Helpers;
using EmployeeTweaks.Network;
using EmployeeTweaks.Patches.EmployeeArea;
using EmployeeTweaks.Patches.FilterItemApply;
using EmployeeTweaks.Patches.Unpackaging;
using EmployeeTweaks.Persistence;
using FishNet;
using FishNet.Connection;
using FishNet.Object;
using HarmonyLib;
using MelonLoader;
using MelonLoader.Preferences;
using MelonLoader.Utils;
using Microsoft.CodeAnalysis;
using S1API.Entities;
using S1API.Internal.Abstraction;
using S1API.Saveables;
using S1API.UI;
using ScheduleOne;
using ScheduleOne.Core.Items.Framework;
using ScheduleOne.Effects;
using ScheduleOne.Employees;
using ScheduleOne.EntityFramework;
using ScheduleOne.Growing;
using ScheduleOne.ItemFramework;
using ScheduleOne.Management;
using ScheduleOne.NPCs;
using ScheduleOne.NPCs.Behaviour;
using ScheduleOne.ObjectScripts;
using ScheduleOne.PlayerScripts;
using ScheduleOne.Product;
using ScheduleOne.Property;
using ScheduleOne.Tiles;
using ScheduleOne.Tools;
using ScheduleOne.UI.Items;
using ScheduleOne.UI.Management;
using Semver;
using SteamNetworkLib;
using SteamNetworkLib.Events;
using SteamNetworkLib.Models;
using Steamworks;
using TMPro;
using UnityEngine;
using UnityEngine.Events;
using UnityEngine.SceneManagement;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: MelonInfo(typeof(global::EmployeeTweaks.EmployeeTweaks), "EmployeeTweaks", "1.0.5", "k073l", null)]
[assembly: MelonColor(1, 217, 131, 36)]
[assembly: MelonGame("TVGS", "Schedule I")]
[assembly: MelonOptionalDependencies(new string[] { "SteamNetworkLib" })]
[assembly: MelonPlatformDomain(/*Could not decode attribute arguments.*/)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: IgnoresAccessChecksTo("Assembly-CSharp")]
[assembly: AssemblyCompany("EmployeeTweaks-Mono")]
[assembly: AssemblyConfiguration("Mono")]
[assembly: AssemblyDescription("Various employee tweaks - unpackaging, sprinkler/pourer use and more")]
[assembly: AssemblyFileVersion("1.0.5.0")]
[assembly: AssemblyInformationalVersion("1.0.5+849dbbb6d27c6c028f7583f6aca013d2bcbac764")]
[assembly: AssemblyProduct("EmployeeTweaks-Mono")]
[assembly: AssemblyTitle("EmployeeTweaks-Mono")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.5.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 EmployeeTweaks
{
	public static class BuildInfo
	{
		public const string Name = "EmployeeTweaks";

		public const string Description = "Various employee tweaks - unpackaging, sprinkler/pourer use and more";

		public const string Author = "k073l";

		public const string Version = "1.0.5";
	}
	public class EmployeeTweaks : MelonMod
	{
		private static Instance Logger;

		private DebugAreaDrawer debugAreaDrawer;

		private bool _lastShift;

		private bool _lastCtrl;

		internal SettingsRegistry SettingsRegistry;

		internal INetworkManager? NetworkManager;

		public override void OnInitializeMelon()
		{
			Logger = ((MelonBase)this).LoggerInstance;
			CheckDependencies();
			MoveItemBehaviourPatches.ManualPatchDestinationValid(((MelonBase)this).HarmonyInstance);
		}

		public override void OnLateInitializeMelon()
		{
			SettingsRegistry = new SettingsRegistry();
			NetworkManager = NetworkLoader.Create();
			if (NetworkManager == null)
			{
				Logger.Warning("NetworkManager is null, multiplayer features will be unavailable.");
			}
			SettingsRegistry.InitializeCategories();
			debugAreaDrawer = new DebugAreaDrawer();
			DebugAreaDrawer.WireDebugAreaDrawer(debugAreaDrawer);
			Logger.Msg("EmployeeTweaks initialized");
		}

		public override void OnUpdate()
		{
			NetworkManager?.Update();
		}

		public override void OnLateUpdate()
		{
			TextMeshProUGUI applyItemAsFilterButtonText = FilterConfigPanelPatches.ApplyItemAsFilterButtonText;
			if (!((Object)(object)applyItemAsFilterButtonText == (Object)null))
			{
				bool flag = Input.GetKey((KeyCode)304) || Input.GetKey((KeyCode)303);
				bool flag2 = Input.GetKey((KeyCode)306) || Input.GetKey((KeyCode)305);
				if (flag != _lastShift || flag2 != _lastCtrl)
				{
					_lastShift = flag;
					_lastCtrl = flag2;
					FilterConfigPanelPatches.AllSlots = flag;
					FilterConfigPanelPatches.DenyListMode = flag2;
					((TMP_Text)applyItemAsFilterButtonText).text = (flag ? "Apply All As Filters" : "Apply Item As Filter");
				}
			}
		}

		public override void OnDeinitializeMelon()
		{
			NetworkManager?.Dispose();
		}

		private static void CheckDependencies()
		{
			DependenciesChecker dependenciesChecker = new DependenciesChecker
			{
				ShowMenuBanner = true,
				UnloadIfMissingRequired = true
			};
			dependenciesChecker.AddDependency(new DependencyInfo
			{
				Name = "S1API (Forked)",
				AssemblyName = "S1API",
				IsRequired = true,
				Version = "3.0.2",
				Urls = new List<DependencyUrl>(3)
				{
					new DependencyUrl
					{
						SourceName = "Thunderstore",
						Url = "https://thunderstore.io/c/schedule-i/p/ifBars/S1API_Forked/"
					},
					new DependencyUrl
					{
						SourceName = "NexusMods",
						Url = "https://www.nexusmods.com/schedule1/mods/1194"
					},
					new DependencyUrl
					{
						SourceName = "Github",
						Url = "https://github.com/ifBars/S1API/releases/"
					}
				}
			});
			dependenciesChecker.AddDependency(new DependencyInfo
			{
				Name = "SteamNetworkLib",
				AssemblyName = "SteamNetworkLib",
				IsRequired = false,
				Version = "1.2.1",
				Urls = new List<DependencyUrl>(4)
				{
					new DependencyUrl
					{
						SourceName = "Thunderstore Il2Cpp",
						Url = "https://thunderstore.io/c/schedule-i/p/ifBars/SteamNetworkLib_Il2Cpp/"
					},
					new DependencyUrl
					{
						SourceName = "Thunderstore Mono",
						Url = "https://thunderstore.io/c/schedule-i/p/ifBars/SteamNetworkLib_Mono/"
					},
					new DependencyUrl
					{
						SourceName = "NexusMods",
						Url = "https://www.nexusmods.com/schedule1/mods/1396"
					},
					new DependencyUrl
					{
						SourceName = "Github",
						Url = "https://github.com/ifBars/SteamNetworkLib/releases"
					}
				}
			});
			dependenciesChecker.ProcessAndAlert();
		}
	}
	internal class SettingsRegistry
	{
		internal MelonPreferences_Category EmployeeCapacityCategory;

		internal NetworkedMelonEntry<bool> EnableCapacityAndDebug;

		internal MelonPreferences_Entry<bool> DrawDebugArea;

		internal HashSet<NetworkedMelonEntry<int>> EmployeeCapacities = new HashSet<NetworkedMelonEntry<int>>();

		internal MelonPreferences_Category EmployeeAssignsCategory;

		internal NetworkedMelonEntry<bool> EnableAssigns;

		internal NetworkedMelonEntry<int> BotanistMaxPots;

		internal NetworkedMelonEntry<int> HandlerMaxStations;

		internal NetworkedMelonEntry<int> HandlerMaxRoutes;

		internal NetworkedMelonEntry<int> ChemistMaxStations;

		internal NetworkedMelonEntry<int> CleanerMaxBins;

		internal object? _boxedClient = null;

		internal object? _boxedOptions = null;

		public bool InitializeNetwork(object? client)
		{
			if (client == null)
			{
				return false;
			}
			_boxedClient = client;
			Assembly assembly = AppDomain.CurrentDomain.GetAssemblies().FirstOrDefault((Assembly a) => a.GetName().Name == "SteamNetworkLib");
			if (assembly == null)
			{
				return false;
			}
			Type type = assembly.GetType("SteamNetworkLib.Sync.NetworkSyncOptions");
			if (type == null)
			{
				return false;
			}
			_boxedOptions = Activator.CreateInstance(type);
			if (_boxedOptions == null)
			{
				return false;
			}
			PropertyInfo property = type.GetProperty("KeyPrefix");
			if (property == null)
			{
				return false;
			}
			property.SetValue(_boxedOptions, Assembly.GetExecutingAssembly().GetName().Name + "_");
			return true;
		}

		public void InitializeCategories()
		{
			InitializeCapacityCategory();
			InitializeAssignsCategory();
		}

		private void InitializeCapacityCategory()
		{
			EmployeeCapacityCategory = MelonPreferences.CreateCategory("EmployeeTweaksEmployeeCapacity", "Employee Capacities");
			EnableCapacityAndDebug = EmployeeCapacityCategory.GetOrCreateNetworkedEntry("EmployeeTweaksEnableCapacityAndDebug", defaultValue: true, _boxedClient, _boxedOptions, announce: true, "Enable Category", "Enables employee capacity tweaks and drawing employee idle points area");
			DrawDebugArea = EmployeeCapacityCategory.CreateEntry<bool>("EmployeeTweaksDrawDebugArea", false, "Draw Debug Area", "Draws a debug area where employee idle points are contained", false, false, (ValueValidator)null, (string)null);
		}

		private void InitializeAssignsCategory()
		{
			EmployeeAssignsCategory = MelonPreferences.CreateCategory("EmployeeTweaksEmployeeAssignsCategory", "Employee Assigns Capacities");
			EnableAssigns = EmployeeAssignsCategory.GetOrCreateNetworkedEntry("EmployeeTweaksEnableAssigns", defaultValue: true, _boxedClient, _boxedOptions, announce: true, "Enable Category", "Enables employee assigns capacity modifications");
			BotanistMaxPots = EmployeeAssignsCategory.GetOrCreateNetworkedEntry("EmployeeTweaksBotanistMaxPots", 8, _boxedClient, _boxedOptions, announce: true, "Botanist Max Pots", $"Maximum number of pots a botanist can be assigned to (allowed values from {SettingsConstants.BotanistBoundsMaxPots.Item1} to {SettingsConstants.BotanistBoundsMaxPots.Item2}). Changes require a restart.", isHidden: false, dontSaveDefault: false, (ValueValidator?)(object)new ValueRange<int>(SettingsConstants.BotanistBoundsMaxPots.Item1, SettingsConstants.BotanistBoundsMaxPots.Item2));
			HandlerMaxStations = EmployeeAssignsCategory.GetOrCreateNetworkedEntry("EmployeeTweaksHandlerMaxStations", 3, _boxedClient, _boxedOptions, announce: true, "Handler Max Stations", $"Maximum number of stations a packager can be assigned to (allowed values from {SettingsConstants.HandlerBoundsMaxStations.Item1} to {SettingsConstants.HandlerBoundsMaxStations.Item2}). Changes require a restart.", isHidden: false, dontSaveDefault: false, (ValueValidator?)(object)new ValueRange<int>(SettingsConstants.HandlerBoundsMaxStations.Item1, SettingsConstants.HandlerBoundsMaxStations.Item2));
			HandlerMaxRoutes = EmployeeAssignsCategory.GetOrCreateNetworkedEntry("EmployeeTweaksHandlerMaxRoutes", 5, _boxedClient, _boxedOptions, announce: true, "Handler Max Routes", $"Maximum number of routes a packager can be assigned to (allowed values from {SettingsConstants.HandlerBoundsMaxRoutes.Item1} to {SettingsConstants.HandlerBoundsMaxRoutes.Item2}). Changes require a restart.", isHidden: false, dontSaveDefault: false, (ValueValidator?)(object)new ValueRange<int>(SettingsConstants.HandlerBoundsMaxRoutes.Item1, SettingsConstants.HandlerBoundsMaxRoutes.Item2));
			ChemistMaxStations = EmployeeAssignsCategory.GetOrCreateNetworkedEntry("EmployeeTweaksChemistMaxStations", 4, _boxedClient, _boxedOptions, announce: true, "Chemist Max Stations", $"Maximum number of stations a chemist can be assigned to (allowed values from {SettingsConstants.ChemistBoundsMaxStations.Item1} to {SettingsConstants.ChemistBoundsMaxStations.Item2}). Changes require a restart.", isHidden: false, dontSaveDefault: false, (ValueValidator?)(object)new ValueRange<int>(SettingsConstants.ChemistBoundsMaxStations.Item1, SettingsConstants.ChemistBoundsMaxStations.Item2));
			CleanerMaxBins = EmployeeAssignsCategory.GetOrCreateNetworkedEntry("EmployeeTweaksCleanerMaxBins", 6, _boxedClient, _boxedOptions, announce: true, "Cleaner Max Trash Cans", $"Maximum number of trash cans a cleaner can be assigned to (allowed values from {SettingsConstants.CleanerBoundsMaxBins.Item1} to {SettingsConstants.CleanerBoundsMaxBins.Item2}). Changes require a restart.", isHidden: false, dontSaveDefault: false, (ValueValidator?)(object)new ValueRange<int>(SettingsConstants.CleanerBoundsMaxBins.Item1, SettingsConstants.CleanerBoundsMaxBins.Item2));
		}
	}
	internal static class SettingsConstants
	{
		public const int BotanistDefaultMaxPots = 8;

		public static (int, int) BotanistBoundsMaxPots = (1, 32);

		public const int HandlerDefaultMaxStations = 3;

		public static (int, int) HandlerBoundsMaxStations = (1, 8);

		public const int HandlerDefaultMaxRoutes = 5;

		public static (int, int) HandlerBoundsMaxRoutes = (1, 16);

		public const int ChemistDefaultMaxStations = 4;

		public static (int, int) ChemistBoundsMaxStations = (1, 32);

		public const int CleanerDefaultMaxBins = 6;

		public static (int, int) CleanerBoundsMaxBins = (1, 32);
	}
}
namespace EmployeeTweaks.Persistence
{
	public class UnpackageSave : Saveable
	{
		[SaveableField("UnpackageStations")]
		public Dictionary<Guid, bool> UnpackageStations = new Dictionary<Guid, bool>();

		private static UnpackageSave _instance;

		public static UnpackageSave Instance => _instance ?? (_instance = new UnpackageSave());

		public UnpackageSave()
		{
			_instance = this;
		}

		protected override void OnLoaded()
		{
			INetworkManager? networkManager = Melon<EmployeeTweaks>.Instance.NetworkManager;
			if (networkManager == null || networkManager.IsSingleplayer)
			{
				return;
			}
			foreach (KeyValuePair<Guid, bool> unpackageStation in UnpackageStations)
			{
				Melon<EmployeeTweaks>.Instance.NetworkManager?.BroadcastStation(unpackageStation.Key.ToString(), unpackageStation.Value);
			}
		}

		public bool TryGetValue(Guid guid, out bool value)
		{
			return UnpackageStations.TryGetValue(guid, out value);
		}
	}
}
namespace EmployeeTweaks.Patches.Unpackaging
{
	[HarmonyPatch(typeof(AdvancedTransitRoute))]
	internal static class AdvancedTransitRoutePatch
	{
		[HarmonyPatch("GetItemReadyToMove")]
		[HarmonyPrefix]
		private static bool GetItemReadyToMove(AdvancedTransitRoute __instance, ref ItemInstance __result)
		{
			if (((TransitRoute)__instance).Source == null || ((TransitRoute)__instance).Destination == null)
			{
				return true;
			}
			if (((TransitRoute)__instance).Destination == null)
			{
				return true;
			}
			ITransitEntity destination = ((TransitRoute)__instance).Destination;
			PackagingStation result;
			bool flag = Utils.Is2<PackagingStation>(destination, out result) && (Object)(object)result != (Object)null;
			ITransitEntity source = ((TransitRoute)__instance).Source;
			PackagingStation result2;
			bool flag2 = Utils.Is2<PackagingStation>(source, out result2) && (Object)(object)result2 != (Object)null;
			if (!flag && !flag2)
			{
				return true;
			}
			PackagingStation val = (flag ? result : result2);
			UnpackageSave.Instance.TryGetValue(((BuildableItem)val).GUID, out var value);
			if (!value)
			{
				return true;
			}
			if (flag)
			{
				foreach (ItemSlot outputSlot in ((TransitRoute)__instance).Source.OutputSlots)
				{
					if (outputSlot.ItemInstance != null && __instance.Filter.DoesItemMeetFilter(outputSlot.ItemInstance))
					{
						int outputCapacityForItem = destination.GetOutputCapacityForItem(outputSlot.ItemInstance, (NPC)null);
						if (outputCapacityForItem > 0)
						{
							__result = outputSlot.ItemInstance.GetCopy(Mathf.Min(outputCapacityForItem, ((BaseItemInstance)outputSlot.ItemInstance).Quantity));
							return false;
						}
					}
				}
			}
			else
			{
				foreach (ItemSlot inputSlot in ((TransitRoute)__instance).Source.InputSlots)
				{
					if (inputSlot.ItemInstance != null && __instance.Filter.DoesItemMeetFilter(inputSlot.ItemInstance))
					{
						int inputCapacityForItem = destination.GetInputCapacityForItem(inputSlot.ItemInstance, (NPC)null, true);
						if (inputCapacityForItem > 0)
						{
							__result = inputSlot.ItemInstance.GetCopy(Mathf.Min(inputCapacityForItem, ((BaseItemInstance)inputSlot.ItemInstance).Quantity));
							return false;
						}
					}
				}
			}
			__result = null;
			return false;
		}
	}
	[HarmonyPatch(typeof(MoveItemBehaviour))]
	internal static class MoveItemBehaviourPatches
	{
		private static Dictionary<MoveItemBehaviour, object> customGrabRunning = new Dictionary<MoveItemBehaviour, object>();

		private static Dictionary<MoveItemBehaviour, object> customPlaceRunning = new Dictionary<MoveItemBehaviour, object>();

		internal static void ManualPatchDestinationValid(Harmony harmony)
		{
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Expected O, but got Unknown
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Expected O, but got Unknown
			MethodInfo methodInfo = AccessTools.Method(typeof(MoveItemBehaviour), "IsDestinationValid", new Type[3]
			{
				typeof(TransitRoute),
				typeof(ItemInstance),
				typeof(string).MakeByRefType()
			}, (Type[])null);
			if (methodInfo == null)
			{
				MelonLogger.Error("Failed to find IsDestinationValid method!");
				return;
			}
			harmony.Patch((MethodBase)methodInfo, new HarmonyMethod(typeof(MoveItemBehaviourPatches), "IsDestinationValid", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			MethodInfo methodInfo2 = AccessTools.Method(typeof(MoveItemBehaviour), "IsTransitRouteValid", new Type[3]
			{
				typeof(TransitRoute),
				typeof(string),
				typeof(string).MakeByRefType()
			}, (Type[])null);
			if (methodInfo2 == null)
			{
				MelonLogger.Error("Failed to find IsTransitRouteValid method!");
			}
			else
			{
				harmony.Patch((MethodBase)methodInfo2, new HarmonyMethod(typeof(MoveItemBehaviourPatches), "IsTransitRouteValidID", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			}
		}

		private static bool IsDestinationValid(MoveItemBehaviour __instance, TransitRoute route, ItemInstance item, ref string invalidReason, ref bool __result)
		{
			invalidReason = string.Empty;
			if (((route != null) ? route.Destination : null) == null)
			{
				__result = false;
				return true;
			}
			ITransitEntity destination = route.Destination;
			PackagingStation result;
			bool flag = Utils.Is2<PackagingStation>(destination, out result) && (Object)(object)result != (Object)null;
			ITransitEntity source = route.Source;
			PackagingStation result2;
			bool flag2 = Utils.Is2<PackagingStation>(source, out result2) && (Object)(object)result2 != (Object)null;
			if (!flag && !flag2)
			{
				__result = false;
				return true;
			}
			PackagingStation val = (flag ? result : result2);
			UnpackageSave.Instance.TryGetValue(((BuildableItem)val).GUID, out var value);
			if (!value)
			{
				__result = false;
				return true;
			}
			if (!__instance.CanGetToDestination(route))
			{
				invalidReason = "Cannot get to destination!";
				__result = false;
				return false;
			}
			if (!__instance.CanGetToSource(route))
			{
				invalidReason = "Cannot get to source!";
				__result = false;
				return false;
			}
			if ((flag ? destination.GetOutputCapacityForItem(item, ((Behaviour)__instance).Npc) : destination.GetInputCapacityForItem(item, ((Behaviour)__instance).Npc, true)) == 0)
			{
				invalidReason = "Destination has no capacity for item!";
				__result = false;
				return false;
			}
			__result = true;
			return false;
		}

		private static bool IsTransitRouteValidID(MoveItemBehaviour __instance, TransitRoute route, string itemID, ref string invalidReason, ref bool __result)
		{
			invalidReason = string.Empty;
			if (((route != null) ? route.Destination : null) == null || route.Source == null)
			{
				__result = false;
				return true;
			}
			ITransitEntity destination = route.Destination;
			PackagingStation result;
			bool flag = Utils.Is2<PackagingStation>(destination, out result) && (Object)(object)result != (Object)null;
			ITransitEntity source = route.Source;
			PackagingStation result2;
			bool flag2 = Utils.Is2<PackagingStation>(source, out result2) && (Object)(object)result2 != (Object)null;
			if (!flag && !flag2)
			{
				return true;
			}
			PackagingStation val = (flag ? result : result2);
			UnpackageSave.Instance.TryGetValue(((BuildableItem)val).GUID, out var value);
			if (!value)
			{
				__result = false;
				return true;
			}
			if (!route.AreEntitiesNonNull())
			{
				invalidReason = "Entities are null!";
				__result = false;
				return false;
			}
			ItemSlot firstSlotContainingItem = source.GetFirstSlotContainingItem(itemID, (ESlotType)(!flag2));
			ItemInstance val2 = ((firstSlotContainingItem != null) ? firstSlotContainingItem.ItemInstance : null);
			if (val2 == null || ((BaseItemInstance)val2).Quantity <= 0)
			{
				invalidReason = "Item is null or quantity is 0!";
				__result = false;
				return false;
			}
			if (!__instance.IsDestinationValid(route, val2, ref invalidReason))
			{
				__result = false;
				return false;
			}
			__result = true;
			return false;
		}

		[HarmonyPatch("IsNpcInventoryItemValid")]
		[HarmonyPrefix]
		private static bool CheckNpcInventoryItemValid(MoveItemBehaviour __instance, ItemInstance item, ref bool __result)
		{
			TransitRoute assignedRoute = __instance.assignedRoute;
			if (((assignedRoute != null) ? assignedRoute.Destination : null) == null)
			{
				return true;
			}
			ITransitEntity destination = __instance.assignedRoute.Destination;
			PackagingStation result;
			bool flag = Utils.Is2<PackagingStation>(destination, out result) && (Object)(object)result != (Object)null;
			ITransitEntity source = __instance.assignedRoute.Source;
			PackagingStation result2;
			bool flag2 = Utils.Is2<PackagingStation>(source, out result2) && (Object)(object)result2 != (Object)null;
			if (!flag && !flag2)
			{
				return true;
			}
			PackagingStation val = (flag ? result : result2);
			UnpackageSave.Instance.TryGetValue(((BuildableItem)val).GUID, out var value);
			if (!value)
			{
				return true;
			}
			if (flag)
			{
				if (destination.GetOutputCapacityForItem(item, ((Behaviour)__instance).Npc) == 0)
				{
					__result = false;
					return false;
				}
			}
			else if (destination.GetInputCapacityForItem(item, ((Behaviour)__instance).Npc, true) == 0)
			{
				__result = false;
				return false;
			}
			__result = true;
			return false;
		}

		[HarmonyPatch("GetAmountToGrab")]
		[HarmonyPrefix]
		private static bool GetAmountToGrab(MoveItemBehaviour __instance, ref int __result)
		{
			TransitRoute assignedRoute = __instance.assignedRoute;
			if (((assignedRoute != null) ? assignedRoute.Destination : null) == null)
			{
				return true;
			}
			ITransitEntity destination = __instance.assignedRoute.Destination;
			PackagingStation result;
			bool flag = Utils.Is2<PackagingStation>(destination, out result) && (Object)(object)result != (Object)null;
			ITransitEntity source = __instance.assignedRoute.Source;
			PackagingStation result2;
			bool flag2 = Utils.Is2<PackagingStation>(source, out result2) && (Object)(object)result2 != (Object)null;
			if (!flag && !flag2)
			{
				return true;
			}
			PackagingStation val = (flag ? result : result2);
			UnpackageSave.Instance.TryGetValue(((BuildableItem)val).GUID, out var value);
			if (!value)
			{
				return true;
			}
			ItemSlot firstSlotContainingTemplateItem = __instance.assignedRoute.Source.GetFirstSlotContainingTemplateItem(__instance.itemToRetrieveTemplate, (ESlotType)(flag ? 1 : 0));
			ItemInstance val2 = ((firstSlotContainingTemplateItem != null) ? firstSlotContainingTemplateItem.ItemInstance : null);
			if (val2 == null)
			{
				__result = 0;
				return false;
			}
			int num = ((BaseItemInstance)val2).Quantity;
			if (__instance.maxMoveAmount > 0)
			{
				num = Mathf.Min(__instance.maxMoveAmount, num);
			}
			int num2 = (flag ? destination.GetOutputCapacityForItem(val2, ((Behaviour)__instance).Npc) : destination.GetInputCapacityForItem(val2, ((Behaviour)__instance).Npc, true));
			__result = Mathf.Min(num, num2);
			return false;
		}

		[HarmonyPatch("GrabItem")]
		[HarmonyPrefix]
		private static bool GrabItem(MoveItemBehaviour __instance)
		{
			//IL_0102: Unknown result type (might be due to invalid IL or missing references)
			TransitRoute assignedRoute = __instance.assignedRoute;
			if (((assignedRoute != null) ? assignedRoute.Source : null) == null)
			{
				return true;
			}
			ITransitEntity destination = __instance.assignedRoute.Destination;
			PackagingStation result;
			bool flag = Utils.Is2<PackagingStation>(destination, out result) && (Object)(object)result != (Object)null;
			ITransitEntity source = __instance.assignedRoute.Source;
			PackagingStation result2;
			bool flag2 = Utils.Is2<PackagingStation>(source, out result2) && (Object)(object)result2 != (Object)null;
			if (!flag && !flag2)
			{
				return true;
			}
			PackagingStation val = (flag ? result : result2);
			UnpackageSave.Instance.TryGetValue(((BuildableItem)val).GUID, out var value);
			if (!value)
			{
				return true;
			}
			if (flag)
			{
				return true;
			}
			if (((Behaviour)__instance).beh.DEBUG_MODE)
			{
				Console.Log((object)"MoveItemBehaviour.GrabItem", (Object)null);
			}
			__instance.currentState = (EState)2;
			__instance.grabRoutine = null;
			object value2 = MelonCoroutines.Start(Routine());
			customGrabRunning[__instance] = value2;
			return false;
			IEnumerator Routine()
			{
				Transform sourceAccessPoint = __instance.GetSourceAccessPoint(__instance.assignedRoute);
				if ((Object)(object)sourceAccessPoint == (Object)null)
				{
					Console.LogWarning((object)"Could not find source access point!", (Object)null);
					__instance.grabRoutine = null;
					((Behaviour)__instance).Disable_Networked((NetworkConnection)null);
					object coro = customGrabRunning[__instance];
					customGrabRunning.Remove(__instance);
					MelonCoroutines.Stop(coro);
				}
				else
				{
					((Behaviour)__instance).Npc.Movement.FaceDirection(sourceAccessPoint.forward, 0.5f);
					((Behaviour)__instance).Npc.SetAnimationTrigger_Networked((NetworkConnection)null, "GrabItem");
					if (Utils.Is<Employee>(((Behaviour)__instance).Npc, out Employee employee) && !((Object)(object)employee == (Object)null))
					{
						float seconds = 0.5f / employee.CurrentWorkSpeed;
						yield return (object)new WaitForSeconds(seconds);
						ItemInstance itemToRetrieveTemplate = __instance.itemToRetrieveTemplate;
						if (((itemToRetrieveTemplate != null) ? ((BaseItemInstance)itemToRetrieveTemplate).ID : null) != null)
						{
							string invalidReason = default(string);
							if (!__instance.IsTransitRouteValid(__instance.assignedRoute, ((BaseItemInstance)__instance.itemToRetrieveTemplate).ID, ref invalidReason))
							{
								Console.LogWarning((object)(((Behaviour)__instance).Npc.fullName + " transit route no longer valid! Reason: " + invalidReason), (Object)null);
								__instance.grabRoutine = null;
								((Behaviour)__instance).Disable_Networked((NetworkConnection)null);
								object coro2 = customGrabRunning[__instance];
								customGrabRunning.Remove(__instance);
								MelonCoroutines.Stop(coro2);
							}
							else
							{
								__instance.TakeItem();
								yield return (object)new WaitForSeconds(0.5f);
								__instance.grabRoutine = null;
								__instance.currentState = (EState)0;
								object coro3 = customGrabRunning[__instance];
								customGrabRunning.Remove(__instance);
								MelonCoroutines.Stop(coro3);
							}
						}
					}
				}
			}
		}

		[HarmonyPatch("TakeItem")]
		[HarmonyPrefix]
		private static bool TakeItem(MoveItemBehaviour __instance)
		{
			TransitRoute assignedRoute = __instance.assignedRoute;
			if (((assignedRoute != null) ? assignedRoute.Destination : null) == null)
			{
				return true;
			}
			ITransitEntity destination = __instance.assignedRoute.Destination;
			PackagingStation result;
			bool flag = Utils.Is2<PackagingStation>(destination, out result) && (Object)(object)result != (Object)null;
			ITransitEntity source = __instance.assignedRoute.Source;
			PackagingStation result2;
			bool flag2 = Utils.Is2<PackagingStation>(source, out result2) && (Object)(object)result2 != (Object)null;
			if (!flag && !flag2)
			{
				return true;
			}
			PackagingStation val = (flag ? result : result2);
			UnpackageSave.Instance.TryGetValue(((BuildableItem)val).GUID, out var value);
			if (!value)
			{
				return true;
			}
			if (((Behaviour)__instance).beh.DEBUG_MODE)
			{
				Console.Log((object)"MoveItemBehaviour.TakeItem", (Object)null);
			}
			int amountToGrab = __instance.GetAmountToGrab();
			if (amountToGrab == 0)
			{
				Console.LogWarning((object)"Amount to grab is 0!", (Object)null);
				return false;
			}
			ItemSlot firstSlotContainingTemplateItem = __instance.assignedRoute.Source.GetFirstSlotContainingTemplateItem(__instance.itemToRetrieveTemplate, (ESlotType)(flag ? 1 : 0));
			if (((firstSlotContainingTemplateItem != null) ? firstSlotContainingTemplateItem.ItemInstance : null) == null)
			{
				return false;
			}
			ItemInstance copy = firstSlotContainingTemplateItem.ItemInstance.GetCopy(amountToGrab);
			__instance.grabbedAmount = amountToGrab;
			firstSlotContainingTemplateItem.ChangeQuantity(-amountToGrab, false);
			((Behaviour)__instance).Npc.Inventory.InsertItem(copy, true);
			if (flag)
			{
				destination.ReserveOutputSlotsForItem(copy, ((NetworkBehaviour)((Behaviour)__instance).Npc).NetworkObject);
			}
			else
			{
				destination.ReserveInputSlotsForItem(copy, ((NetworkBehaviour)((Behaviour)__instance).Npc).NetworkObject);
			}
			return false;
		}

		[HarmonyPatch("PlaceItem")]
		[HarmonyPrefix]
		private static bool PlaceItem(MoveItemBehaviour __instance)
		{
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			TransitRoute assignedRoute = __instance.assignedRoute;
			if (((assignedRoute != null) ? assignedRoute.Destination : null) == null)
			{
				return true;
			}
			ITransitEntity dest = __instance.assignedRoute.Destination;
			PackagingStation result;
			bool destIsStation = Utils.Is2<PackagingStation>(dest, out result) && (Object)(object)result != (Object)null;
			ITransitEntity source = __instance.assignedRoute.Source;
			PackagingStation result2;
			bool flag = Utils.Is2<PackagingStation>(source, out result2) && (Object)(object)result2 != (Object)null;
			if (!destIsStation && !flag)
			{
				return true;
			}
			PackagingStation val = (destIsStation ? result : result2);
			UnpackageSave.Instance.TryGetValue(((BuildableItem)val).GUID, out var value);
			if (!value)
			{
				return true;
			}
			if (((Behaviour)__instance).beh.DEBUG_MODE)
			{
				Console.Log((object)"MoveItemBehaviour.PlaceItem", (Object)null);
			}
			__instance.currentState = (EState)4;
			__instance.placingRoutine = null;
			object value2 = MelonCoroutines.Start(Routine());
			customPlaceRunning[__instance] = value2;
			return false;
			IEnumerator Routine()
			{
				if ((Object)(object)__instance.GetDestinationAccessPoint(__instance.assignedRoute) != (Object)null)
				{
					((Behaviour)__instance).Npc.Movement.FaceDirection(__instance.GetDestinationAccessPoint(__instance.assignedRoute).forward, 0.5f);
				}
				((Behaviour)__instance).Npc.SetAnimationTrigger_Networked((NetworkConnection)null, "GrabItem");
				if (!Utils.Is<Employee>(((Behaviour)__instance).Npc, out Employee employee) || (Object)(object)employee == (Object)null)
				{
					customPlaceRunning.Remove(__instance);
				}
				else
				{
					float seconds = 0.5f / employee.CurrentWorkSpeed;
					yield return (object)new WaitForSeconds(seconds);
					if (destIsStation)
					{
						dest.RemoveOutputSlotLocks(((NetworkBehaviour)((Behaviour)__instance).Npc).NetworkObject);
					}
					else
					{
						dest.RemoveSlotLocks(((NetworkBehaviour)((Behaviour)__instance).Npc).NetworkObject);
					}
					ItemInstance firstIdenticalItem = ((Behaviour)__instance).Npc.Inventory.GetFirstIdenticalItem(__instance.itemToRetrieveTemplate, (ItemFilter)null);
					if (firstIdenticalItem != null && __instance.grabbedAmount > 0)
					{
						ItemInstance copy = firstIdenticalItem.GetCopy(__instance.grabbedAmount);
						if (destIsStation)
						{
							if (dest.GetOutputCapacityForItem(copy, ((Behaviour)__instance).Npc) >= __instance.grabbedAmount)
							{
								dest.InsertItemIntoOutput(copy, ((Behaviour)__instance).Npc);
							}
							else
							{
								Console.LogWarning((object)"Destination does not have enough capacity for item! Attempting to return item to source.", (Object)null);
								if (__instance.assignedRoute.Source.GetOutputCapacityForItem(copy, ((Behaviour)__instance).Npc) >= __instance.grabbedAmount)
								{
									__instance.assignedRoute.Source.InsertItemIntoOutput(copy, ((Behaviour)__instance).Npc);
								}
								else
								{
									Console.LogError((object)"Source does not have enough capacity for item! Item will be lost.", (Object)null);
								}
							}
						}
						else if (dest.GetInputCapacityForItem(copy, ((Behaviour)__instance).Npc, true) >= __instance.grabbedAmount)
						{
							dest.InsertItemIntoInput(copy, ((Behaviour)__instance).Npc);
						}
						else
						{
							Console.LogWarning((object)"Destination does not have enough capacity for item! Attempting to return item to source.", (Object)null);
							if (__instance.assignedRoute.Source.GetOutputCapacityForItem(copy, ((Behaviour)__instance).Npc) >= __instance.grabbedAmount)
							{
								__instance.assignedRoute.Source.InsertItemIntoOutput(copy, ((Behaviour)__instance).Npc);
							}
							else
							{
								Console.LogError((object)"Source does not have enough capacity for item! Item will be lost.", (Object)null);
							}
						}
						((BaseItemInstance)firstIdenticalItem).ChangeQuantity(-__instance.grabbedAmount);
					}
					else
					{
						Console.LogWarning((object)"Could not find carried item to place!", (Object)null);
					}
					yield return (object)new WaitForSeconds(0.5f);
					__instance.placingRoutine = null;
					__instance.currentState = (EState)0;
					((Behaviour)__instance).Disable_Networked((NetworkConnection)null);
					object coro = customPlaceRunning[__instance];
					customPlaceRunning.Remove(__instance);
					MelonCoroutines.Stop(coro);
				}
			}
		}

		[HarmonyPatch("StopCurrentActivity")]
		[HarmonyPrefix]
		private static bool StopCurrentActivity(MoveItemBehaviour __instance)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Invalid comparison between Unknown and I4
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Invalid comparison between Unknown and I4
			EState currentState = __instance.currentState;
			EState val = currentState;
			if ((int)val != 2)
			{
				if ((int)val == 4)
				{
					if (customPlaceRunning.TryGetValue(__instance, out object value))
					{
						MelonCoroutines.Stop(value);
						customPlaceRunning.Remove(__instance);
						return false;
					}
					return true;
				}
				return true;
			}
			if (customGrabRunning.TryGetValue(__instance, out object value2))
			{
				MelonCoroutines.Stop(value2);
				customGrabRunning.Remove(__instance);
				return false;
			}
			return true;
		}

		[HarmonyPatch("OnActiveTick")]
		[HarmonyPrefix]
		private static bool OnActiveTick(MoveItemBehaviour __instance)
		{
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Invalid comparison between Unknown and I4
			if (!InstanceFinder.IsServer)
			{
				return false;
			}
			if (!__instance.assignedRoute.AreEntitiesNonNull())
			{
				Console.LogWarning((object)"Transit route entities are null!", (Object)null);
				((Behaviour)__instance).Disable_Networked((NetworkConnection)null);
				return false;
			}
			if (((Behaviour)__instance).beh.DEBUG_MODE)
			{
				Console.Log((object)("State: " + ((object)Unsafe.As<EState, EState>(ref __instance.currentState)/*cast due to .constrained prefix*/).ToString()), (Object)null);
				Console.Log((object)("Moving: " + ((Behaviour)__instance).Npc.Movement.IsMoving), (Object)null);
			}
			if ((int)__instance.currentState > 0)
			{
				return false;
			}
			if (((Behaviour)__instance).Npc.Inventory.GetIdenticalItemAmount(__instance.itemToRetrieveTemplate) > 0 && __instance.grabbedAmount > 0)
			{
				if (__instance.IsAtDestination())
				{
					__instance.PlaceItem();
				}
				else
				{
					__instance.WalkToDestination();
				}
			}
			else if (__instance.skipPickup)
			{
				__instance.TakeItem();
				__instance.skipPickup = false;
			}
			else if (__instance.IsAtSource())
			{
				__instance.GrabItem();
			}
			else
			{
				__instance.WalkToSource();
			}
			return false;
		}

		[HarmonyPatch("StartTransit")]
		[HarmonyPrefix]
		private static bool StartTransit(MoveItemBehaviour __instance)
		{
			//IL_0197: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a1: Expected O, but got Unknown
			//IL_0217: Unknown result type (might be due to invalid IL or missing references)
			ITransitEntity destination = __instance.assignedRoute.Destination;
			PackagingStation result;
			bool flag = Utils.Is2<PackagingStation>(destination, out result) && (Object)(object)result != (Object)null;
			ITransitEntity source = __instance.assignedRoute.Source;
			PackagingStation result2;
			bool flag2 = Utils.Is2<PackagingStation>(source, out result2) && (Object)(object)result2 != (Object)null;
			if (!flag && !flag2)
			{
				return true;
			}
			object[] obj = new object[4]
			{
				__instance.assignedRoute.Source.Name,
				__instance.assignedRoute.Destination.Name,
				null,
				null
			};
			ItemInstance itemToRetrieveTemplate = __instance.itemToRetrieveTemplate;
			obj[2] = ((itemToRetrieveTemplate != null) ? ((BaseItemInstance)itemToRetrieveTemplate).ID : null);
			ItemInstance itemToRetrieveTemplate2 = __instance.itemToRetrieveTemplate;
			obj[3] = ((itemToRetrieveTemplate2 != null) ? new int?(((BaseItemInstance)itemToRetrieveTemplate2).Quantity) : ((int?)null));
			Console.Log((object)string.Format("{0} ->  {1} ({2}x{3})", obj), (Object)null);
			if (!InstanceFinder.IsServer)
			{
				return false;
			}
			if (((Behaviour)__instance).Npc.Inventory.GetIdenticalItemAmount(__instance.itemToRetrieveTemplate) == 0)
			{
				ItemInstance itemToRetrieveTemplate3 = __instance.itemToRetrieveTemplate;
				if (((itemToRetrieveTemplate3 != null) ? ((BaseItemInstance)itemToRetrieveTemplate3).ID : null) == null)
				{
					return false;
				}
				string text = default(string);
				if (!__instance.IsTransitRouteValid(__instance.assignedRoute, ((BaseItemInstance)__instance.itemToRetrieveTemplate).ID, ref text))
				{
					Console.LogWarning((object)("Invalid transit route for move item behaviour by checking transit route!. Reason: " + text), (Object)null);
					((Behaviour)__instance).Disable_Networked((NetworkConnection)null);
					return false;
				}
			}
			else
			{
				ItemInstance firstIdenticalItem = ((Behaviour)__instance).Npc.Inventory.GetFirstIdenticalItem(__instance.itemToRetrieveTemplate, new ItemFilter(__instance.IsNpcInventoryItemValid));
				if (((Behaviour)__instance).Npc.Behaviour.DEBUG_MODE)
				{
					Console.Log((object)("Moving item: " + (object)firstIdenticalItem), (Object)null);
				}
				string text2 = default(string);
				if (!__instance.IsDestinationValid(__instance.assignedRoute, firstIdenticalItem, ref text2))
				{
					Console.LogWarning((object)("Invalid transit route for move item behaviour by checking destination! Reason: " + text2), (Object)null);
					((Behaviour)__instance).Disable_Networked((NetworkConnection)null);
					return false;
				}
			}
			__instance.currentState = (EState)0;
			return false;
		}
	}
	[HarmonyPatch(typeof(Packager))]
	internal static class PackagerPatches
	{
		[HarmonyWrapSafe]
		[HarmonyPatch("GetStationMoveItems")]
		[HarmonyPrefix]
		private static bool GetStationMoveItems(Packager __instance, ref PackagingStation __result)
		{
			PackagingStation result = default(PackagingStation);
			bool value = default(bool);
			foreach (PackagingStation assignedStation in __instance.configuration.AssignedStations)
			{
				if ((Object)(object)assignedStation != (Object)null && Utils.Is<PackagingStation>(assignedStation, out result) && (Object)(object)result != (Object)null && UnpackageSave.Instance.TryGetValue(((BuildableItem)result).GUID, out value) && value)
				{
					List<ItemSlot> inputSlots = result.InputSlots;
					if (Utils.Is<PackagingStationConfiguration>(assignedStation.Configuration, out PackagingStationConfiguration config) && config != null)
					{
						bool flag = (from x in inputSlots.AsEnumerable()
							where x != null
							select x.ItemInstance into x
							where ((x != null) ? ((BaseItemInstance)x).ID : null) != null
							select x).Any((ItemInstance x) => ((Employee)__instance).MoveItemBehaviour.IsTransitRouteValid(config.DestinationRoute, ((BaseItemInstance)x).ID));
						if (inputSlots.AsEnumerable().Sum((ItemSlot x) => x.Quantity) != 0 && flag)
						{
							__result = assignedStation;
							return false;
						}
					}
				}
				else
				{
					ItemSlot outputSlot = assignedStation.OutputSlot;
					if (Utils.Is<PackagingStationConfiguration>(assignedStation.Configuration, out PackagingStationConfiguration result2) && result2 != null && outputSlot.Quantity != 0 && ((Employee)__instance).MoveItemBehaviour.IsTransitRouteValid(result2.DestinationRoute, ((BaseItemInstance)outputSlot.ItemInstance).ID))
					{
						__result = assignedStation;
						return false;
					}
				}
			}
			__result = null;
			return false;
		}

		[HarmonyPatch("StartMoveItem", new Type[] { typeof(PackagingStation) })]
		[HarmonyPrefix]
		private static bool StartMoveItem(Packager __instance, PackagingStation station)
		{
			UnpackageSave.Instance.TryGetValue(((BuildableItem)station).GUID, out var value);
			if (!value)
			{
				return true;
			}
			if (!Utils.Is<PackagingStationConfiguration>(station.Configuration, out PackagingStationConfiguration config) || config == null)
			{
				return true;
			}
			ItemSlot val = station.InputSlots.AsEnumerable().FirstOrDefault((Func<ItemSlot, bool>)delegate(ItemSlot x)
			{
				if (x.ItemInstance == null)
				{
					return false;
				}
				string text = default(string);
				bool flag = ((Employee)__instance).MoveItemBehaviour.IsTransitRouteValid(config.DestinationRoute, ((BaseItemInstance)x.ItemInstance).ID, ref text);
				if (!flag)
				{
					Console.Log((object)("[Unpacked] Rejected item " + ((BaseItemInstance)x.ItemInstance).ID + ": " + text), (Object)null);
				}
				return flag;
			});
			if (val == null)
			{
				return true;
			}
			Console.Log((object)("[Unpacked] Starting moving items from " + ((Object)((Component)station).gameObject).name), (Object)null);
			((Employee)__instance).MoveItemBehaviour.InitializeMoveItemBehaviourWithID(config.DestinationRoute, val.ItemInstance);
			((Behaviour)((Employee)__instance).MoveItemBehaviour).Enable_Networked();
			return false;
		}

		private static void InitializeMoveItemBehaviourWithID(this MoveItemBehaviour moveItemBehaviour, TransitRoute route, ItemInstance _itemToRetrieveTemplate, int _maxMoveAmount = -1, bool _skipPickup = false)
		{
			if (((_itemToRetrieveTemplate != null) ? ((BaseItemInstance)_itemToRetrieveTemplate).ID : null) == null)
			{
				return;
			}
			string text = default(string);
			if (!moveItemBehaviour.IsTransitRouteValid(route, ((BaseItemInstance)_itemToRetrieveTemplate).ID, ref text))
			{
				Console.LogError((object)("Invalid transit route for move item behaviour! Reason: " + text), (Object)(object)((Component)moveItemBehaviour).gameObject);
				return;
			}
			moveItemBehaviour.assignedRoute = route;
			moveItemBehaviour.itemToRetrieveTemplate = _itemToRetrieveTemplate;
			moveItemBehaviour.maxMoveAmount = _maxMoveAmount;
			if (((Behaviour)moveItemBehaviour).Npc.Behaviour.DEBUG_MODE)
			{
				Console.Log((object)("MoveItemBehaviour initialized with route: " + route.Source.Name + " -> " + route.Destination.Name + " for item: " + ((BaseItemInstance)_itemToRetrieveTemplate).ID), (Object)null);
			}
			moveItemBehaviour.skipPickup = _skipPickup;
		}

		[HarmonyReversePatch(/*Could not decode attribute arguments.*/)]
		[HarmonyPatch(typeof(Employee), "UpdateBehaviour")]
		private static void UpdateEmployeeBehaviour(Employee __instance)
		{
			throw new NotImplementedException();
		}

		[HarmonyPatch("UpdateBehaviour")]
		[HarmonyPrefix]
		private static bool UpdateBehaviour(Packager __instance)
		{
			UpdateEmployeeBehaviour((Employee)(object)__instance);
			if (((Behaviour)__instance.PackagingBehaviour).Active)
			{
				((Employee)__instance).MarkIsWorking();
			}
			else if (((Behaviour)((Employee)__instance).MoveItemBehaviour).Active)
			{
				((Employee)__instance).MarkIsWorking();
			}
			else
			{
				if (!InstanceFinder.IsServer)
				{
					return false;
				}
				if (((Employee)__instance).Fired)
				{
					((Employee)__instance).LeavePropertyAndDespawn();
				}
				else
				{
					if (!((Employee)__instance).CanWork())
					{
						return false;
					}
					if (__instance.configuration.AssignedStationCount + __instance.configuration.Routes.Routes.Count == 0)
					{
						((Employee)__instance).SubmitNoWorkReason("I haven't been assigned to any stations or routes.", "You can use your management clipboards to assign stations or routes to me.", 0);
						((Employee)__instance).SetIdle(true);
					}
					else
					{
						if (!InstanceFinder.IsServer)
						{
							return false;
						}
						PackagingStation stationToAttend = __instance.GetStationToAttend();
						if ((Object)(object)stationToAttend != (Object)null)
						{
							__instance.StartPackaging(stationToAttend);
							return false;
						}
						BrickPress brickPress = __instance.GetBrickPress();
						if ((Object)(object)brickPress != (Object)null)
						{
							__instance.StartPress(brickPress);
							return false;
						}
						PackagingStation stationMoveItems = __instance.GetStationMoveItems();
						if ((Object)(object)stationMoveItems != (Object)null)
						{
							__instance.StartMoveItem(stationMoveItems);
							return false;
						}
						BrickPress brickPressMoveItems = __instance.GetBrickPressMoveItems();
						if ((Object)(object)brickPressMoveItems != (Object)null)
						{
							__instance.StartMoveItem(brickPressMoveItems);
							return false;
						}
						ItemInstance val = default(ItemInstance);
						AdvancedTransitRoute transitRouteReady = __instance.GetTransitRouteReady(ref val);
						if (transitRouteReady != null)
						{
							((Employee)__instance).MoveItemBehaviour.Initialize((TransitRoute)(object)transitRouteReady, val, ((BaseItemInstance)val).Quantity, false);
							((Behaviour)((Employee)__instance).MoveItemBehaviour).Enable_Networked();
						}
						else
						{
							((Employee)__instance).SubmitNoWorkReason("There's nothing for me to do right now.", "I need one of my assigned stations to have enough product and packaging to get to work.", 0);
							((Employee)__instance).SetIdle(true);
						}
					}
				}
			}
			return false;
		}
	}
	public static class PackagingStationConfigPatches
	{
		public static Dictionary<Guid, StringField> UnpackageFields = new Dictionary<Guid, StringField>();

		public static void InitializeField(PackagingStationConfiguration config, PackagingStation station)
		{
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Expected O, but got Unknown
			Guid key = Guid.Parse(((BuildableItem)station).GUID.ToString());
			if (!UnpackageFields.ContainsKey(key))
			{
				StringField value = new StringField((EntityConfiguration)(object)config, "false");
				UnpackageFields[key] = value;
			}
			else
			{
				((EntityConfiguration)config).Fields.Add((ConfigField)(object)UnpackageFields[key]);
			}
		}
	}
	[HarmonyPatch(typeof(PackagingStationConfiguration))]
	public class PackagingStationConfigurationPatch
	{
		[HarmonyPostfix]
		[HarmonyPatch(/*Could not decode attribute arguments.*/)]
		public static void ConstructorPostfix(PackagingStationConfiguration __instance, PackagingStation station)
		{
			if (__instance != null && !((Object)(object)station == (Object)null))
			{
				PackagingStationConfigPatches.InitializeField(__instance, station);
			}
		}
	}
	[HarmonyPatch(typeof(PackagingStationConfigPanel))]
	public class PackagingStationConfigPanelPatch
	{
		[HarmonyPostfix]
		[HarmonyPatch("BindInternal")]
		public static void BindInternalPostfix(PackagingStationConfigPanel __instance, List<EntityConfiguration> configs)
		{
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0104: Expected O, but got Unknown
			//IL_019d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_01da: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e1: Expected O, but got Unknown
			//IL_020b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0222: Unknown result type (might be due to invalid IL or missing references)
			//IL_0239: Unknown result type (might be due to invalid IL or missing references)
			//IL_0250: Unknown result type (might be due to invalid IL or missing references)
			//IL_0267: Unknown result type (might be due to invalid IL or missing references)
			//IL_028e: Unknown result type (might be due to invalid IL or missing references)
			//IL_02aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d0: Expected O, but got Unknown
			//IL_02fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0311: Unknown result type (might be due to invalid IL or missing references)
			//IL_0328: Unknown result type (might be due to invalid IL or missing references)
			//IL_0335: Unknown result type (might be due to invalid IL or missing references)
			//IL_034c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0382: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_03dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e4: Expected O, but got Unknown
			//IL_040e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0425: Unknown result type (might be due to invalid IL or missing references)
			//IL_043c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0453: Unknown result type (might be due to invalid IL or missing references)
			//IL_046a: Unknown result type (might be due to invalid IL or missing references)
			//IL_04f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_04f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_05dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_05ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_05f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_05fe: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)__instance == (Object)null || (Object)(object)__instance.DestinationUI == (Object)null)
			{
				return;
			}
			try
			{
				PackagingStationConfiguration val = null;
				foreach (EntityConfiguration config in configs)
				{
					if (!Utils.Is<PackagingStationConfiguration>(config, out PackagingStationConfiguration result) || result == null)
					{
						continue;
					}
					val = result;
					break;
				}
				if ((Object)(object)((val != null) ? val.Station : null) == (Object)null)
				{
					return;
				}
				Guid stationGuid = Guid.Parse(((BuildableItem)val.Station).GUID.ToString());
				if (!PackagingStationConfigPatches.UnpackageFields.TryGetValue(stationGuid, out StringField _))
				{
					PackagingStationConfigPatches.InitializeField(val, val.Station);
				}
				Transform parent = ((Component)__instance.DestinationUI).transform.parent;
				GameObject val2 = new GameObject("UnpackageToggle");
				val2.transform.SetParent(parent, false);
				RectTransform val3 = val2.AddComponent<RectTransform>();
				RectTransform component = ((Component)__instance.DestinationUI).GetComponent<RectTransform>();
				TextMeshProUGUI fieldLabel = __instance.DestinationUI.FieldLabel;
				Transform val4 = ((component != null) ? ((Transform)component).Find("Selection") : null);
				Image val5 = ((val4 != null) ? ((Component)val4).GetComponent<Image>() : null);
				if ((Object)(object)component == (Object)null || (Object)(object)val5 == (Object)null || (Object)(object)fieldLabel == (Object)null)
				{
					MelonLogger.Error("Failed to find necessary UI components for unpackage toggle");
					return;
				}
				val3.sizeDelta = new Vector2(400f, 50f);
				val2.transform.localPosition = ((Transform)component).localPosition + new Vector3(0f, -120f, 0f);
				GameObject val6 = new GameObject("Title");
				val6.transform.SetParent(val2.transform, false);
				RectTransform val7 = val6.AddComponent<RectTransform>();
				val7.anchorMin = new Vector2(0f, 0.5f);
				val7.anchorMax = new Vector2(0f, 0.5f);
				val7.pivot = new Vector2(0f, 0.5f);
				val7.anchoredPosition = new Vector2(0f, 0f);
				val7.sizeDelta = new Vector2(200f, 30f);
				TextMeshProUGUI val8 = val6.AddComponent<TextMeshProUGUI>();
				((TMP_Text)val8).fontSize = ((TMP_Text)fieldLabel).fontSize;
				((TMP_Text)val8).alignment = ((TMP_Text)fieldLabel).alignment;
				((TMP_Text)val8).text = "Set Unpackage";
				((Graphic)val8).color = ((Graphic)fieldLabel).color;
				((TMP_Text)val8).font = ((TMP_Text)fieldLabel).font;
				GameObject val9 = new GameObject("Value");
				RectTransform val10 = val9.AddComponent<RectTransform>();
				val9.transform.SetParent(val2.transform, false);
				val10.anchorMin = new Vector2(1f, 0.5f);
				val10.anchorMax = new Vector2(1f, 0.5f);
				val10.pivot = new Vector2(1f, 0.5f);
				val10.anchoredPosition = Vector2.zero;
				val10.sizeDelta = new Vector2(80f, 30f);
				Image val11 = val9.AddComponent<Image>();
				val11.sprite = val5.sprite;
				val11.overrideSprite = val5.overrideSprite;
				val11.type = val5.type;
				((Graphic)val11).material = ((Graphic)val5).material;
				((Graphic)val11).color = ((Graphic)val5).color;
				((Graphic)val11).raycastTarget = ((Graphic)val5).raycastTarget;
				val11.preserveAspect = val5.preserveAspect;
				val11.pixelsPerUnitMultiplier = val5.pixelsPerUnitMultiplier;
				GameObject val12 = new GameObject("Text");
				val12.transform.SetParent(val9.transform, false);
				RectTransform val13 = val12.AddComponent<RectTransform>();
				val13.anchorMin = new Vector2(1f, 0.5f);
				val13.anchorMax = new Vector2(1f, 0.5f);
				val13.pivot = new Vector2(1f, 0.5f);
				val13.anchoredPosition = new Vector2(0f, 0f);
				val13.sizeDelta = new Vector2(80f, 30f);
				TextMeshProUGUI valueTmpro = val12.AddComponent<TextMeshProUGUI>();
				((TMP_Text)valueTmpro).fontSize = 24f;
				((TMP_Text)valueTmpro).alignment = (TextAlignmentOptions)514;
				((TMP_Text)valueTmpro).font = ((TMP_Text)fieldLabel).font;
				UnpackageSave.Instance.TryGetValue(stationGuid, out var value2);
				((TMP_Text)valueTmpro).text = (value2 ? "On" : "Off");
				((Graphic)valueTmpro).color = (value2 ? Color.green : Color.gray);
				Button val14 = val9.AddComponent<Button>();
				((UnityEventBase)val14.onClick).RemoveAllListeners();
				string s = "";
				EventHelper.AddListener((Action)delegate
				{
					//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
					//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
					s = s;
					Guid guid = stationGuid;
					MelonLogger.Msg("Toggled unpackaging setting for station " + guid);
					UnpackageSave instance = UnpackageSave.Instance;
					if (instance?.UnpackageStations != null)
					{
						if (!instance.UnpackageStations.TryAdd(stationGuid, value: true))
						{
							instance.UnpackageStations[stationGuid] = !instance.UnpackageStations[stationGuid];
						}
						bool flag = instance.UnpackageStations[stationGuid];
						Melon<EmployeeTweaks>.Instance.NetworkManager?.BroadcastStation(stationGuid.ToString(), flag);
						((TMP_Text)valueTmpro).text = (flag ? "On" : "Off");
						((Graphic)valueTmpro).color = (flag ? Color.green : Color.gray);
					}
				}, (UnityEvent)(object)val14.onClick);
				((Selectable)val14).image = val11;
				((Selectable)val14).targetGraphic = (Graphic)(object)val11;
				UIContentPanel component2 = ((Component)__instance).GetComponent<UIContentPanel>();
				if ((Object)(object)component2 != (Object)null)
				{
					UISelectable val15 = val9.GetComponent<UISelectable>();
					if ((Object)(object)val15 == (Object)null)
					{
						val15 = val9.AddComponent<UISelectable>();
					}
					((UIPanel)component2).AddSelectable(val15);
				}
				Transform val16 = ((Transform)component).Find("Description");
				if (!((Object)(object)val16 == (Object)null))
				{
					GameObject val17 = Object.Instantiate<GameObject>(((Component)val16).gameObject);
					RectTransform component3 = val17.GetComponent<RectTransform>();
					((Transform)component3).SetParent(val2.transform, false);
					((Transform)component3).localPosition = Vector3.zero;
					component3.anchoredPosition += new Vector2(0f, -50f);
					TextMeshProUGUI component4 = val17.GetComponent<TextMeshProUGUI>();
					((TMP_Text)component4).text = "^The assigned packager will use this station for unpackaging product only";
				}
			}
			catch (Exception arg)
			{
				MelonLogger.Error($"BindInternalPostfix failed: {arg}");
			}
		}
	}
	[HarmonyPatch(typeof(PackagingStation))]
	internal static class PackagingStationPatches
	{
		[HarmonyPatch("PackSingleInstance")]
		[HarmonyPrefix]
		private static bool UnpackIfConfigured(PackagingStation __instance)
		{
			if (__instance != null)
			{
				_ = ((BuildableItem)__instance).GUID;
				if (0 == 0)
				{
					UnpackageSave.Instance.TryGetValue(((BuildableItem)__instance).GUID, out var value);
					if (!value)
					{
						return true;
					}
					__instance.Unpack();
					return false;
				}
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(PackagingStationBehaviour))]
	internal static class PackagingStationBehaviourPatches
	{
		[HarmonyPatch("IsStationReady")]
		[HarmonyPrefix]
		private static bool IsStationReady(PackagingStationBehaviour __instance, PackagingStation station, ref bool __result)
		{
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: 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_00b1: Invalid comparison between Unknown and I4
			if ((Object)(object)station == (Object)null)
			{
				__result = false;
				return false;
			}
			NPC npc = ((Behaviour)__instance).Npc;
			Utils.Is2<IUsable>(station, out IUsable result);
			if (result != null && result.IsInUse && (Object)(object)station.NPCUserObject != (Object)(object)((NetworkBehaviour)npc).NetworkObject)
			{
				__result = false;
				return false;
			}
			if (!npc.Movement.CanGetTo(station.StandPoint.position, 1f))
			{
				__result = false;
				return false;
			}
			UnpackageSave.Instance.TryGetValue(((BuildableItem)station).GUID, out var value);
			EMode val = (EMode)(value ? 1 : 0);
			if ((int)station.GetState(val) > 0)
			{
				__result = false;
				return false;
			}
			__result = true;
			return false;
		}
	}
	public static class TransitEntityExtensions
	{
		public static List<ItemSlot> ReserveOutputSlotsForItem(this ITransitEntity entity, ItemInstance item, NetworkObject locker)
		{
			List<ItemSlot> list = new List<ItemSlot>();
			int num = ((BaseItemInstance)item).Quantity;
			for (int i = 0; i < entity.OutputSlots.Count; i++)
			{
				int capacityForItem = entity.OutputSlots[i].GetCapacityForItem(item, false);
				if (capacityForItem != 0)
				{
					int num2 = Mathf.Min(capacityForItem, num);
					num -= num2;
					entity.OutputSlots[i].ApplyLock(locker, "Employee is about to place an item here", false);
					list.Add(entity.OutputSlots[i]);
					if (num <= 0)
					{
						break;
					}
				}
			}
			return list;
		}

		public static void RemoveOutputSlotLocks(this ITransitEntity entity, NetworkObject locker)
		{
			for (int i = 0; i < entity.OutputSlots.Count; i++)
			{
				if (entity.OutputSlots[i].ActiveLock != null && (Object)(object)entity.OutputSlots[i].ActiveLock.LockOwner == (Object)(object)locker)
				{
					entity.OutputSlots[i].RemoveLock(false);
				}
			}
		}
	}
}
namespace EmployeeTweaks.Patches.QualityEmployeeWorkSpeed
{
	[HarmonyPatch]
	internal static class EffectPatches
	{
		private static Instance _logger = new Instance("EmployeeTweaks.QualityEmployeeWorkSpeed");

		[HarmonyPatch(typeof(ProductItemInstance), "ApplyEffectsToNPC")]
		[HarmonyPrefix]
		private static bool ApplyEffectsToEmployee(ProductItemInstance __instance, NPC npc)
		{
			//IL_0104: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)((__instance != null) ? ((ItemInstance)__instance).Definition : null) == (Object)null)
			{
				return true;
			}
			if ((Object)(object)npc == (Object)null)
			{
				return true;
			}
			if (!Utils.Is<Employee>(npc, out Employee result) || (Object)(object)result == (Object)null)
			{
				return true;
			}
			if (!Utils.Is<ProductDefinition>(((ItemInstance)__instance).Definition, out ProductDefinition result2) || (Object)(object)result2 == (Object)null)
			{
				return true;
			}
			List<Effect> list = new List<Effect>();
			list.AddRange(((PropertyItemDefinition)result2).Properties.AsEnumerable());
			list = list.OrderBy((Effect x) => x.Tier).ToList();
			StackEntry val = default(StackEntry);
			foreach (Effect item in list)
			{
				item.ApplyToEmployee(result);
				if (result.WorkSpeedController.TryGetEntry(item.Name, ref val))
				{
					float num = ApplyQuality(val.Value, GetQualityMult(((QualityItemInstance)__instance).Quality));
					_logger.Msg($"Applying quality transformation to {item.Name}: was {val.Value}, is {num}");
					val.Value = num;
					result.WorkSpeedController.Recalculate();
				}
			}
			return false;
		}

		private static float GetQualityMult(EQuality quality)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Expected I4, but got Unknown
			if (1 == 0)
			{
			}
			float result = (int)quality switch
			{
				0 => 0.4f, 
				1 => 0.7f, 
				2 => 1f, 
				3 => 1.2f, 
				4 => 1.5f, 
				_ => 1f, 
			};
			if (1 == 0)
			{
			}
			return result;
		}

		private static float ApplyQuality(float baseValue, float m)
		{
			float num = 1f + (m - 1f) * 1.2f;
			float num2 = baseValue * 0.9f;
			float num3 = baseValue * 1.2f;
			return Mathf.Lerp(num2, num3, Mathf.InverseLerp(0.4f, 1.5f, num));
		}
	}
}
namespace EmployeeTweaks.Patches.MoreEmployeeConfigItems
{
	[HarmonyPatch]
	internal static class BotanistMorePots
	{
		[HarmonyPatch(typeof(Botanist), "AssignProperty")]
		[HarmonyPrefix]
		private static void Awake(Botanist __instance)
		{
			if (Melon<EmployeeTweaks>.Instance.SettingsRegistry.EnableAssigns.Value)
			{
				__instance.MaxAssignedPots = Melon<EmployeeTweaks>.Instance.SettingsRegistry.BotanistMaxPots.Value;
			}
		}

		[HarmonyPatch(typeof(BotanistConfigPanel), "BindInternal")]
		[HarmonyPostfix]
		private static void AddScrollRect(BotanistConfigPanel __instance)
		{
			//IL_0114: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_0128: Unknown result type (might be due to invalid IL or missing references)
			if (!Melon<EmployeeTweaks>.Instance.SettingsRegistry.EnableAssigns.Value || Melon<EmployeeTweaks>.Instance.SettingsRegistry.BotanistMaxPots.Value <= Melon<EmployeeTweaks>.Instance.SettingsRegistry.BotanistMaxPots.DefaultValue)
			{
				return;
			}
			ObjectListFieldUI val = __instance?.PotsUI;
			object obj;
			if (val == null)
			{
				obj = null;
			}
			else
			{
				RectTransform? obj2 = val.Entries.AsEnumerable().FirstOrDefault();
				obj = ((obj2 != null) ? ((Component)((Transform)obj2).parent).gameObject : null);
			}
			GameObject val2 = (GameObject)obj;
			if ((Object)(object)val2 == (Object)null)
			{
				return;
			}
			RectTransform component = val2.GetComponent<RectTransform>();
			if (!((Object)(object)component == (Object)null))
			{
				ClipboardUIHelper.MoveToScrollableList(component, val2.transform.parent);
				Transform val3 = val2.transform.parent.Find("Hint");
				if (!((Object)(object)val3 == (Object)null) && Melon<EmployeeTweaks>.Instance.SettingsRegistry.BotanistMaxPots.Value > 9)
				{
					val3.localPosition += new Vector3(10f, 0f);
				}
			}
		}
	}
	[HarmonyPatch]
	internal class ChemistMoreStations
	{
		[HarmonyPatch(typeof(Chemist), "AssignProperty")]
		[HarmonyPostfix]
		private static void AddStations(Chemist __instance)
		{
			if (Melon<EmployeeTweaks>.Instance.SettingsRegistry.EnableAssigns.Value)
			{
				__instance.configuration.Stations.MaxItems = Melon<EmployeeTweaks>.Instance.SettingsRegistry.ChemistMaxStations.Value;
			}
		}

		[HarmonyPatch(typeof(ChemistConfigPanel), "BindInternal")]
		[HarmonyPostfix]
		private static void AddScrollStationRect(ChemistConfigPanel __instance)
		{
			//IL_0114: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_0128: Unknown result type (might be due to invalid IL or missing references)
			if (!Melon<EmployeeTweaks>.Instance.SettingsRegistry.EnableAssigns.Value || Melon<EmployeeTweaks>.Instance.SettingsRegistry.ChemistMaxStations.Value <= Melon<EmployeeTweaks>.Instance.SettingsRegistry.ChemistMaxStations.DefaultValue)
			{
				return;
			}
			ObjectListFieldUI val = __instance?.StationsUI;
			object obj;
			if (val == null)
			{
				obj = null;
			}
			else
			{
				RectTransform? obj2 = val.Entries.AsEnumerable().FirstOrDefault();
				obj = ((obj2 != null) ? ((Component)((Transform)obj2).parent).gameObject : null);
			}
			GameObject val2 = (GameObject)obj;
			if ((Object)(object)val2 == (Object)null)
			{
				return;
			}
			RectTransform component = val2.GetComponent<RectTransform>();
			if (!((Object)(object)component == (Object)null))
			{
				ClipboardUIHelper.MoveToScrollableList(component, val2.transform.parent);
				Transform val3 = val2.transform.parent.Find("Hint");
				if (!((Object)(object)val3 == (Object)null) && Melon<EmployeeTweaks>.Instance.SettingsRegistry.ChemistMaxStations.Value > 9)
				{
					val3.localPosition += new Vector3(10f, 0f);
				}
			}
		}
	}
	[HarmonyPatch]
	internal class CleanerMoreBins
	{
		[HarmonyPatch(typeof(Cleaner), "AssignProperty")]
		[HarmonyPostfix]
		private static void AddBins(Cleaner __instance)
		{
			if (Melon<EmployeeTweaks>.Instance.SettingsRegistry.EnableAssigns.Value)
			{
				__instance.configuration.Bins.MaxItems = Melon<EmployeeTweaks>.Instance.SettingsRegistry.CleanerMaxBins.Value;
			}
		}

		[HarmonyPatch(typeof(CleanerConfigPanel), "BindInternal")]
		[HarmonyPostfix]
		private static void AddScrollStationRect(CleanerConfigPanel __instance)
		{
			if (!Melon<EmployeeTweaks>.Instance.SettingsRegistry.EnableAssigns.Value || Melon<EmployeeTweaks>.Instance.SettingsRegistry.CleanerMaxBins.Value <= Melon<EmployeeTweaks>.Instance.SettingsRegistry.CleanerMaxBins.DefaultValue)
			{
				return;
			}
			ObjectListFieldUI val = __instance?.BinsUI;
			object obj;
			if (val == null)
			{
				obj = null;
			}
			else
			{
				RectTransform? obj2 = val.Entries.AsEnumerable().FirstOrDefault();
				obj = ((obj2 != null) ? ((Component)((Transform)obj2).parent).gameObject : null);
			}
			GameObject val2 = (GameObject)obj;
			if (!((Object)(object)val2 == (Object)null))
			{
				RectTransform component = val2.GetComponent<RectTransform>();
				if (!((Object)(object)component == (Object)null))
				{
					ClipboardUIHelper.MoveToScrollableList(component, val2.transform.parent);
				}
			}
		}
	}
	public static class ClipboardUIHelper
	{
		private static readonly Instance Logger = new Instance("EmployeeTweaks.MoreEmployeeConfigItems");

		public static ScrollRect MoveToScrollableList(RectTransform source, Transform parent)
		{
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Expected O, but got Unknown
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0208: Unknown result type (might be due to invalid IL or missing references)
			//IL_020d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0220: Unknown result type (might be due to invalid IL or missing references)
			//IL_022a: Unknown result type (might be due to invalid IL or missing references)
			//IL_023c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0246: Unknown result type (might be due to invalid IL or missing references)
			//IL_013b: Unknown result type (might be due to invalid IL or missing references)
			//IL_014a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0159: Unknown result type (might be due to invalid IL or missing references)
			//IL_0168: Unknown result type (might be due to invalid IL or missing references)
			//IL_0177: Unknown result type (might be due to invalid IL or missing references)
			//IL_0186: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)source == (Object)null)
			{
				Logger.Error("Source is null");
				return null;
			}
			VerticalLayoutGroup component = ((Component)source).GetComponent<VerticalLayoutGroup>();
			if ((Object)(object)component == (Object)null)
			{
				Logger.Error("Source does not have VerticalLayoutGroup");
				return null;
			}
			ScrollRect val2 = default(ScrollRect);
			RectTransform val = UIFactory.ScrollableVerticalList(((Object)source).name + "_Scroll", parent, ref val2);
			VerticalLayoutGroup component2 = ((Component)val).GetComponent<VerticalLayoutGroup>();
			((HorizontalOrVerticalLayoutGroup)component2).spacing = ((HorizontalOrVerticalLayoutGroup)component).spacing;
			((LayoutGroup)component2).padding = new RectOffset(((LayoutGroup)component).padding.left, ((LayoutGroup)component).padding.right, 8, ((LayoutGroup)component).padding.bottom);
			((LayoutGroup)component2).childAlignment = ((LayoutGroup)component).childAlignment;
			((HorizontalOrVerticalLayoutGroup)component2).childControlWidth = true;
			((HorizontalOrVerticalLayoutGroup)component2).childControlHeight = ((HorizontalOrVerticalLayoutGroup)component).childControlHeight;
			((HorizontalOrVerticalLayoutGroup)component2).childForceExpandWidth = true;
			((HorizontalOrVerticalLayoutGroup)component2).childForceExpandHeight = ((HorizontalOrVerticalLayoutGroup)component).childForceExpandHeight;
			((HorizontalOrVerticalLayoutGroup)component2).childScaleWidth = ((HorizontalOrVerticalLayoutGroup)component).childScaleWidth;
			((HorizontalOrVerticalLayoutGroup)component2).childScaleHeight = ((HorizontalOrVerticalLayoutGroup)component).childScaleHeight;
			while (((Transform)source).childCount > 0)
			{
				Transform child = ((Transform)source).GetChild(0);
				child.SetParent((Transform)(object)val, false);
				if (Utils.Is<RectTransform>(child, out RectTransform result) && !((Object)(object)result == (Object)null))
				{
					result.anchorMin = new Vector2(result.anchorMin.x, 1f);
					result.anchorMax = new Vector2(result.anchorMax.x, 1f);
					result.pivot = new Vector2(result.pivot.x, 1f);
				}
			}
			RectTransform component3 = ((Component)val2).gameObject.GetComponent<RectTransform>();
			component3.anchorMin = new Vector2(0f, 1f);
			component3.anchorMax = new Vector2(1f, 1f);
			component3.pivot = new Vector2(0.5f, 1f);
			component3.anchoredPosition = source.anchoredPosition + new Vector2(0f, 150f);
			component3.sizeDelta = new Vector2(0f, source.sizeDelta.y);
			val.sizeDelta = new Vector2(0f, val.sizeDelta.y);
			LayoutElement orAddComponent = ((Component)val).gameObject.GetOrAddComponent<LayoutElement>();
			orAddComponent.flexibleWidth = 1f;
			ContentSizeFitter orAddComponent2 = ((Component)val).gameObject.GetOrAddComponent<ContentSizeFitter>();
			orAddComponent2.horizontalFit = (FitMode)0;
			AddVerticalScrollbar(val2, 8f, 8f, (ScrollbarVisibility)1);
			Object.Destroy((Object)(object)((Component)source).gameObject);
			LayoutRebuilder.ForceRebuildLayoutImmediate(val);
			return val2;
		}

		public static Scrollbar AddVerticalScrollbar(ScrollRect scrollRect, float width = 12f, float spacing = -2f, ScrollbarVisibility visibility = (ScrollbarVisibility)1)
		{
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Expected O, but got Unknown
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_0102: Unknown result type (might be due to invalid IL or missing references)
			//IL_011a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0121: Expected O, but got Unknown
			//IL_0152: Unknown result type (might be due to invalid IL or missing references)
			//IL_0169: Unknown result type (might be due to invalid IL or missing references)
			//IL_0180: Unknown result type (might be due to invalid IL or missing references)
			//IL_018d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_020a: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)scrollRect == (Object)null)
			{
				Logger.Error("AddVerticalScrollbar: scrollRect is null");
				return null;
			}
			RectTransform component = ((Component)scrollRect).GetComponent<RectTransform>();
			if ((Object)(object)scrollRect.verticalScrollbar != (Object)null)
			{
				GameObject gameObject = ((Component)scrollRect.verticalScrollbar).gameObject;
				scrollRect.verticalScrollbar = null;
				Object.Destroy((Object)(object)gameObject);
			}
			GameObject val = new GameObject("Scrollbar");
			val.GetOrAddComponent<RectTransform>();
			val.transform.SetParent((Transform)(object)component, false);
			RectTransform component2 = val.GetComponent<RectTransform>();
			component2.anchorMin = new Vector2(1f, 0f);
			component2.anchorMax = new Vector2(1f, 1f);
			component2.pivot = new Vector2(1f, 1f);
			component2.sizeDelta = new Vector2(width, 0f);
			component2.anchoredPosition = Vector2.zero;
			Image val2 = val.AddComponent<Image>();
			((Graphic)val2).color = new Color(63f / 85f, 63f / 85f, 0.7490196f, 0.25f);
			((Graphic)val2).raycastTarget = true;
			GameObject val3 = new GameObject("Handle");
			val3.GetOrAddComponent<RectTransform>();
			val3.transform.SetParent(val.transform, false);
			RectTransform component3 = val3.GetComponent<RectTransform>();
			component3.anchorMin = new Vector2(0f, 0f);
			component3.anchorMax = new Vector2(1f, 1f);
			component3.pivot = new Vector2(0.5f, 0.5f);
			component3.sizeDelta = Vector2.zero;
			Image val4 = val3.AddComponent<Image>();
			((Graphic)val4).color = new Color(0.6745098f, 0.6745098f, 0.6784314f, 0.65f);
			((Graphic)val4).raycastTarget = true;
			Scrollbar val5 = val.AddComponent<Scrollbar>();
			val5.direction = (Direction)2;
			val5.handleRect = component3;
			((Selectable)val5).targetGraphic = (Graphic)(object)val4;
			scrollRect.vertical = true;
			scrollRect.horizontal = false;
			scrollRect.verticalScrollbar = val5;
			scrollRect.verticalScrollbarVisibility = visibility;
			scrollRect.verticalScrollbarSpacing = spacing;
			RectTransform content = scrollRect.content;
			if ((Object)(object)content != (Object)null)
			{
				LayoutRebuilder.ForceRebuildLayoutImmediate(content);
			}
			Canvas.ForceUpdateCanvases();
			return val5;
		}
	}
	[HarmonyPatch]
	internal static class HandlerPatches
	{
		[HarmonyPatch(typeof(Packager), "AssignProperty")]
		[HarmonyPostfix]
		private static void AddRoutes(Packager __instance)
		{
			if (Melon<EmployeeTweaks>.Instance.SettingsRegistry.EnableAssigns.Value)
			{
				__instance.configuration.Routes.MaxRoutes = Melon<EmployeeTweaks>.Instance.SettingsRegistry.HandlerMaxRoutes.Value;
				__instance.MaxAssignedStations = Melon<EmployeeTweaks>.Instance.SettingsRegistry.HandlerMaxStations.Value;
				__instance.configuration.Stations.MaxItems = Melon<EmployeeTweaks>.Instance.SettingsRegistry.HandlerMaxStations.Value;
			}
		}

		[HarmonyPatch(typeof(PackagerConfigPanel), "BindInternal")]
		[HarmonyPostfix]
		private static void AddScrollStationRect(PackagerConfigPanel __instance)
		{
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: Unknown result type (might be due to invalid IL or missing references)
			if (!Melon<EmployeeTweaks>.Instance.SettingsRegistry.EnableAssigns.Value || Melon<EmployeeTweaks>.Instance.SettingsRegistry.HandlerMaxStations.Value <= Melon<EmployeeTweaks>.Instance.SettingsRegistry.HandlerMaxStations.DefaultValue)
			{
				return;
			}
			ObjectListFieldUI val = __instance?.StationsUI;
			object obj;
			if (val == null)
			{
				obj = null;
			}
			else
			{
				RectTransform? obj2 = val.Entries.AsEnumerable().FirstOrDefault();
				obj = ((obj2 != null) ? ((Component)((Transform)obj2).parent).gameObject : null);
			}
			GameObject val2 = (GameObject)obj;
			if ((Object)(object)val2 == (Object)null)
			{
				return;
			}
			RectTransform component = val2.GetComponent<RectTransform>();
			if (!((Object)(object)component == (Object)null))
			{
				ScrollRect val3 = ClipboardUIHelper.MoveToScrollableList(component, val2.transform.parent);
				RectTransform component2 = ((Component)val3).gameObject.GetComponent<RectTransform>();
				if (!((Object)(object)component2 == (Object)null))
				{
					component2.sizeDelta = new Vector2(0f, 165f);
					component2.offsetMin = new Vector2(0f, -165f);
					Canvas.ForceUpdateCanvases();
					LayoutRebuilder.ForceRebuildLayoutImmediate(val3.content);
				}
			}
		}

		[HarmonyPatch(typeof(PackagerConfigPanel), "BindInternal")]
		[HarmonyPostfix]
		private static void AddScrollRouteRect(PackagerConfigPanel __instance)
		{
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0109: Unknown result type (might be due to invalid IL or missing references)
			if (!Melon<EmployeeTweaks>.Instance.SettingsRegistry.EnableAssigns.Value || Melon<EmployeeTweaks>.Instance.SettingsRegistry.HandlerMaxRoutes.Value <= Melon<EmployeeTweaks>.Instance.SettingsRegistry.HandlerMaxRoutes.DefaultValue)
			{
				return;
			}
			RouteListFieldUI routesUI = __instance.RoutesUI;
			object obj;
			if (routesUI == null)
			{
				obj = null;
			}
			else
			{
				RouteEntryUI? obj2 = routesUI.RouteEntries.AsEnumerable().FirstOrDefault();
				obj = ((obj2 != null) ? ((Component)((Component)obj2).transform.parent).gameObject : null);
			}
			GameObject val = (GameObject)obj;
			if ((Object)(object)val == (Object)null)
			{
				return;
			}
			RectTransform component = val.GetComponent<RectTransform>();
			if (!((Object)(object)component == (Object)null))
			{
				ScrollRect val2 = ClipboardUIHelper.MoveToScrollableList(component, val.transform.parent);
				RectTransform component2 = ((Component)val2).gameObject.GetComponent<RectTransform>();
				if (!((Object)(object)component2 == (Object)null))
				{
					component2.anchoredPosition = new Vector2(0f, -55f);
					component2.sizeDelta = new Vector2(0f, 165f);
					Canvas.ForceUpdateCanvases();
					LayoutRebuilder.ForceRebuildLayoutImmediate(val2.content);
				}
			}
		}
	}
	[HarmonyPatch]
	public class SharedClipboardPatches
	{
		[HarmonyPatch(typeof(ObjectListFieldUI), "Bind")]
		[HarmonyPrefix]
		private static void AddMissing(ObjectListFieldUI __instance, List<ObjectListField> field)
		{
			if (!Melon<EmployeeTweaks>.Instance.SettingsRegistry.EnableAssigns.Value)
			{
				return;
			}
			int num = field.AsEnumerable().Max((ObjectListField olf) => olf.MaxItems);
			int num2 = __instance.Entries.Length;
			if (num <= num2)
			{
				MelonDebug.Msg($"Not adding, current: {num2}, maxFieldsNeeded: {num}");
				return;
			}
			int num3 = num - num2;
			RectTransform val = __instance.Entries.AsEnumerable().FirstOrDefault();
			if ((Object)(object)val == (Object)null || num3 <= 0)
			{
				MelonDebug.Msg($"Not adding, template: {val} or todo {num3}");
				return;
			}
			List<RectTransform> list = new List<RectTransform>();
			RectTransform[] entries = __instance.Entries;
			foreach (RectTransform item in entries)
			{
				list.Add(item);
			}
			for (int num5 = 0; num5 < num3; num5++)
			{
				GameObject val2 = Object.Instantiate<GameObject>(((Component)val).gameObject);
				val2.transform.SetParent(((Component)val).transform.parent, false);
				val2.transform.SetAsLastSibling();
				list.Add(val2.GetComponent<RectTransform>());
			}
			__instance.Entries = list.ToArray();
			MelonDebug.Msg($"Ensured {__instance.Entries.Length} instances");
		}

		[HarmonyPatch(typeof(RouteListFieldUI), "Bind")]
		[HarmonyPrefix]
		private static void AddMissing(RouteListFieldUI __instance)
		{
			if (!Melon<EmployeeTweaks>.Instance.SettingsRegistry.EnableAssigns.Value)
			{
				return;
			}
			int item = SettingsConstants.HandlerBoundsMaxRoutes.Item2;
			int num = __instance.RouteEntries.Length;
			if (item <= num)
			{
				MelonDebug.Msg($"Not adding, current: {num}, maxFieldsNeeded: {item}");
				return;
			}
			int num2 = item - num;
			RouteEntryUI? obj = __instance.RouteEntries.AsEnumerable().FirstOrDefault();
			GameObject val = ((obj != null) ? ((Component)obj).gameObject : null);
			if ((Object)(object)val == (Object)null || num2 <= 0)
			{
				MelonDebug.Msg($"Not adding, template: {val} or todo {num2}");
				return;
			}
			List<RouteEntryUI> list = new List<RouteEntryUI>();
			RouteEntryUI[] routeEntries = __instance.RouteEntries;
			foreach (RouteEntryUI item2 in routeEntries)
			{
				list.Add(item2);
			}
			for (int j = 0; j < num2; j++)
			{
				GameObject val2 = Object.Instantiate<GameObject>(val.gameObject);
				val2.transform.SetParent(val.transform.parent, false);
				val2.transform.SetSiblingIndex(val.transform.parent.childCount - 2);
				val2.SetActive(false);
				RouteEntryUI component = val2.GetComponent<RouteEntryUI>();
				if (!((Object)(object)component == (Object)null))
				{
					list.Add(component);
				}
			}
			__instance.RouteEntries = list.ToArray();
		}
	}
}
namespace EmployeeTweaks.Patches.FilterItemApply
{
	[HarmonyPatch(typeof(FilterConfigPanel))]
	internal class FilterConfigPanelPatches
	{
		private static Instance _logger = new Instance("EmployeeTweaks.FilterItemApply");

		internal const string Filter1 = "Apply Item As Filter";

		internal const string Filter2 = "Apply All As Filters";

		internal static bool AllSlots;

		internal static bool DenyListMode;

		internal static TextMeshProUGUI ApplyItemAsFilterButtonText;

		private static Button _applyItemAsFilterButton;

		[HarmonyPatch("Awake")]
		[HarmonyPostfix]
		private static void AddButton(FilterConfigPanel __instance)
		{
			Button applyToSiblingsButton = __instance.ApplyToSiblingsButton;
			if ((Object)(object)applyToSiblingsButton == (Object)null)
			{
				return;
			}
			GameObject val = Object.Instantiate<GameObject>(((Component)applyToSiblingsButton).gameObject, ((Component)applyToSiblingsButton).transform.parent);
			_applyItemAsFilterButton = val.GetComponent<Button>();
			ApplyItemAsFilterButtonText = ((Component)_applyItemAsFilterButton).GetComponentInChildren<TextMeshProUGUI>();
			((TMP_Text)ApplyItemAsFilterButtonText).text = "Apply Item As Filter";
			((UnityEventBase)_applyItemAsFilterButton.onClick).RemoveAllListeners();
			string s = "";
			EventHelper.AddListener((Action)delegate
			{
				s = s;
				if (AllSlots)
				{
					ApplyItemsAsFilters(__instance.OpenSlot);
				}
				else
				{
					ApplyItemAsFilter(__instance.OpenSlot);
				}
			}, (UnityEvent)(object)_applyItemAsFilterButton.onClick);
		}

		private static void ApplyItemAsFilter(ItemSlot itemSlot)
		{
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			if (!AllSlots)
			{
				_logger.Msg("Applying item as filter");
			}
			ItemInstance itemInstance = itemSlot.ItemInstance;
			if (((itemInstance != null) ? ((BaseItemInstance)itemInstance).ID : null) == null)
			{
				_logger.Warning("No item in slot to apply as filter.");
				return;
			}
			SlotFilter playerFilter = itemSlot.PlayerFilter;
			if (playerFilter?.ItemIDs == null)
			{
				_logger.Warning("Player filter is null or does not have an ItemIDs list.");
				return;
			}
			playerFilter.ItemIDs.Clear();
			playerFilter.ItemIDs.Add(((BaseItemInstance)itemInstance).ID);
			playerFilter.Type = (EType)((!DenyListMode) ? 1 : 2);
			itemSlot.SetPlayerFilter(playerFilter, false);
		}

		private static void ApplyItemsAsFilters(ItemSlot itemSlot)
		{
			_logger.Msg("Applying all items in sibling slots as filters.");
			foreach (ItemSlot slot in itemSlot.SiblingSet.Slots)
			{
				ApplyItemAsFilter(slot);
			}
		}
	}
}
namespace EmployeeTweaks.Patches.EmployeeArea
{
	internal class DebugAreaDrawer
	{
		private Instance Logger = new Instance("EmployeeTweaks.DebugAreaDrawer");

		private List<GameObject> _areas = new List<GameObject>();

		internal void Draw()
		{
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_010d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0114: Unknown result type (might be due to invalid IL or missing references)
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			//IL_011a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0133: Unknown result type (might be due to invalid IL or missing references)
			foreach (GameObject area in _areas)
			{
				if ((Object)(object)area != (Object)null)
				{
					Object.DestroyImmediate((Object)(object)area);
				}
			}
			_areas.Clear();
			if (!Melon<EmployeeTweaks>.Instance.SettingsRegistry.EnableCapacityAndDebug.Value || !Melon<EmployeeTweaks>.Instance.SettingsRegistry.DrawDebugArea.Value)
			{
				return;
			}
			Vector3 val = default(Vector3);
			((Vector3)(ref val))..ctor(0f, 0.1f, 0f);
			foreach (var value in PropertyPatch._propertyIdlePointRects.Values)
			{
				Logger.Msg($"Drawing Employee Area at {value.Item1 + val}, {value.Item2 + val}");
				GameObject item = DrawDebugArea(value.Item1 + val, value.Item2 + val, new Color(1f, 0f, 0f, 0.2f));
				_areas.Add(item);
			}
		}

		private static GameObject DrawDebugArea(Vector3 a, Vector3 b, Color color)
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Expected O, but got Unknown
			//IL_0107: Unknown result type (might be due to invalid IL or missing references)
			//IL_0142: Unknown result type (might be due to invalid IL or missing references)
			//IL_0170: Unknown result type (might be due to invalid IL or missing references)
			//IL_0176: Unknown result type (might be due to invalid IL or missing references)
			//IL_017c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0182: Unknown result type (might be due to invalid IL or missing references)
			//IL_018c: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = GameObject.CreatePrimitive((PrimitiveType)5);
			((Object)val).name = "DebugArea";
			Object.Destroy((Object)(object)val.GetComponent<Collider>());
			Vector3 val2 = Vector3.Min(a, b);
			Vector3 val3 = Vector3.Max(a, b);
			Vector3 val4 = (val2 + val3) * 0.5f;
			Vector3 val5 = val3 - val2;
			val.transform.position = val4 + Vector3.up * 0.01f;
			val.transform.rotation = Quaternion.Euler(90f, 0f, 0f);
			val.transform.localScale = new Vector3(val5.x, val5.z, 1f);
			MeshRenderer component = val.GetComponent<MeshRenderer>();
			Shader val6 = Shader.Find("Universal Render Pipeline/Lit");
			if ((Object)(object)val6 == (Object)null)
			{
				return val;
			}
			Material val7 = new Material(val6);
			if (val7.HasProperty("_Surface"))
			{
				val7.SetFloat("_Surface", 1f);
			}
			if (color.a <= 0f)
			{
				color.a = 0.2f;
			}
			if (val7.HasProperty("_BaseColor"))
			{
				val7.SetColor("_BaseColor", color);
			}
			if (val7.HasProperty("_EmissionColor"))
			{
				val7.EnableKeyword("_EMISSION");
				val7.SetColor("_EmissionColor", new Color(color.r, color.g, color.b) * 1.5f);
			}
			val7.SetInt("_ZWrite", 0);
			val7.renderQueue = 3000;
			((Renderer)component).material = val7;
			return val;
		}

		internal static void WireDebugAreaDrawer(DebugAreaDrawer debugAreaDrawer)
		{
			Player.LocalPlayerSpawned += delegate
			{
				debugAreaDrawer.Draw();
			};
			((MelonEventBase<LemonAction<bool, bool>>)(object)Melon<EmployeeTweaks>.Instance.SettingsRegistry.DrawDebugArea.OnEntryValueChanged).Subscribe((LemonAction<bool, bool>)delegate
			{
				debugAreaDrawer.Draw();
			}, 0, false);
		}
	}
	[HarmonyPatch(typeof(Property))]
	internal class PropertyPatch
	{
		private static Instance Logger = new Instance("EmployeeTweaks.PropertyPatch");

		internal static Dictionary<Property, (Vector3, Vector3)> _propertyIdlePointRects = new Dictionary<Property, (Vector3, Vector3)>();

		[HarmonyPatch("NetworkInitialize___Early")]
		[HarmonyPriority(-100)]
		[HarmonyPrefix]
		private static void StorePointRectAndAddCapacity(Property __instance)
		{
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			if (!Melon<EmployeeTweaks>.Instance.SettingsRegistry.EnableCapacityAndDebug.Value)
			{
				return;
			}
			Transform[] employeeIdlePoints = __instance.EmployeeIdlePoints;
			if (employeeIdlePoints != null && employeeIdlePoints.Length > 0)
			{
				var (val, val2) = MinMaxPoints(employeeIdlePoints.AsEnumerable().ToList());
				if (val == val2)
				{
					val2 = val + new Vector3(0.5f, 0f, 0.5f);
				}
				_propertyIdlePointRects[__instance] = (val, val2);
			}
			if (__instance.EmployeeCapacity <= 0)
			{
				return;
			}
			NetworkedMelonEntry<int> entry = Melon<EmployeeTweaks>.Instance.SettingsRegistry.EmployeeCapacityCategory.GetOrCreateNetworkedEntry("EmployeeTweaks_" + __instance.propertyCode + "_EmpCap", __instance.EmployeeCapacity, Melon<EmployeeTweaks>.Instance.SettingsRegistry._boxedClient, Melon<EmployeeTweaks>.Instance.SettingsRegistry._boxedOptions, announce: true, __instance.propertyName + " Employee Capacity", "Max amount of employees you can hire for this property", isHidden: false, dontSaveDefault: false, (ValueValidator?)(object)new ValueRange<int>(1, Mathf.CeilToInt((float)__instance.EmployeeCapacity * 1.5f) + 1));
			Melon<EmployeeTweaks>.Instance.SettingsRegistry.EmployeeCapacities.Add(entry);
			((MelonEventBase<LemonAction<int, int>>)(object)entry.OnEntryValueChanged).Subscribe((LemonAction<int, int>)delegate(int oldVal, int newVal)
			{
				if (oldVal != newVal)
				{
					AddCapacity(__instance, newVal);
				}
			}, 0, false);
			AddCapacity(__instance, entry.Value);
			void AddCapacity(Property prop, int target)
			{
				//IL_0134: Unknown result type (might be due to invalid IL or missing references)
				//IL_013a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0253: Unknown result type (might be due to invalid IL or missing references)
				//IL_0258: Unknown result type (might be due to invalid IL or missing references)
				//IL_026b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0272: Expected O, but got Unknown
				//IL_0293: Unknown result type (might be due to invalid IL or missing references)
				//IL_02a9: Unknown result type (might be due to invalid IL or missing references)
				int num = prop.Employees?.AsEnumerable().Count() ?? 0;
				(Vector3, Vector3) value;
				if (target < num)
				{
					Logger.Warning($"Cannot set capacity of {prop.propertyName} to {target} because it currently has {num} employees");
					entry.Value = prop.EmployeeCapacity;
				}
				else if (!_propertyIdlePointRects.TryGetValue(prop, out value))
				{
					Logger.Warning("Could not find idle point rect for " + prop.propertyName + ", cannot add capacity");
					entry.Value = prop.EmployeeCapacity;
				}
				else
				{
					Transform[] employeeIdlePoints2 = prop.EmployeeIdlePoints;
					int num2 = ((employeeIdlePoints2 != null) ? employeeIdlePoints2.Length : 0);
					int num3 = target - num2;
					if (num3 <= 0)
					{
						if (num2 <= 0)
						{
							entry.Value = prop.EmployeeCapacity;
						}
						else
						{
							List<Transform> list = prop.EmployeeIdlePoints.AsEnumerable().ToList();
							list = list.GetRange(0, target);
							prop.EmployeeIdlePoints = list.ToArray();
							prop.EmployeeCapacity = list.Count;
						}
					}
					else
					{
						List<Vector3> list2 = PoissonDiskSampler2D.SampleAdaptive(value.Item1, value.Item2, (prop.EmployeeIdlePoints?.AsEnumerable() ?? Array.Empty<Transform>()).ToList(), num3, 1f, 0.01f, prop.propertyCode.GetHashCode());
						int count = list2.Count;
						Transform[] employeeIdlePoints3 = prop.EmployeeIdlePoints;
						if (count + ((employeeIdlePoints3 != null) ? employeeIdlePoints3.Length : 0) < target)
						{
							Logger.Warning($"Generated {list2.Count} new points for {prop.propertyName} but needed {num3}, cannot add capacity");
							entry.Value = prop.EmployeeCapacity;
						}
						else
						{
							List<Transform> list3 = new List<Transform>();
							Transform val3 = prop.EmployeeIdlePoints?.FirstOrDefault();
							if ((Object)(object)val3 == (Object)null)
							{
								Logger.Warning("Property " + prop.propertyName + " has no idle points, cannot add capacity");
								entry.Value = prop.EmployeeCapacity;
							}
							else
							{
								foreach (Vector3 item2 in list2)
								{
									GameObject val4 = new GameObject(prop.propertyName + "_EmployeeIdlePoint");
									val4.transform.SetParent(((Component)val3).transform.parent, false);
									val4.transform.position = item2;
									val4.transform.rotation = ((Component)val3).transform.rotation;
									list3.Add(val4.transform);
								}
								Transform[] employeeIdlePoints4 = prop.EmployeeIdlePoints;
								foreach (Transform item in employeeIdlePoints4)
								{
									list3.Add(item);
								}
								prop.EmployeeIdlePoints = list3.ToArray();
								prop.EmployeeCapacity = list3.Count;
							}
						}
					}
				}
			}
		}

		private static (Vector3 min, Vector3 max) MinMaxPoints(List<Transform> transforms)
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			if (transforms == null || transforms.Count == 0)
			{
				throw new ArgumentException("Empty list");
			}
			Vector3 position = transforms[0].position;
			Vector3 val = position;
			Vector3 val2 = position;
			for (int i = 1; i < transforms.Count; i++)
			{
				Vector3 position2 = transforms[i].position;
				val = Vector3.Min(val, position2);
				val2 = Vector3.Max(val2, position2);
			}
			return (min: val, max: val2);
		}
	}
	public static class PoissonDiskSampler2D
	{
		private static Random _rng;

		public static List<Vector3> SampleAdaptive(Vector3 min, Vector3 max, List<Transform> blocked, int targetCount, float preferredRadius, float minRadius, int seed, int maxIterations = 5, int k = 30)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			_rng = new Random(seed);
			float num = preferredRadius;
			List<Vector3> list = new List<Vector3>();
			for (int i = 0; i < maxIterations; i++)
			{
				List<Vector3> list2 = Sample(min, max, blocked, num, k);
				if (list2.Count >= targetCount)
				{
					return list2.GetRange(0, targetCount);
				}
				if (list2.Count > list.Count)
				{
					list = list2;
				}
				num *= 0.7f;
				if (num < minRadius)
				{
					break;
				}
			}
			if (list.Count < targetCount)
			{
				list.AddRange(Fill(min, max, blocked, list, targetCount - list.Count, minRadius));
			}
			return list;
		}

		private static List<Vector3> Sample(Vector3 min, Vector3 max, List<Transform> blocked, float radius, int k)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: 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_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			float num = radius / Mathf.Sqrt(2f);
			int num2 = Mathf.CeilToInt((max.x - min.x) / num);
			int num3 = Mathf.CeilToInt((max.z - min.z) / num);
			Vector3?[,] grid = new Vector3?[num2, num3];
			List<Vector3> list = new List<Vector3>();
			List<Vector3> list2 = new List<Vector3>();
			Vector3 val = RandomPoint(min, max);
			list.Add(val);
			list2.Add(val);
			Set(grid, min, num, val);
			while (list.Count > 0)
			{
				int index = _rng.Next(list.Count);
				Vector3 p = list[index];
				bool flag = false;
				for (int i = 0; i < k; i++)
				{
					Vector3 val2 = GenerateAround(p, radius);
					if (IsValid(val2, min, max, radius, grid, blocked, num))
					{
						list.Add(val2);
						list2.Add(val2);
						Set(grid, min, num, val2);
						flag = true;
						break;
					}
				}
				if (!flag)
				{
					list.RemoveAt(index);
				}
			}
			return list2;
		}

		private static List<Vector3> Fill(Vector3 min, Vector3 max, List<Transform> blocked, List<Vector3> current, int needed, float epsilon)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: 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)
			List<Vector3> list = new List<Vector3>();
			float epsSqr = epsilon * epsilon;
			int num = 0;
			int num2 = needed * 20;
			while (list.Count < needed && num++ < num2)
			{
				Vector3 val = RandomPoint(min, max);
				if (!TooClose(val, blocked, current, list, epsSqr))
				{
					list.Add(val);
				}
			}
			return list;
		}

		private static Vector3 RandomPoint(Vector3 min, Vector3 max)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: 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_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			return new Vector3(Lerp(min.x, max.x), min.y, Lerp(min.z, max.z));
		}

		private static Vector3 GenerateAround(Vector3 p, float radius)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			float num = (float)(_rng.NextDouble() * 3.1415927410125732 * 2.0);
			float num2 = Lerp(radius, radius * 2f);
			return new Vector3(p.x + Mathf.Cos(num) * num2, p.y, p.z + Mathf.Sin(num) * num2);
		}

		private static bool IsValid(Vector3 p, Vector3 min, Vector3 max, float radius, Vector3?[,] grid, List<Transform> blocked, float cellSize)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: 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_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			if (p.x < min.x || p.x > max.x || p.z < min.z || p.z > max.z)
			{
				return false;
			}
			float num = radius * radius;
			if (TooClose(p, blocked, null, null, num))
			{
				return false;
			}
			int num2 = (int)((p.x - min.x) / cellSize);
			int num3 = (int)((p.z - min.z) / cellSize);
			for (int i = -2; i <= 2; i++)
			{
				for (int j = -2; j <= 2; j++)
				{
					int num4 = num2 + i;
					int num5 = num3 + j;
					if (num4 >= 0 && num5 >= 0 && num4 < grid.GetLength(0) && num5 < grid.GetLength(1) && grid[num4, num5].HasValue)
					{
						Vector3 val = grid[num4, num5].Value - p;
						if (((Vector3)(ref val)).sqrMagnitude < num)
						{
							return false;
						}
					}
				}
			}
			return true;
		}

		private static void Set(Vector3?[,] grid, Vector3 min, float cellSize, Vector3 p)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			int num = (int)((p.x - min.x) / cellSize);
			int num2 = (int)((p.z - min.z) / cellSize);
			grid[num, num2] = p;
		}

		private static bool TooClose(Vector3 p, List<Transform> blocked, List<Vector3> a, List<Vector3> b, float epsSqr)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			Vector3 val;
			foreach (Transform item in blocked)
			{
				val = item.position - p;
				if (((Vector3)(ref val)).sqrMagnitude < epsSqr)
				{
					return true;
				}
			}
			if (a != null)
			{
				foreach (Vector3 item2 in a)
				{
					val = item2 - p;
					if (((Vector3)(ref val)).sqrMagnitude < epsSqr)
					{
						return true;
					}
				}
			}
			if (b != null)
			{
				foreach (Vector3 item3 in b)
				{
					val = item3 - p;
					if (((Vector3)(ref val)).sqrMagnitude < epsSqr)
					{
						return true;
					}
				}
			}
			return false;
		}

		private static float Lerp(float a, float b)
		{
			return a + (float)_rng.NextDouble() * (b - a);
		}
	}
}
namespace EmployeeTweaks.Patches.BotanistSprinklersPourer
{
	[HarmonyPatch(typeof(GrowContainerBehaviour))]
	internal class GrowContainerBehaviourPatch
	{
		[HarmonyPatch("OnActiveTick")]
		[HarmonyPostfix]
		private static void UseSprinklerOrPourer(GrowContainerBehaviour __instance)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Invalid comparison between Unknown and I4
			if (!InstanceFinder.IsServer || (int)__instance._currentState != 3 || !__instance.IsAtGrowContainer())
			{
				return;
			}
			if (Utils.Is<WaterPotBehaviour>(__instance, out WaterPotBehaviour result) && (Object)(object)result != (Object)null)
			{
				if (!Utils.Is<Pot>(((GrowContainerBehaviour)result)._growContainer, out Pot pot))
				{
					return;
				}
				HashSet<GridItem> itemsAroundItem = GetItemsAroundItem((GridItem)(object)pot);
				MelonDebug.Msg("Found " + itemsAroundItem.Count + " items around the pot");
				foreach (GridItem item in itemsAroundItem)
				{
					if (!Utils.Is<Sprinkler>(item, out Sprinkler result2) || (Object)(object)result2 == (Object)null)
					{
						continue;
					}
					List<Pot> pots = result2.GetPots();
					if ((Object)(object)pots.AsEnumerable().FirstOrDefault((Func<Pot, bool>)((Pot x) => (Object)(object)x != (Object)null && (Object)(object)x == (Object)(object)pot)) == (Object)null)
					{
						continue;
					}
					MelonDebug.Msg("It's an eligible sprinkler, activating it");
					if (!result2.IsSprinkling)
					{
						result2.Interacted();
					}
					((GrowContainerBehaviour)result).OnStopPerformAction();
					((GrowContainerBehaviour)result).OnActionSuccess((ItemInstance)null);
					((Behaviour)result).Disable_Networked((NetworkConnection)null);
					if (Utils.Is<Botanist>(((Behaviour)result).Npc, out Botanist result3) && result3 != null)
					{
						((Employee)result3).SetIdle(true);
					}
					break;
				}
			}
			if (!Utils.Is<AddSoilToGrowContainerBehaviour>(__instance, out AddSoilToGrowContainerBehaviour result4) || !((Object)(object)result4 != (Object)null))
			{
				return;
			}
			if (!Utils.Is<Pot>(((GrowContainerBehaviour)result4)._growContainer, out Pot pot2))
			{
				return;
			}
			HashSet<GridItem> itemsAroundItem2 = GetItemsAroundItem((GridItem)(object)pot2);
			MelonDebug.Msg("Found " + itemsAroundItem2.Count + " items around the pot");
			string[] array = default(string[]);
			foreach (GridItem item2 in itemsAroundItem2)
			{
				if (!Utils.Is<SoilPourer>(item2, out SoilPourer result5) || (Object)(object)result5 == (Object)null)
				{
					continue;
				}
				List<Pot> pots2 = result5.GetPots();
				if (!((Object)(object)pots2.AsEnumerable().FirstOrDefault((Func<Pot, bool>)((Pot x) => (Object)(object)x != (Object)null && (Object)(object)x == (Object)(object)pot2)) == (Object)null))
				{
					MelonDebug.Msg("It's a eligible soil pourer, activating it");
					if (!((GrowContainerBehaviour)result4).AreTaskConditionsMetForContainer((GrowContainer)(object)pot2))
					{
						MelonDebug.Msg("Conditions not met");
						((Behaviour)result4).Disable_Networked((NetworkConnection)null);
						break;
					}
					ItemSlot val = null;
					if (((GrowContainerBehaviour)result4).DoesTaskRequireItem((GrowContainer)(object)pot2, ref array))
					{
						val = ((GrowContainerBehaviour)result4).GetItemSlotContainingRequiredItem((IItemSlotOwner)(object)((NPC)((GrowContainerBehaviour)result4)._botanist).Inventory, array);
					}
					ItemInstance val2 = ((val != null) ? val.ItemInstance.GetCopy(1) : null);
					if (val2 == null)
					{
						break;
					}
					if (!Utils.Is<SoilDefinition>(val2.Definition, out SoilDefinition result6) || (Object)(object)result6 == (Object)null)
					{
						MelonDebug.Msg("No soil in inventory");
						((Behaviour)result4).Disable_Networked((NetworkConnection)null);
						break;
					}
					if (((GrowContainerBehaviour)result4).CheckSuccess(val2))
					{
						MelonCoroutines.Start(PourerRoutine(result4, result5, val, result6));
					}
					else
					{
						((Behaviour)result4).Disable_Networked((NetworkConnection)null);
					}
				}
			}
		}

		private static HashSet<GridItem> GetItemsAroundItem(GridItem item)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Expected O, but got Unknown
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Expected O, but got Unknown
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Expected O, but got Unknown
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Expected O, but got Unknown
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Expected O, but got Unknown
			Coordinate origin = new Coordinate(item._originCoordinate);
			List<Coordinate> list = new List<Coordinate>();
			for (int i = -1; i <= 2; i++)
			{
				list.Add(new Coordinate(i, -1));
				list.Add(new Coordinate(i, 2));
			}
			for (int j = 0; j <= 1; j++)
			{
				list.Add(new Coordinate(-1, j));
				list.Add(new Coordinate(2, j));
			}
			List<Coordinate> list2 = list.Select((Coordinate offset) => origin + Coordinate.RotateCoordinates(offset, (float)item._rotation)).ToList();
			HashSet<GridItem> hashSet = new HashSet<GridItem>();
			foreach (Coordinate item2 in list2)
			{
				Tile tile = item.OwnerGrid.GetTile(item2);
				if ((Object)(object)tile == (Object)null)
				{
					continue;
				}
				foreach (GridItem buildableOccupant in tile.BuildableOccupants)
				{
					hashSet.Add(buildableOccupant);
				}
			}
			return hashSet;
		}

		private static IEnumerator PourerRoutine(AddSoilToGrowContainerBehaviour addSoilToGrowContainerBehaviour, SoilPourer soilPourer, ItemSlot slot, SoilDefinition soilDefinition)
		{
			float waitTime = ((GrowContainerBehaviour)addSoilToGrowContainerBehaviour).GetActionDuration() / ((Employee)((GrowContainerBehaviour)addSoilToGrowContainerBehaviour)._botanist).CurrentWorkSpeed;
			waitTime *= 0.25f;
			soilPourer.SetSoil((NetworkConnection)null, ((BaseItemDefinition)soilDefinition).ID);
			yield return (object)new WaitForSeconds(waitTime);
			if (!soilPourer.isDispensing)
			{
				soilPourer.PourSoil();
			}
			ItemInstance usedItem;
			try
			{
				usedItem = ((slot != null) ? slot.ItemInstance.GetCopy(1) : null);
			}
			catch (Exception)
			{
				yield break;
			}
			((GrowContainerBehaviour)addSoilToGrowContainerBehaviour).OnStopPerformAction();
			((GrowContainerBehaviour)addSoilToGrowContainerBehaviour).OnActionSuccess(usedItem);
			if (slot != null && slot.Quantity > 0)
			{
				slot.ChangeQuantity(-1, false);
			}
			((Behaviour)addSoilToGrowContainerBehaviour).Disable_Networked((NetworkConnection)null);
			if (Utils.Is<Botanist>(((Behaviour)addSoilToGrowContainerBehaviour).Npc, out Botanist botanist))
			{
				Botanist obj = botanist;
				if (obj != null)
				{
					((Employee)obj).SetIdle(true);
				}
			}
		}
	}
}
namespace EmployeeTweaks.Network
{
	internal interface INetworkManager : IDisposable
	{
		bool IsInLobby { get; }

		bool IsHost { get; }

		bool IsSingleplayer { get; }

		bool IsServer { get; }

		void Update();

		void BroadcastStation(string stationGuid, bool value);
	}
	public class SetUnpackageStation : P2PMessage
	{
		public override string MessageType => "SetUnpackageStation";

		public string StationGuid { get; set; }

		public bool IsUnpackageStation { get; set; }

		public override byte[] Serialize()
		{
			string s = ((P2PMessage)this).CreateJsonBase($"\"StationGuid\":{StationGuid},\"IsUnpackageStation\":\"{IsUnpackageStation}\"");
			return Encoding.UTF8.GetBytes(s);
		}

		public override void Deserialize(byte[] data)
		{
			string text = Encoding.UTF8.GetString(data);
			((P2PMessage)this).ParseJsonBase(text);
			StationGuid = ((P2PMessage)this).ExtractJsonValue(text, "StationGuid");
			IsUnpackageStation = bool.Parse(((P2PMessage)this).ExtractJsonValue(text, "IsUnpackageStation"));
		}
	}
	internal static class NetworkLoader
	{
		internal static INetworkManager? Create()
		{
			if (AppDomain.CurrentDomain.GetAssemblies().All((Assembly a) => a.GetName().Name != "SteamNetworkLib"))
			{
				return null;
			}
			return CreateInternal();
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private static INetworkManager? CreateInternal()
		{
			try
			{
				NetworkManager networkManager = new NetworkManager();
				networkManager.Initialize();
				return networkManager;
			}
			catch (Exception arg)
			{
				MelonLogger.Warning($"Failed to initialize network manager: {arg}. If you're playing singleplayer, you may disregard this message.");
				return null;
			}
		}
	}
	internal class NetworkManager : INetworkManager, IDisposable
	{
		private SteamNetworkClient? _client;

		private Instance _logger;

		public bool IsInLobby
		{
			get
			{
				SteamNetworkClient? client = _client;
				return client != null && client.IsInLobby;
			}
		}

		public bool IsHost
		{
			get
			{
				SteamNetworkClient? client = _client;
				return client != null && client.IsHost;
			}
		}

		public bool IsSingleplayer => !IsInLobby;

		public bool IsServer => IsHost || IsSingleplayer;

		public NetworkManager()
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Expected O, but got Unknown
			_logger = new Instance("EmployeeTweaks.NetworkManager");
		}

		public bool Initialize()
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Expected O, but got Unknown
			try
			{
				_client = new SteamNetworkClient();
				if (!_client.Initialize())
				{
					_logger.Error("Failed to initialize SteamNetworkClient.");
					return false;
				}
				if (!Melon<EmployeeTweaks>.Instance.SettingsRegistry.InitializeNetwork(_client))
				{
					_logger.Error("Failed to initialize networked preferences. Preferences will be local-only.");
					return false;
				}
				RegisterMessageHandlers();
				RegisterLobbyHandlers();
				_logger.Msg("SteamNetworkClient initialized successfully.");
				return true;
			}
			catch (Exception arg)
			{
				_logger.Warning($"Exception during SteamNetworkClient initialization: {arg}");
				_client = null;
				return false;
			}
		}

		private void RegisterMessageHandlers()
		{
			SteamNetworkClient? client = _client;
			if (client != null)
			{
				client.RegisterMessageHandler<SetUnpackageStation>((Action<SetUnpackageStation, CSteamID>)OnSetUnpackageStation);
			}
		}

		private void RegisterLobbyHandlers()
		{
			if (_client != null)
			{
				_client.OnMemberJoined += OnMemberJoined;
			}
		}

		public void Update()
		{
			SteamNetworkClient? client = _client;
			if (client != null)
			{
				client.ProcessIncomingMessages();
			}
		}

		public void Dispose()
		{
			SteamNetworkClient? client = _client;
			if (client != null)
			{
				client.Dispose();
			}
		}

		public void BroadcastStation(string stationGuid, bool value)
		{
			SetUnpackageStation setUnpackageStation = new SetUnpackageStation
			{
				StationGuid = stationGuid,
				IsUnpackageStation = value
			};
			_logger.Debug($"Broadcasting station change: StationGUID={stationGuid}, value={value}");
			SteamNetworkClient? client = _client;
			if (client != null)
			{
				client.BroadcastMessage((P2PMessage)(object)setUnpackageStation);
			}
		}

		private async void OnMemberJoined(object sender, MemberJoinedEventArgs e)
		{
			if (!IsHost || _client == null)
			{
				return;
			}
			_logger.Msg("Member joined: " + e.Member.DisplayName);
			if (UnpackageSave.Instance?.UnpackageStations == null)
			{
				return;
			}
			foreach (Guid key in UnpackageSave.Instance.UnpackageStations.Keys)
			{
				SetUnpackageStation message = new SetUnpackageStation
				{
					StationGuid = key.ToString(),
					IsUnpackageStation = UnpackageSave.Instance.UnpackageStations[key]
				};
				await _client.SendMessageToPlayerAsync(e.Member.SteamId, (P2PMessage)(object)message);
			}
		}

		private void OnSetUnpackageStation(SetUnpackageStation message, CSteamID cSteamID)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			SteamNetworkClient? client = _client;
			CSteamID? val = ((client != null) ? new CSteamID?(client.LocalPlayerId) : ((CSteamID?)null));
			if (!val.HasValue || !(cSteamID == val.GetValueOrDefault()))
			{
				_logger.Debug($"Received OnSetUnpackageStation: StationGUID={message.StationGuid}, value={message.IsUnpackageStation}");
				MelonCoroutines.Start(ProcessMessage());
			}
			IEnumerator ProcessMessage()
			{
				yield return ExponentialBackoff(delegate
				{
					//IL_0005: Unknown result type (might be due to invalid IL or missing references)
					//IL_000a: Unknown result type (might be due to invalid IL or missing references)
					Scene sceneByName = SceneManager.GetSceneByName("Main");
					return ((Scene)(ref sceneByName)).isLoaded;
				}, 1f, 30f, 300f);
				try
				{
					UnpackageSave save = UnpackageSave.Instance;
					Guid guid = Guid.Parse(message.StationGuid);
					if (save?.UnpackageStations != null)
					{
						if (!save.UnpackageStations.TryAdd(guid, value: true))
						{
							save.UnpackageStations[guid] = message.IsUnpackageStation;
						}
						_logger.Msg($"Set unpackage station {message.StationGuid} to {message.IsUnpackageStation}");
					}
				}
				catch (Exception arg)
				{
					_logger.Error($"Failed to set unpackage station from network: {arg}");
				}
			}
		}

		private static IEnumerator ExponentialBackoff(Func<bool> predicate, float initialDelay, float finalDelay, float timeout)
		{
			float delay = initialDelay;
			float elapsed = 0f;
			while (!predicate() && elapsed < timeout)
			{
				yield return (object)new WaitForSeconds(delay);
				elapsed += delay;
				delay = Mathf.Min(delay * 2f, finalDelay);
			}
		}
	}
}
namespace EmployeeTweaks.Helpers
{
	public class DependenciesChecker
	{
		public class MissingDependencyInfo(string name, string version, List<DependencyUrl> urls, bool isRequired, string reason)
		{
			public string Name { get; set; } = name;

			public string Version { get; set; } = version;

			public List<DependencyUrl> Urls { get; set; } = urls;

			public bool IsRequired { get; set; } = isRequired;

			public string Reason { get; set; } = reason;
		}

		private static readonly Instance Logger = new Instance("EmployeeTweaks.DependenciesChecker");

		private readonly List<DependencyInfo> _dependencies = new List<DependencyInfo>();

		private List<MissingDependencyInfo> _missingDependencies = new List<MissingDependencyInfo>();

		public bool ShowMenuBanner { get; set; } = true;

		public bool ShowBannerIfOptionalOnly { get; set; } = false;

		public bool UnloadIfMissingRequired { get; set; } = false;

		public void AddDependency(DependencyInfo dependency)
		{
			_dependencies.Add(dependency);
		}

		public void ProcessAndAlert()
		{
			CheckDependencies();
			if (_missingDependencies.Count != 0)
			{
				PrintMissing();
				if (ShowMenuBanner)
				{
					ShowBanner();
				}
				MelonCoroutines.Start(DelayedUnload());
			}
		}

		private void CheckDependencies()
		{
			_missingDependencies = new List<MissingDependencyInfo>();
			foreach (DependencyInfo dependency in _dependencies)
			{
				MissingDependencyInfo missingDependencyInfo = IsPresent(dependency);
				if (missingDependencyInfo != null)
				{
					_missingDependencies.Add(missingDependencyInfo);
				}
			}
		}

		private void PrintMissing()
		{
			Logger.Msg("Missing dependencies:");
			foreach (MissingDependencyInfo missingDependency in _missingDependencies)
			{
				if (missingDependency.IsRequired)
				{
					Logger.Error("- " + missingDependency.Name + " (min version " + missingDependency.Version + "): required - " + missingDependency.Reason);
				}
				else
				{
					Logger.Warning("- " + missingDependency.Name + " (min version " + missingDependency.Version + "): optional - " + missingDependency.Reason);
				}
				if (missingDependency.Urls.Count == 0)
				{
					continue;
				}
				Logger.Msg("  Possible sources:");
				foreach (DependencyUrl url in missingDependency.Urls)
				{
					Logger.Msg("  - " + url.SourceName + ": " + url.Url);
				}
			}
		}

		private void ShowBanner()
		{
			((MelonEventBase<LemonAction<int, string>>)(object)MelonEvents.OnSceneWasLoaded).Subscribe((LemonAction<int, string>)delegate(int _, string name)
			{
				if (!(name != "Menu"))
				{
					MissingDepsPanelCreator.Show(this, _missingDependencies);
				}
			}, 0, false);
			((MelonEventBase<LemonAction<int, string>>)(object)MelonEvents.OnSceneWasUnloaded).Subscribe((LemonAction<int, string>)delegate(int _, string name)
			{
				if (!(name != "Menu"))
				{
					MissingDepsPanelCreator.Hide();
				}
			}, 0, false);
			MissingDepsPanelCreator.Show(this, _missingDependencies);
		}

		private IEnumerator DelayedUnload()
		{
			yield return (object)new WaitForSeconds(5f);
			if (UnloadIfMissingRequired && _missingDependencies.Any((MissingDependencyInfo d) => d.IsRequired))
			{
				Logger.Warning("Missing required dependencies detected and UnloadIfMissingRequired is true, unloading mod.");
				((MelonBase)Melon<EmployeeTweaks>.Instance).Unregister("Missing required dependencies", false);
			}
		}

		private static MissingDependencyInfo? IsPresent(DependencyInfo dependency)
		{
			Assembly foundInDomain = AppDomain.CurrentDomain.GetAssemblies().FirstOrDefault((Assembly assembly) => assembly.GetName().Name == dependency.AssemblyName);
			if (foundInDomain == null)
			{
				Logger.Debug(dependency.AssemblyName + " not found in AppDomain, marking as missing.");
				return new MissingDependencyInfo(dependency.Name, dependency.Version, dependency.Urls, dependency.IsRequired, "Assembly not found");
			}
			MelonMod val = ((IEnumerable<MelonMod>)MelonTypeBase<MelonMod>.RegisteredMelons).FirstOrDefault((Func<MelonMod, bool>)((MelonMod m) => ((MelonBase)m).MelonAssembly.Assembly == foundInDomain));
			if (val == null)
			{
				Logger.Debug(foundInDomain.GetName().Name + " wasn't found in RegisteredMelons.");
				Version version = foundInDomain.GetName().Version;
				if (version == null)
				{
					Logger.Debug(dependency.AssemblyName + " version is not available.");
					return new MissingDependencyInfo(dependency.Name, dependency.Version, dependency.Urls, dependency.IsRequired, "Cannot verify version");
				}
				if (!Version.TryParse(dependency.Version, out Version result))
				{
					Logger.Debug(dependency.AssemblyName + " version is not a valid version.");
					return new MissingDependencyInfo(dependency.Name, dependency.Version, dependency.Urls, dependency.IsRequired, "Invalid version format");
				}
				if (version < result)
				{
					Logger.Debug(dependency.AssemblyName + " version is too old.");
					return new MissingDependencyInfo(dependency.Name, dependency.Version, dependency.Urls, dependency.IsRequired, $"Version {version} found, but {dependency.Version} required");
				}
				return null;
			}
			SemVersion semanticVersion = ((MelonBase)val).Info.SemanticVersion;
			if (semanticVersion == (SemVersion)null)
			{
				Logger.Debug($"{foundInDomain.GetName().Name}'s version {semanticVersion} is not SemVer.");
				if (!Version.TryParse(dependency.Version, out Version result2))
				{
					Logger.Debug(dependency.AssemblyName + " version is not a valid version.");
					return new MissingDependencyInfo(dependency.Name, dependency.Version, dependency.Urls, dependency.IsRequired, "Invalid version format");
				}
				if (!Version.TryParse(((MelonBase)val).Info.Version, out Version result3))
				{
					Logger.Debug(dependency.AssemblyName + " version is not a valid version.");
					return new MissingDependencyInfo(dependency.Name, dependency.Version, dependency.Urls, dependency.IsRequired, "Invalid version format");
				}
				if (result3 < result2)
				{
					Logger.Debug(dependency.AssemblyName + " version is too old.");
					return new MissingDependencyInfo(dependency.Name, dependency.Version, dependency.Urls, dependency.IsRequired, $"Version {result3} found, but {dependency.Version} required");
				}
				return null;
			}
			SemVersion val2 = default(SemVersion);
			if (!SemVersion.TryParse(dependency.Version, ref val2, false))
			{
				Logger.Debug(dependency.AssemblyName + " version is not a valid version.");
				return new MissingDependencyInfo(dependency.Name, dependency.Version, dependency.Urls, dependency.IsRequired, "Invalid version format");
			}
			if (semanticVersion < val2)
			{
				Logger.Debug(dependency.AssemblyName + " version is too old.");
				return new MissingDependencyInfo(dependency.Name, dependency.Version, dependency.Urls, dependency.IsRequired, $"Version {semanticVersion} found, but {dependency.Version} required");
			}
			return null;
		}
	}
	public class DependencyInfo
	{
		public string Name { get; set; }

		public string AssemblyName { get; set; }

		public string Version { get; set; }

		public bool IsRequired { get; set; }

		public List<DependencyUrl> Urls { get; set; }

		public DependencyInfo(string name, string version, string? assemblyName = null, List<DependencyUrl>? urls = null, bool isRequired = true)
		{
			Name = name;
			AssemblyName = assemblyName ?? name;
			Version = version;
			IsRequired = isRequired;
			Urls = urls ?? new List<DependencyUrl>();
		}

		public DependencyInfo()
		{
		}
	}
	public class DependencyUrl
	{
		public string SourceName { get; set; }

		public string Url { get; set; }

		public DependencyUrl(string sourceName, string url)
		{
			SourceName = sourceName;
			Url = url;
		}

		public DependencyUrl()
		{
		}
	}
	internal static class MissingDepsPanelCreator
	{
		private static GameObject? _canvasObject;

		public static void Show(DependenciesChecker instance, List<DependenciesChecker.MissingDependencyInfo> deps)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Expected O, but got Unknown
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Expected O, but got Unknown
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0121: Unknown result type (might be due to invalid IL or missing references)
			//IL_012b: Expected O, but got Unknown
			//IL_0150: Unknown result type (might be due to invalid IL or missing references)
			//IL_0157: Expected O, but got Unknown
			//IL_01a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_022a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0231: Expected O, but got Unknown
			//IL_02f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_02df: Unknown result type (might be due to invalid IL or missing references)
			//IL_032c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0333: Expected O, but got Unknown
			//IL_03a3: Unknown result type (might be due to invalid IL or missing references)
			Hide();
			_canvasObject = new GameObject("MissingDependenciesCanvas");
			Canvas val = _canvasObject.AddComponent<Canvas>();
			val.renderMode = (RenderMode)0;
			val.sortingOrder = 9999;
			_canvasObject.AddComponent<GraphicRaycaster>();
			GameObject val2 = new GameObject("MissingDependenciesPanel");
			val2.transform.SetParent(_canvasObject.transform, false);
			RectTransform val3 = val2.AddComponent<RectTransform>();
			val3.anchorMin = new Vector2(1f, 0.5f);
			val3.anchorMax = new Vector2(1f, 0.5f);
			val3.pivot = new Vector2(1f, 0.5f);
			val3.anchoredPosition = new Vector2(-20f, 0f);
			val3.sizeDelta = new Vector2(420f, 0f);
			Image val4 = val2.AddComponent<Image>();
			((Graphic)val4).color = new Color(0.08f, 0.08f, 0.08f, 0.95f);
			ContentSizeFitter val5 = val2.AddComponent<ContentSizeFitter>();
			val5.verticalFit = (FitMode)2;
			VerticalLayoutGroup val6 = val2.AddComponent<VerticalLayoutGroup>();
			((LayoutGroup)val6).padding = new RectOffset(16, 16, 12, 12);
			((HorizontalOrVerticalLayoutGroup)val6).spacing = 6f;
			((LayoutGroup)val6).childAlignment = (TextAnchor)0;
			((HorizontalOrVerticalLayoutGroup)val6).childForceExpandWidth = true;
			GameObject val7 = new GameObject("Header");
			val7.transform.SetParent(val2.transform, false);
			Text val8 = val7.AddComponent<Text>();
			val8.text = "Missing Dependencies";
			val8.font = Resources.GetBuiltinResource<Font>("Arial.ttf");
			val8.fontSize = 18;
			val8.fontStyle = (FontStyle)1;
			((Graphic)val8).color = Color.white;
			val8.alignment = (TextAnchor)3;
			if (deps.All((DependenciesChecker.MissingDependencyInfo d) => !d.IsRequired) && !instance.ShowBannerIfOptionalOnly)
			{
				Hide();
				return;
			}
			foreach (DependenciesChecker.MissingDependencyInfo dep in deps)
			{
				GameObject val9 = new GameObject("Dep_" + dep.Name);
				val9.transform.SetParent(val2.transform, false);
				val9.AddComponent<LayoutElement>().minHeight = 20f;
				Text val10 = val9.AddComponent<Text>();
				val10.text = "  " + dep.Name + " (min v" + dep.Version + ") - " + dep.Reason;
				val10.font = Resources.GetBuiltinResource<Font>("Arial.ttf");
				val10.fontSize = 15;
				((Graphic)val10).color = (dep.IsRequired ? new Color(1f, 0.4f, 0.4f) : new Color(1f, 0.8f, 0.3f));
				val10.alignment = (TextAnchor)0;
			}
			GameObject val11 = new GameObject("Footer");
			val11.transform.SetParent(val2.transform, false);
			Text val12 = val11.AddComponent<Text>();
			val12.text = "See the console (or log at " + Path.Combine(MelonEnvironment.MelonLoaderLogsDirectory, "Latest.log") + ") for details.";
			val12.font = Resources.GetBuiltinResource<Font>("Arial.ttf");
			val12.fontSize = 14;
			((Graphic)val12).color = new Color(0.6f, 0.6f, 0.6f);
			val12.alignment = (TextAnchor)0;
		}

		public static void Hide()
		{
			if ((Object)(object)_canvasObject != (Object)null)
			{
				Object.Destroy((Object)(object)_canvasObject);
				_canvasObject = null;
			}
		}
	}
	public static class MelonExtensions
	{
		private static readonly Dictionary<string, List<NetworkedMelonEntry>> NetworkedMelonEntries = new Dictionary<string, List<NetworkedMelonEntry>>();

		public static NetworkedMelonEntry<T> GetOrCreateNetworkedEntry<T>(this MelonPreferences_Category category, string identifier, T defaultValue, object? client, object? options, bool announce = true, string? displayName = null, string? description = null, bool isHidden = false, bool dontSaveDefault = false, ValueValidator? validator = null, string? oldIdentifier = null)
		{
			MelonPreferences_Entry<T> orCreateEntry = category.GetOrCreateEntry(identifier, defaultValue, displayName, description, isHidden, dontSaveDefault, validator, oldIdentifier);
			return category.GetOrCreateNetworkedEntry<T>(orCreateEntry, client, options, announce);
		}

		private static NetworkedMelonEntry<T> GetOrCreateNetworkedEntry<T>(this MelonPreferences_Category category, MelonPreferences_Entry<T> entry, object? client, object? options, bool announce = true)
		{
			if (NetworkedMelonEntries.TryGetValue(category.Identifier, out List<NetworkedMelonEntry> value) && value.FirstOrDefault((NetworkedMelonEntry e) => e.Identifier == ((MelonPreferences_Entry)entry).Identifier) is NetworkedMelonEntry<T> result)
			{
				return result;
			}
			NetworkedMelonEntry<T> networkedMelonEntry = new NetworkedMelonEntry<T>(entry, client, options)
			{
				Announce = announce
			};
			if (!NetworkedMelonEntries.ContainsKey(category.Identifier))
			{
				NetworkedMelonEntries.Add(category.Identifier, new List<NetworkedMelonEntry>());
			}
			NetworkedMelonEntries[category.Identifier].Add(networkedMelonEntry);
			return networkedMelonEntry;
		}

		public static MelonPreferences_Entry<T> GetOrCreateEntry<T>(this MelonPreferences_Category category, string identifier, T defaultValue, string? displayName = null, string? description = null, bool isHidden = false, bool dontSaveDefault = false, ValueValidator? validator = null, string? oldIdentifier = null)
		{
			if (category.HasEntry(identifier))
			{
				return category.GetEntry<T>(identifier);
			}
			return category.CreateEntry<T>(identifier, defaultValue, displayName, description, isHidden, dontSaveDefault, validator, oldIdentifier);
		}

		public static void Debug(this Instance logger, string message, bool stacktrace = true)
		{
			MelonDebug.Msg(stacktrace ? ("[" + GetCallerInfo() + "] " + message) : message);
		}

		private static string GetCallerInfo()
		{
			StackTrace stackTrace = new StackTrace();
			for (int i = 2; i < stackTrace.FrameCount; i++)
			{
				StackFrame frame = stackTrace.GetFrame(i);
				MethodBase method = frame.GetMethod();
				if (!(method?.DeclaringType == null))
				{
					return method.DeclaringType.FullName + "." + method.Name;
				}
			}
			return "unknown";
		}
	}
	public class NetworkedMelonEntry(MelonPreferences_Entry entry)
	{
		protected static Assembly? SteamNetworkLibAssembly;

		protected object? SyncVar;

		protected PropertyInfo? SyncVarValueProperty;

		protected PropertyInfo? SyncVarCanWriteProperty;

		protected readonly MelonPreferences_Entry Entry = entry;

		public string Identifier => entry.Identifier;

		public string DisplayName
		{
			get
			{
				return entry.DisplayName;
			}
			set
			{
				entry.DisplayName = value;
			}
		}

		public string Description
		{
			get
			{
				return entry.Description;
			}
			set
			{
				entry.Description = value;
			}
		}

		public string Comment
		{
			get
			{
				return entry.Comment;
			}
			set
			{
				entry.Comment = value;
			}
		}

		public bool IsHidden
		{
			get
			{
				return entry.IsHidden;
			}
			set
			{
				entry.IsHidden = value;
			}
		}

		public bool DontSaveDefault
		{
			get
			{
				return entry.DontSaveDefault;
			}
			set
			{
				entry.DontSaveDefault = value;
			}
		}

		public MelonPreferences_Category Category => entry.Category;

		public ValueValidator Validator => entry.Validator;

		public object BoxedEditedValue
		{
			get
			{
				return entry.BoxedEditedValue;
			}
			set
			{
				entry.BoxedEditedValue = value;
			}
		}

		public MelonEvent<object, object> OnEntryValueChangedUntyped => entry.OnEntryValueChangedUntyped;

		public bool Announce { get; set; } = true;

		public virtual object BoxedValue
		{
			get
			{
				if (!Announce || SyncVar == null)
				{
					return entry.BoxedValue;
				}
				return SyncVarValueProperty.GetValue(SyncVar);
			}
			set
			{
				if (!Announce || SyncVar == null)
				{
					entry.BoxedValue = value;
				}
				else
				{
					SyncVarValueProperty.SetValue(SyncVar, value);
				}
			}
		}

		protected static void LoadSteamNetworkLib()
		{
			if (!(SteamNetworkLibAssembly != null))
			{
				Assembly assembly = AppDomain.CurrentDomain.GetAssemblies().FirstOrDefault((Assembly a) => a.GetName().Name == "SteamNetworkLib");
				if (!(assembly == null))
				{
					SteamNetworkLibAssembly = assembly;
				}
			}
		}

		public string GetEditedValueAsString()
		{
			return entry.GetEditedValueAsString();
		}

		public string GetDefaultValueAsString()
		{
			return entry.GetDefaultValueAsString();
		}

		public string GetValueAsString()
		{
			return entry.GetValueAsString();
		}

		public Type GetReflectedType()
		{
			return entry.GetReflectedType();
		}

		public string GetExceptionMessage(string submsg)
		{
			return entry.GetExceptionMessage(submsg);
		}

		public virtual void ResetToDefault()
		{
			if (!Announce || SyncVar == null)
			{
				entry.ResetToDefault();
			}
			else if ((bool)SyncVarCanWriteProperty.GetValue(SyncVar))
			{
				entry.ResetToDefault();
				SyncVarValueProperty.SetValue(SyncVar, entry.BoxedValue);
			}
			else
			{
				MelonLogger.Warning("Resetting clientside entry '" + Identifier + "' - real value is host-controlled");
				entry.ResetToDefault();
			}
		}

		protected void HandleSyncVarChanged(object oldValue, object newValue)
		{
			if ((bool)SyncVarCanWriteProperty.GetValue(SyncVar))
			{
				ValueValidator validator = entry.Validator;
				if (validator == null || validator.IsValid(newValue))
				{
					entry.BoxedValue = newValue;
				}
				else
				{
					SyncVarValueProperty.SetValue(SyncVar, oldValue);
				}
			}
			else
			{
				ValueValidator validator2 = entry.Validator;
				if (validator2 == null || validator2.IsValid(newValue))
				{
					OnClientSyncUpdate(oldValue, newValue);
				}
			}
		}

		protected virtual void OnClientSyncUpdate(object oldValue, object newValue)
		{
			entry.OnEntryValueChangedUntyped.Invoke(oldValue, newValue);
		}
	}
	public class NetworkedMelonEntry<T> : NetworkedMelonEntry
	{
		private MelonPreferences_Entry<T> TypedEntry => (MelonPreferences_Entry<T>)(object)entry;

		public T Value
		{
			get
			{
				if (!base.Announce || SyncVar == null)
				{
					return TypedEntry.Value;
				}
				return (T)SyncVarValueProperty.GetValue(SyncVar);
			}
			set
			{
				if (!base.Announce || SyncVar == null)
				{
					TypedEntry.Value = value;
				}
				else
				{
					SyncVarValueProperty.SetValue(SyncVar, value);
				}
			}
		}

		public T EditedValue
		{
			get
			{
				return TypedEntry.EditedValue;
			}
			set
			{
				TypedEntry.EditedValue = value;
			}
		}

		public T DefaultValue => TypedEntry.DefaultValue;

		public MelonEvent<T, T> OnEntryValueChanged => TypedEntry.OnEntryValueChanged;

		public override object BoxedValue
		{
			get
			{
				return Value;
			}
			set
			{
				Value = (T)value;
			}
		}

		public override void ResetToDefault()
		{
			if (!base.Announce || SyncVar == null)
			{
				((MelonPreferences_Entry)TypedEntry).ResetToDefault();
				return;
			}
			if ((bool)SyncVarCanWriteProperty.GetValue(SyncVar))
			{
				SyncVarValueProperty.SetValue(SyncVar, TypedEntry.DefaultValue);
				return;
			}
			MelonLogger.Warning("Resetting clientside entry '" + base.Identifier + "' - real value is host-controlled");
			((MelonPreferences_Entry)TypedEntry).ResetToDefault();
		}

		public NetworkedMelonEntry(MelonPreferences_Entry<T> entry, object? client = null, object? options = null)
			: base((MelonPreferences_Entry)(object)entry)
		{
			NetworkedMelonEntry.LoadSteamNetworkLib();
			if (NetworkedMelonEntry.SteamNetworkLibAssembly != null && client != null && options != null)
			{
				TryInitialize(client, options);
			}
		}

		private void TryInitialize(object client, object options)
		{
			Type type = NetworkedMelonEntry.SteamNetworkLibAssembly.GetTypes().FirstOrDefault((Type t) => t.Name == "HostSyncVar`1" && t.IsGenericType);
			if (type == null)
			{
				return;
			}
			Type type2 = type.MakeGenericType(typeof(T));
			MethodInfo method = client.GetType().GetMethod("CreateHostSyncVar", BindingFlags.Instance | BindingFlags.Public);
			if (method == null)
			{
				return;
			}
			MethodInfo methodInfo = method.MakeGenericMethod(typeof(T));
			SyncVar = methodInfo.Invoke(client, new object[4]
			{
				"NME_" + base.Category.Identifier + "_" + base.Identifier,
				TypedEntry.Value,
				options,
				null
			});
			if (SyncVar == null)
			{
				return;
			}
			SyncVarValueProperty = type2.GetProperty("Value");
			if (SyncVarValueProperty == null)
			{
				SyncVar = null;
				return;
			}
			SyncVarCanWriteProperty = type2.GetProperty("CanWrite");
			if (SyncVarCanWriteProperty == null)
			{
				SyncVar = null;
				return;
			}
			EventInfo eventInfo = type2.GetEvent("OnValueChanged");
			if (eventInfo == null)
			{
				SyncVar = null;
				return;
			}
			MethodInfo method2 = typeof(NetworkedMelonEntry<T>).GetMethod("OnSyncVarValueChanged", BindingFlags.Instance | BindingFlags.NonPublic);
			if (method2 == null)
			{
				SyncVar = null;
				return;
			}
			Delegate handler = Delegate.CreateDelegate(eventInfo.EventHandlerType, this, method2);
			eventInfo.AddEventHandler(SyncVar, handler);
		}

		protected override void OnClientSyncUpdate(object oldValue, object newValue)
		{
			if (oldValue is T val && newValue is T val2)
			{
				TypedEntry.OnEntryValueChanged.Invoke(val, val2);
			}
		}

		private void OnSyncVarValueChanged(T oldValue, T newValue)
		{
			HandleSyncVarChanged(oldValue, newValue);
		}
	}
	public static class Il2CppListExtensions
	{
		public static IEnumerable<T> AsEnumerable<T>(this List<T> list)
		{
			return list ?? new List<T>();
		}

		public static object ToNativeList<T>(this List<T> source)
		{
			return source ?? new List<T>();
		}
	}
	public static class Utils
	{
		private static readonly Instance Logger = new Instance("EmployeeTweaks-Utils");

		public static T? FindObjectByName<T>(string objectName) where T : Object
		{
			try
			{
				T[] array = Resources.FindObjectsOfTypeAll<T>();
				foreach (T val in array)
				{
					if (!(((Object)val).name != objectName))
					{
						Logger.Debug("Found " + typeof(T).Name + " '" + objectName + "' directly in loaded objects");
						return val;
					}
				}
				return default(T);
			}
			catch (Exception ex)
			{
				Logger.Error("Error finding " + typeof(T).Name + " '" + objectName + "': " + ex.Message);
				return default(T);
			}
		}

		public static List<T> GetAllComponentsInChildrenRecursive<T>(GameObject obj) where T : Component
		{
			List<T> list = new List<T>();
			if ((Object)(object)obj == (Object)null)
			{
				return list;
			}
			T[] components = obj.GetComponents<T>();
			if (components.Length != 0)
			{
				list.AddRange(components);
			}
			for (int i = 0; i < obj.transform.childCount; i++)
			{
				Transform child = obj.transform.GetChild(i);
				list.AddRange(GetAllComponentsInChildrenRecursive<T>(((Component)child).gameObject));
			}
			return list;
		}

		public static bool Is<T>(object obj, out T? result) where T : class
		{
			if (obj is T val)
			{
				result = val;
				return true;
			}
			result = null;
			return false;
		}

		public static bool Is2<T>(object obj, out T? result) where T : class
		{
			result = obj as T;
			return result != null;
		}

		public static IEnumerator WaitForPlayer(IEnumerator routine)
		{
			while ((Object)(object)Player.Local == (Object)null || (Object)(object)((Component)Player.Local).gameObject == (Object)null)
			{
				yield return null;
			}
			MelonCoroutines.Start(routine);
		}

		public static IEnumerator WaitForNetwork(IEnumerator routine)
		{
			while (!InstanceFinder.IsServer && !InstanceFinder.IsClient)
			{
				yield return null;
			}
			MelonCoroutines.Start(routine);
		}

		public static IEnumerator WaitForCondition(Func<bool> condition, float timeout = float.NaN, Action? onTimeout = null, Action? onFinish = null)
		{
			float startTime = Time.time;
			while (!condition())
			{
				if (!float.IsNaN(timeout) && Time.time - startTime > timeout)
				{
					onTimeout?.Invoke();
					yield break;
				}
				yield return null;
			}
			onFinish?.Invoke();
		}

		public static string GetHierarchyPath(this Transform transform)
		{
			if ((Object)(object)transform == (Object)null)
			{
				return "null";
			}
			string text = ((Object)transform).name;
			Transform parent = transform.parent;
			while ((Object)(object)parent != (Object)null)
			{
				text = ((Object)parent).name + "/" + text;
				parent = parent.parent;
			}
			return text;
		}

		public static T GetOrAddComponent<T>(this GameObject gameObject) where T : Component
		{
			T component = gameObject.GetComponent<T>();
			if ((Object)(object)component != (Object)null)
			{
				return component;
			}
			component = gameObject.AddComponent<T>();
			Logger.Debug("Added component " + typeof(T).Name + " to GameObject " + ((Object)gameObject).name);
			return component;
		}

		public static Material? DrawDebugVisuals(this GameObject gameObject, Color? color = null)
		{
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Expected O, but got Unknown
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_012b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0131: Unknown result type (might be due to invalid IL or missing references)
			//IL_0137: Unknown result type (might be due to invalid IL or missing references)
			//IL_013d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0147: Unknown result type (might be due to invalid IL or missing references)
			Renderer component = gameObject.GetComponent<Renderer>();
			if ((Object)(object)component == (Object)null)
			{
				Logger.Error("GameObject " + ((Object)gameObject).name + " has no Renderer component");
				return null;
			}
			Color valueOrDefault = color.GetValueOrDefault();
			if (!color.HasValue)
			{
				((Color)(ref valueOrDefault))..ctor(1f, 0f, 1f, 0.5f);
				color = valueOrDefault;
			}
			Shader val = Shader.Find("Universal Render Pipeline/Lit");
			if ((Object)(object)val == (Object)null)
			{
				return null;
			}
			Material val2 = new Material(val);
			if (val2.HasProperty("_Surface"))
			{
				val2.SetFloat("_Surface", 1f);
			}
			Color value = color.Value;
			if (value.a <= 0f)
			{
				value.a = 0.2f;
			}
			if (val2.HasProperty("_BaseColor"))
			{
				val2.SetColor("_BaseColor", value);
			}
			if (val2.HasProperty("_EmissionColor"))
			{
				val2.EnableKeyword("_EMISSION");
				val2.SetColor("_EmissionColor", new Color(value.r, value.g, value.b) * 1.5f);
			}
			val2.SetInt("_ZWrite", 0);
			val2.renderQueue = 3000;
			Material material = component.material;
			component.material = val2;
			return material;
		}
	}
}
namespace System.Runtime.CompilerServices
{
	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
	internal sealed class IgnoresAccessChecksToAttribute : Attribute
	{
		internal IgnoresAccessChecksToAttribute(string assemblyName)
		{
		}
	}
}